Instant Download Modern C++ For Absolute Beginners: A Friendly Introduction To The C++ Programming Language and C++11 To C++23 Standards, 2nd Edition Slobodan Dmitrović PDF All Chapters
Instant Download Modern C++ For Absolute Beginners: A Friendly Introduction To The C++ Programming Language and C++11 To C++23 Standards, 2nd Edition Slobodan Dmitrović PDF All Chapters
com
OR CLICK HERE
DOWLOAD NOW
https://ebookmass.com/product/modern-c-for-absolute-beginners-2nd-
edition-slobodan-dmitrovic/
ebookmass.com
https://ebookmass.com/product/modern-c-for-absolute-beginners-second-
edition-solbodan-dmitrovic/
ebookmass.com
https://ebookmass.com/product/workbook-for-radiologic-science-for-
technologists-e-book-physics-biology-and-protection-11th-edition-
ebook-pdf/
ebookmass.com
The Tokyo University Trial and the Struggle Against Order
in Postwar Japan Christopher Perkins
https://ebookmass.com/product/the-tokyo-university-trial-and-the-
struggle-against-order-in-postwar-japan-christopher-perkins/
ebookmass.com
https://ebookmass.com/product/basic-electronics-quickstart-guide-
understanding-the-basic-john-thomas/
ebookmass.com
https://ebookmass.com/product/bad-apple-lancaster-hill/
ebookmass.com
https://ebookmass.com/product/captured-and-bound-rugged-mountain-
goliaths-mountain-goliaths-rugged-mountain-ink-book-4-khloe-summers/
ebookmass.com
https://ebookmass.com/product/autoimmune-diseases-in-domestic-animals-
ian-r-tizard/
ebookmass.com
Casarett & Doull's Essentials of Toxicology 4th Edition
Ph.D. Klaassen
https://ebookmass.com/product/casarett-doulls-essentials-of-
toxicology-4th-edition-ph-d-klaassen/
ebookmass.com
Modern C++ for Absolute
Beginners
A Friendly Introduction to the C++
Programming Language and C++11
to C++23 Standards
Second Edition
Slobodan Dmitrović
Modern C++ for Absolute Beginners: A Friendly Introduction to the C++
Programming Language and C++11 to C++23 Standards
Slobodan Dmitrović
Belgrade, Serbia
Chapter 1: Introduction�������������������������������������������������������������������������������������������� 1
Chapter 5: Types����������������������������������������������������������������������������������������������������� 13
Fundamental Types��������������������������������������������������������������������������������������������������������������������� 13
Boolean���������������������������������������������������������������������������������������������������������������������������������� 13
Character Type����������������������������������������������������������������������������������������������������������������������� 14
Integer Types������������������������������������������������������������������������������������������������������������������������� 16
Floating-Point Types�������������������������������������������������������������������������������������������������������������� 18
Type void������������������������������������������������������������������������������������������������������������������������������� 18
Type Modifiers����������������������������������������������������������������������������������������������������������������������������� 19
Variable Declaration, Definition, and Initialization����������������������������������������������������������������������� 19
v
Table of Contents
Chapter 6: Exercises����������������������������������������������������������������������������������������������� 21
Hello World and Comments��������������������������������������������������������������������������������������������������������� 21
Declaration���������������������������������������������������������������������������������������������������������������������������������� 21
Definition������������������������������������������������������������������������������������������������������������������������������������� 22
Initialization��������������������������������������������������������������������������������������������������������������������������������� 22
Chapter 7: Operators���������������������������������������������������������������������������������������������� 25
Assignment Operator������������������������������������������������������������������������������������������������������������������ 25
Arithmetic Operators������������������������������������������������������������������������������������������������������������������� 25
Compound Assignment Operators���������������������������������������������������������������������������������������������� 27
Increment/Decrement Operators������������������������������������������������������������������������������������������������ 28
Chapter 9: Exercises����������������������������������������������������������������������������������������������� 31
Standard Input���������������������������������������������������������������������������������������������������������������������������� 31
Two Inputs����������������������������������������������������������������������������������������������������������������������������������� 31
Multiple Inputs���������������������������������������������������������������������������������������������������������������������������� 32
Inputs and Arithmetic Operations����������������������������������������������������������������������������������������������� 33
Postincrement and Compound Assignment�������������������������������������������������������������������������������� 33
Integral and Floating-Point Division�������������������������������������������������������������������������������������������� 34
vi
Table of Contents
Substrings����������������������������������������������������������������������������������������������������������������������������������� 48
Finding a Substring��������������������������������������������������������������������������������������������������������������������� 49
vii
Table of Contents
viii
Table of Contents
ix
Table of Contents
x
Table of Contents
xi
Table of Contents
xii
Table of Contents
std::unordered_set�������������������������������������������������������������������������������������������������������������� 288
std::unordered_map������������������������������������������������������������������������������������������������������������ 290
std::tuple����������������������������������������������������������������������������������������������������������������������������� 292
static_assert������������������������������������������������������������������������������������������������������������������������ 293
Introduction to Concurrency������������������������������������������������������������������������������������������������ 294
Deleted and Defaulted Functions���������������������������������������������������������������������������������������� 301
Type Aliases������������������������������������������������������������������������������������������������������������������������� 304
C++14��������������������������������������������������������������������������������������������������������������������������������������� 304
Binary Literals��������������������������������������������������������������������������������������������������������������������� 305
Digit Separators������������������������������������������������������������������������������������������������������������������� 306
Auto for Functions��������������������������������������������������������������������������������������������������������������� 306
Generic Lambdas����������������������������������������������������������������������������������������������������������������� 307
std::make_unique���������������������������������������������������������������������������������������������������������������� 307
C++17��������������������������������������������������������������������������������������������������������������������������������������� 308
Nested Namespaces������������������������������������������������������������������������������������������������������������ 308
Constexpr Lambdas������������������������������������������������������������������������������������������������������������� 309
Structured Bindings������������������������������������������������������������������������������������������������������������� 309
std::filesystem��������������������������������������������������������������������������������������������������������������������� 311
std::string_view������������������������������������������������������������������������������������������������������������������� 315
std::any�������������������������������������������������������������������������������������������������������������������������������� 317
std::variant�������������������������������������������������������������������������������������������������������������������������� 319
C++20��������������������������������������������������������������������������������������������������������������������������������������� 322
Modules������������������������������������������������������������������������������������������������������������������������������� 323
Concepts������������������������������������������������������������������������������������������������������������������������������ 325
Lambda Templates�������������������������������������������������������������������������������������������������������������� 329
[likely] and [unlikely] Attributes������������������������������������������������������������������������������������������� 330
Ranges��������������������������������������������������������������������������������������������������������������������������������� 332
Coroutines��������������������������������������������������������������������������������������������������������������������������� 336
std::span������������������������������������������������������������������������������������������������������������������������������ 337
Mathematical Constants������������������������������������������������������������������������������������������������������ 338
xiii
Table of Contents
C++23��������������������������������������������������������������������������������������������������������������������������������������� 339
Multidimensional Subscript Operator���������������������������������������������������������������������������������� 340
Literal Suffixes for size_t����������������������������������������������������������������������������������������������������� 340
The #warning Preprocessor Directive��������������������������������������������������������������������������������� 341
The std::string::contains( ) Member Function���������������������������������������������������������������������� 341
std::print������������������������������������������������������������������������������������������������������������������������������ 343
Index��������������������������������������������������������������������������������������������������������������������� 433
xiv
About the Author
Slobodan Dmitrović is a software consultant, trainer, and
author of several programming books. He is a professional
R&D software developer with two decades of experience in
the industry. Slobodan provides C++ training courses for
corporate clients and academic institutions. Connect with
Slobodan at https://www.linkedin.com/in/slobodan-
dmitrovic/.
xv
About the Technical Reviewer
Germán González-Morris is a polyglot software architect/
engineer with 20+ years of experience in the field, having
knowledge in Java, Spring, C, Julia, Python, Haskell, and
JavaScript, among others. He works for cloud (architecture)
and web distributed applications. Germán loves math
puzzles (including reading Knuth), swimming, and table
tennis. Also, he has reviewed several books including an
application container book (WebLogic) and books on
languages (C, Haskell, TypeScript, WebAssembly, Math for
coders, regexp, Julia, Algorithms). For more details, you can
visit his blog (https://devwebcl.blogspot.com/) or Twitter
account (@devwebcl).
xvii
Acknowledgments
I want to thank my friends, readers, and fellow C++ peers who have supported me in
writing the second edition of this book.
I am thankful to the entire C++ community for their help and feedback. I would
like to thank Rainer Grimm, Klaus Iglberger, Jens Weller, Bartłomiej Filipek, and
many others.
My most profound appreciation goes to S. Antonijević, Ron and Brankica, and Saša
Popović for their ongoing support.
xix
About the Second Edition
The second edition of this book is updated to include the notable features inside the
C++23 standard.
I have revised and updated numerous chapters with more relevant information and
clarification.
The second edition includes more diagrams to represent certain concepts better.
I have also added the output for all the code snippets.
The book now has a chapter entirely dedicated to various projects.
My intent with the second edition was to provide a simplified, updated, and accurate
introduction to the modern C++ programming language.
xxi
CHAPTER 1
Introduction
Congratulations on choosing to learn the C++ programming language, and thank you for
picking up this book. I will try to introduce you to a beautiful world of C++ to the best of
my abilities.
This book is an effort to introduce the reader to the C++ programming language in
a structured, straightforward, and friendly manner. We will use the “just enough theory
and plenty of examples” approach whenever possible.
To me, C++ is a wonderful product of the human intellect. Over the years, I have
certainly come to think of it as a thing of beauty and elegance. C++ is a language like no
other, surprising in its complexity yet wonderfully sleek and elegant in so many ways. It
is also a language that cannot be learned by guessing, one that is easy to get wrong and
challenging to get right.
In this book, we will get familiar with the language basics first. Then, we will move on
to classes, templates, and the C++ Standard Library. Once we got these covered, we will
describe the modern C++ standards in more detail.
After each section, source code exercises will help us adopt the learned material
more efficiently.
Finally, we will create a couple of source code projects. Let us get started!
1
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_1
CHAPTER 2
What Is C++?
C++ is a programming language – a standardized, general-purpose, object-oriented,
compiled language. Every C++ compiler is accompanied by a set of useful functions
and containers called the C++ Standard Library. Bjarne Stroustrup created C++ as an
extension to a C programming language. Still, C++ evolved to be a completely different
programming language.
Let us emphasize this: C and C++ are two different languages. C++ started as “C with
classes,” but it is now a completely different language. So, C++ is not C; C++ is not C with
classes; it is just C++. And there is no such thing as a C/C++ programming language.
C++ is widely used for so-called systems programming as well as application
programming. C++ is a language that allows us to get down to the metal where we can
perform low-level routines if needed or soar high using abstraction mechanisms such as
templates and classes.
C++ Standards
C++ is governed by the ISO C++ standard. There are multiple ISO C++ standards listed
here in chronological order: C++03, C++11, C++14, C++17, C++20, and the upcoming
C++23 standard.
Every C++ standard, starting with C++11 onward, is referred to as “modern C++.”
And modern C++ is what we will be teaching in this book.
3
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_2
CHAPTER 3
C++ Compilers
C++ programs are usually a collection of some C++ code spread across one or multiple
source and header files. Source files, by convention, have the .cpp extension, and header
files, by convention, have the .h extension. Other extensions are also possible. Both
header and source files are regular text files containing some C++ source code. The C++
compiler is a program that compiles these files and turns them into object files. A linker
then links object files together to create an executable file or a library. At the time of
writing, some of the more popular C++ compilers are
–– The g++ front end (as part of the GNU Compiler Collection or GCC)
On Linux
To install a C++ compiler (as part of the GCC) on Linux Ubuntu, type the following inside
the terminal:
5
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_3
Chapter 3 C++ Compilers
To compile the C++ source file, named, for example, source.cpp, we type
g++ source.cpp
This command will produce an executable with the default name of a.out. To run the
executable file, type
./a.out
The same rules apply to the Clang compiler when compiling. Substitute g++ with
clang++.
On Windows
On Windows, we can install a free or commercial copy of Visual Studio.
Choose Create a new project, make sure the C++ language option is selected, choose
Empty Project, click Next, and click Create. Go to the Solution Explorer panel, right-click
the project name, choose Add ➤ New Item ➤ C++ File (.cpp), type the name of a file
(source.cpp), and click Add. Press F5 to run the program.
We can also do the following: choose Create a new project, make sure the C++
language option is selected, choose Console App, click Next, and click Create.
If a Create a new project button is not visible, choose File ➤ New ➤ Project and repeat
the remaining steps.
6
CHAPTER 4
int main(){}
The function main is the main program’s entry point, the start of our program. When
we run our executable, the code inside the main function body gets executed. A function
is of type int (and returns a result to the system, but let us not worry about that just yet).
The reserved name main is a function name. It is followed by a list of parameters inside
the parentheses () followed by a function body marked with braces {}. Braces marking
the beginning and the end of a function body can also be on separate lines:
int main()
{
}
This simple program does nothing, it has no parameters listed inside parentheses,
and there are no statements inside the function body. It is essential to understand that
this is the main program signature.
There is also another main function signature accepting two different parameters used
for manipulating the command-line arguments. For now, we will only use the first form.
Comments
Single-line comments in C++ start with double slashes //, and the compiler ignores
them. We use them to comment or document the code or use them as notes:
int main()
{
7
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_4
Chapter 4 Our First Program
int main()
{
// this is a comment
// this is another comment
}
Multiline comments start with the /* and end with the */. They are also known as
C-style comments. Example:
int main()
{
/* This is a
multi-line comment */
}
#include <iostream>
int main()
{
std::cout << "Hello World.";
}
Output:
Hello World.
8
Chapter 4 Our First Program
Believe it or not, this example’s detailed analysis and explanation can be more than
15 pages long. We can go into it right now, but we will be no wiser at this point as we first
need to know what headers, streams, objects, operators, and string literals are. Do not
worry. We will get there.
Explanation:
The #include <iostream> statement includes the iostream header file content into
our source file via the #include directive. The iostream header is part of the standard
library. We need its inclusion to be able to use the std::cout object, also known as the
standard output stream. The << operator, called the stream insertion operator, inserts
our Hello World string literal into that output stream. A string literal is enclosed in
double quotes "". The ; marks the end of the statement. Statements are pieces of the
C++ program that get executed. Statements end with a semicolon ; in C++. The std is
the standard library namespace, and :: is the scope resolution operator. Object cout
is located inside the std namespace, and to access it, we need to prepend the call with
the std::. We will get more familiar with all of these later in the book, especially the
std:: part.
A brief explanation:
In a nutshell, the std::cout << is the natural way of outputting data to the standard
output/console window in C++.
We can output multiple string literals by separating them with multiple << operators:
#include <iostream>
int main()
{
std::cout << "Some string." << " Another string.";
}
Output:
9
Chapter 4 Our First Program
Example:
#include <iostream>
int main()
{
std::cout << "First line" << '\n' << "Second line.";
}
Output:
First line
Second line.
#include <iostream>
int main()
{
std::cout << "First line\nSecond line.";
}
Output:
First line
Second line.
10
Chapter 4 Our First Program
Good to remember Do not introduce the entire std namespace into a current
scope via the using namespace std; statement.
#include <iostream>
int main()
{
cout << "Bad practice.";
}
#include <iostream>
int main()
{
std::cout << "Good practice.";
}
For calls to objects and functions residing inside the std namespace, add the std::
prefix where needed.
11
CHAPTER 5
Types
Every entity has a type. What is a type? A type is a property describing the set of possible
values and operations on those values. Instances of types are called objects. An object is
a region in memory that has a type, a value, and possibly a name. An instance of a simple
type is not to be confused with an instance of a class which is also called an object.
Fundamental Types
C++ has some built-in types. We often refer to them as fundamental types. A declaration
is a statement that introduces a name into a current scope.
Boolean
Let us declare a variable b of type bool. This type holds values of true and false:
int main()
{
bool b;
}
This example declares a variable b of type bool. And that is it. The variable is not
initialized: and no value has been assigned to it at the time of construction. To initialize a
variable, we use an assignment operator = followed by an initializer:
int main()
{
bool b = true;
}
13
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_5
Chapter 5 Types
int main()
{
bool b{ true };
}
These examples declare a (local) variable b of type bool and initialize it to a value
of true. Our variable now holds a value of true. All local variables should be initialized.
Accessing uninitialized variables results in undefined behavior, abbreviated as UB. More
on this in the following chapters.
Character Type
Type char, referred to as character type, is used to represent a single character. The type
can store characters such as 'a', 'Z', etc. The size of a character type is exactly one byte.
Character literals are enclosed in single quotes '' in C++. To declare and initialize a
variable of type char, we write
int main()
{
char c = 'a';
}
#include <iostream>
int main()
{
char c = 'a';
std::cout << "The value of variable c is: " << c;
}
Output:
14
Chapter 5 Types
Once declared and initialized, we can access our variable and change its value:
#include <iostream>
int main()
{
char c = 'a';
std::cout << "The value of variable c is: " << c;
c = 'B';
std::cout << " The new value of variable c is: " << c;
}
Output:
The size of the char type in memory is always one byte. We obtain the size of the type
through a sizeof operator:
#include <iostream>
int main()
{
std::cout << "The size of type char is: " << sizeof(char) << "
byte(s)";
}
Output:
There are other character types, such as wchar_t for holding characters of Unicode
character set and char16_t for holding UTF-16 character sets, but for now, let us stick to
the type char.
A character literal is a character enclosed in single quotes, for example, 'a', 'A', 'z',
'X', '0', etc.
15
Chapter 5 Types
Every character is represented by an integer number in the character set. That is why
we can assign both numeric literals (up to a certain number) and character literals to our
char variable:
int main()
{
char c = 'a';
// is the same as:
// char c = 97;
}
We can write char c = 'a'; or we can write char c = 97; which is (probably) the
same, as the 'a' character in the ASCII table is represented with the number of 97. For
the most part, we will be using character literals to represent the value of a char object.
Integer Types
Another fundamental type is int called integer type. We use it to store integral values
(whole numbers), both negative and positive:
#include <iostream>
int main()
{
int x = 123;
int y = -256;
std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
}
Output:
Here, we declared and initialized two variables of type int. The size of int is usually
4 bytes. We can also initialize the variable with another variable. It will receive a copy of
its value. We still have two separate objects in memory:
16
Chapter 5 Types
#include <iostream>
int main()
{
int x = 123;
int y = x;
std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
// x is 123
// y is 123
x = 456;
std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
// x is now 456
// y is still 123
}
Output:
The value of x is: 123, the value of y is: 123The value of x is: 456, the
value of y is: 123
Once we declare a variable, we access and manipulate the variable name by its name
only, without the type name.
Integer literals can be decimal, octal, and hexadecimal. Octal literals start with a
prefix of 0, and hexadecimal literals begin with a prefix of 0x.
int main()
{
int x = 10; // decimal literal
int y = 012; // octal literal
int z = 0xA; // hexadecimal literal
}
Floating-Point Types
There are three floating-point types in C++: float, double, and long double. Mainly,
we will be using the type double (double precision). We use it for storing floating-point
values/real numbers:
#include <iostream>
int main()
{
double d = 3.14;
std::cout << "The value of d is: " << d;
}
Output:
int main()
{
double x = 213.456;
double y = 1.;
double z = 0.15;
double w = .15;
double d = 3.14e10;
}
Type void
Type void is a type with no values. Well, what is the purpose of such a type if we cannot
have objects of that type? Good question. While we cannot have objects of type void, we
can have functions of type void – functions that do not return a value. We can also have
a void pointer type marked with void*. More on this in later chapters when we discuss
pointers and functions.
18
Chapter 5 Types
Type Modifiers
Types can have modifiers. Some of the modifiers are signed and unsigned. The signed
(the default if omitted) means the type can hold both positive and negative values,
and unsigned means the type has unsigned representation. Other modifiers affect the
type’s size: short means the type will have a width of at least 16 bits, and long means
the type will have a width of at least 32 bits. Furthermore, we can now combine these
modifiers:
#include <iostream>
int main()
{
unsigned long int x = 4294967295;
std::cout << "The value of an unsigned long integer variable
is: " << x;
}
Output:
int main()
{
char c;
int x;
double d;
}
19
Chapter 5 Types
int main()
{
int x, y, z;
}
int main()
{
int x = 123;
int y{ 123 };
int z = { 123 };
}
int main()
{
char c = 'a';
int x = 123;
double d = 456.78;
}
20
CHAPTER 6
Exercises
Hello World and Comments
Write a program that has a comment in it and outputs “Hello World.” on one line and
“C++ rocks!” on a new line.
#include <iostream>
int main()
{
// this is a comment
std::cout << "Hello World." << '\n';
std::cout << "C++ rocks!";
}
Output:
Hello World.
C++ rocks!
Declaration
Write a program that declares three variables inside the main function. Variables are of
types char, int, and double. The names of the variables are arbitrary. Since we do not
use any input or output, we do not need to include the <iostream> header.
int main()
{
char mychar;
21
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_6
Chapter 6 Exercises
int myint;
double mydouble;
}
Definition
Write a program that defines three variables inside the main function. The variables are
of types char, int, and double. The names of the variables are arbitrary. The initializers
are arbitrary.
int main()
{
char mychar = 'a';
int myint = 123;
double mydouble = 456.78;
}
Initialization
Write a program that defines three variables inside the main function. The variables are
of types char, int, and double. The names of the variables are arbitrary. The initializers
are arbitrary. The initialization is performed using the initializer list. Print the values
afterward.
#include <iostream>
int main()
{
char mychar{ 'a' };
int myint{ 123 };
double mydouble{ 456.78 };
std::cout << "The value of a char variable is: " << mychar << '\n';
std::cout << "The value of an int variable is: " << myint << '\n';
std::cout << "The value of a double variable is: " << mydouble << '\n';
}
22
Chapter 6 Exercises
Output:
23
CHAPTER 7
Operators
Assignment Operator
The assignment operator = assigns a value to a variable/object:
int main()
{
char mychar = 'c'; // define a char variable mychar
mychar = 'd'; // assign a new value to mychar
int x = 123; // define an integer variable x
x = 456; // assign a new value to x
int y = 789; // define a new integer variable y
y = x; // assign a value of x to it
}
Arithmetic Operators
We can do arithmetic operations using arithmetic operators. Some of them are
+ // addition
- // subtraction
* // multiplication
/ // division
% // modulo
Example:
#include <iostream>
int main()
25
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_7
Chapter 7 Operators
{
int x = 123;
int y = 456;
int result = x + y; // addition
result = x - y; // subtraction
result = x * y; // multiplication
result = x / y; // division
std::cout << "The result is: " << result << '\n';
}
Output:
The integer division, in our example, results in a value of 0. It is because the result of
the integral division where both operands are integers is truncated toward zeros. In the
expression x / y, x and y are operands, and / is the operator.
If we want a floating-point result, we need to use the type double and make sure at
least one of the division operands is also of type double:
#include <iostream>
int main()
{
int x = 123;
double y = 456.0;
double result = x / y;
std::cout << "The division result is: " << result << '\n';
}
Output:
#include <iostream>
int main()
26
Random documents with unrelated
content Scribd suggests to you:
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebookmass.com