C++ Primer 第五版 学习笔记 Part I and II

基础部分

1. A stream is a sequence of characters read from or written to an IO device.
2. To handle input, we use an object of type istream named cin; for output, ostream named cout. Also, cerr, clog.
3. All the names defined by standard library are in the std namespace.
4. The value returned from main is a status indicator. A nonzero has a meaning defined by system.
5. The « operator takes 2 operands: left-hand is an ostream object, the other is a value, it returns its left-hand operand, so we can use « twice.

1
2
3
4
5
6
7
8
9

int main()
{
   cout << "Enter two numbers:" << endl;
   int v1  = 0, v2 = 0;
   cin >> v1 >> v2;
   cout << "The sum of  " << v1 << " and " << v2<< " is " << v1 + v2 << endl;

   return 0;
} 

6. End-of-File from keyboard, control-z on windows, control-d on linux.
7. while(cin » value) , it tests if istream is valid. It returns false when we hit end-of-file or invalid input.
8. “iostream.h”, this is old C head file, not belong to namespace std. The new declaration is #include .

变量和类型

1. The type of an object determines what operations can be performed on it.
2. C++ is a statically typed language, type checking is done at compile time.
3. The types int, short, long, long long are all signed. Especially, char and signed char are not the same. char is signed on some machines and unsigned on others, so explicitly specify it.
4. In an unsigned type, all bits represent the value. An 8-bit unsigned char can hold values from 0 to 255.
5. Signed values are automatically converted to unsigned. So don’t mix signed and unsigned types.
6. If we assign an out-of-range value to an object of unsigned type, the result is the remainder of the value modulo the number of values the target type can hold.
7. we can write 20 in three ways:

1
2
3

20      /* decimal */
024     /* octal */
0x14    /* hexadecimal */

8. The compiler appends a null character(’\0’) to every string literal. Literal ‘A’ : single character. String literal “A” : an array of two characters, letter A and ‘\0’.
9. Escape Sequences:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

\n         newline                
\t         horizontal tab
\v         vertical tab
\a         alert
\b         backspace
\"         double quote
\'         single quote
\\         backslash
\?         question mark
\r         carriage return
\f         formfeed

we can also use a generalized escape sequence:

1
2
3
4
5
6

\7        bell
\12       newline
\40       blank
\0        null
\115      'M'
\x4d      'M'

10. if a “" is followed by more than 3 octal digits, only the first 3 are associated with the “".

1
2

\1234        two characters, octal value 123 and character 4
\x1234       single, 16-bit character, four hexadecimal digits

11. specify the type of a literal, override default type:

1
2
3
4

L 'a'        wide character literal, type is wchar_t
42ULL        unsigned integer literal, unsigned long long
1E-3F        single-precision floating-point literal, type is float
3.14159L     extended-precision floating-point literal, type is long double

12. A variable provides us with named storage that our programs can manipulate.
13. Most generally, an object is a region of memory that can contain data and has a type.
14. Initialization and assignment are different operations in C++.
15. Initialization forms:

1
2
3
4

int sold = 0; 
int sold = {0}; 
int sold{0}; 
int sold(0);

16. C++ 11 Initialization:

1
2
3

long double ld = 3.1415926536;
int a{ld}, b = {ld};   // error, narrowing conversion required
int c(ld), d = ld;     // ok, but value will be truncated

17. Variables defined outside any function body are initialized to zero. Variables of built-in type defined inside a function are uninitialized, the value of it is undefined. Objects of class type that we do not explicitly initialize have a value that is defined by the class.

18. A declaration makes a name known to the program. A definition creates the associated entity. To obtain a declaration that is not a definition, we add the “extern” keyword and may not provide an explicit initializer. An extern that has an initializer is a definition. And, it is an error to provide an initializer on an extern inside a function.

1

extern double pi = 3.1416; // definition

19. A reference defines an alternative name for an object. A reference type “refers to” another type. When we define a reference, we bind the reference to its initializer. There is no way to rebind a reference to a different object, so references must be initialized, a reference is not an object.

1
2

int i = 1024, i2 = 2048;
int &r = i,  r2 = i2;  // r is a reference bound to i, r2 is an int

20. C++ 11, a new kind of reference: an “rvalue reference“，it uses && to define, directly use temporary objects.

21. A pointer holds the address of another object. Unlike a reference, a pointer is an object in its own right. Pointers can be assigned and copied; a single pointer can point to several different objects over its lifetime. Unlike a reference, a pointer need not be initialized at the time it is defined.

1
2

int ival = 42;
int *p = &ival; // p holds the address of ival, p is a pointer to ival

22. Because references are not objects, they don’t have address. Hence, we may not define a pointer to a reference.

23. The value stored in a pointer can be in one of four states： (1) It can point to an object (2) It can point to the location just immediately past the end of an object (3)It can be a null pointer, indicating that it is not bound to any object (4)It can be invalid; values other than the preceding three are invalid. It is an error to copy or try to access the value of an invalid pointer. The result of it is undefined.

24. Some symbols have multiple meanings. Such as & and *, are used as both an operator in an expression and as part of a declaration. This is determined by the context.

1
2
3
4
5

int i = 42;
int &r = i;  // & is part of a declaration
int *p;      // * is part of a declaration
p = &i;     //  & as the address-of operator
*p = i;     //  * as the deference operator

25. C++ 11, nullptr is a literal that has a special type that can be converted to any other pointer type. Old programs use a preprocessor variable named NULL. The preprocessor is a program runs before compiler. Morden C++ programs should avoid using NULL and use nullptr instead.
26. The type void* is a special pointer type that can hold the address of any object.
27. It is common misconception to think that the type modifier (* or &) applies to all variables in a statement.

1
2

int* p1, p2;  // legal but might be misleading
int *p1, *p2; // both p1 and p2 are pointers to int

28. We can store the address of a pointer in another pointer. A reference is not an object. Hence, we may not have a pointer to a reference. However, because a pointer is an object, we can define a reference to a pointer. The easiest way to understand the type of r is read the definition from right to left.

1
2
3
4
5

int i = 42;
int *p;
int *&r = p; // r is a reference to the pointer p
r = &i;
*r = 0;

29. Const objects are local to a file. To share a const object among multiple files, define variable as extern.
30. A reference to const May refer to an object that is not const.
31. A const pointer must be initialized, and once initialized, its value may not be changed.
32. P is a const pointer to const, neither the value of the object addressed by p nor the address stored in p can be changed.
33. We use the term top-level const to indicate that the pointer iteself is a const, can appear in any object type. When a pointer can point to a const object, we refer to that const as a low-level const.
34. A constant expression is an expression whose value cannot change and that can be evaluated at compile time.

1
2
3
4

const int max_files = 20;  // max_files is a constant expression
const int limit = max_files + 1; // limit is a constant expression
int staff_size = 27;  // staff_size is not a constant expression
const int sz = get_size(); // sz is not a constant expression

35. C++ 11, to verify that a variable is a constant expression by declaring the variable in a constexpr declaration. Variables declared as constexpr are implicitly const and must be initialized by constant expressions.

1
2
3

constexpr int mf = 20;  // 20 is a constant expression
constexpr int limit = mf + 1; // mf + 1 is a constant expression
constexpr int sz = size();  // ok only if size is a constexpr function

36. C++ 11, we can use constexpr functions in the initializer of a constexpr variable. When we define a pointer in a constexpr declaration, the constexpr applies to the pointer.

1
2
3
4
5

const int *p = nullptr;  // p is a pointer to a const int
constexpr int *q = nullptr; // q is a const pointer to int

constexpr int i = 42;  // type of i is const int
constexpr const int *p = &i; // p is a constant pointer to the const int i

37. A type alias is a name that is a synonym for another type. We often use “typedef” to define. C++ 11, an alias declaration starts with the keyword using followed by alias name.

1
2
3
4
5
6
7

typedef double wages;  // wages is a synonym for double
typedef wages base, *p; // base is a synonym for double, p for double*

using SI = Sales_item;  // SI is a synonym for Sales_item

wages hourly, weekly;  // same as double hourly, weekly;
SI item;  // same as Sales_item item

38. C++ 11, we can use “auto” to let the compiler to deduce the type from the initializer. When we define multiple variables, they must have consistent types.

1
2
3
4
5

auto i = 0, *p = &i;  // ok: i is int and p is a pointer to int
auto sz = 0, pi = 3.14;  // error: inconsistent types for sz and pi

int i = 0, &r = i;
auto a = r;  // a is an int (r is an alias for i, which has type int)

auto ordinarily ignores top-level consts.

1
2
3
4
5

const int ci = i, &cr = ci;
auto b = ci;  // b is an int (top-level const in ci is dropped)
auto c = cr;  // c is an int (cr is an alias for ci whose const is top-level)
auto d = &i;  // d is an int*(& of an int object is int*)
auto e = &ci; // e is const int*(& of a const object is low-level const)

If we want the deduced type to have a top-level const, say explicityly.

1
2

const auto f = ci; // deduced type of ci is int; f has type const int
auto &g = ci;  // g is a const int& that is bound to ci

As usual, the initializers must provide consistent auto-deduced types.

1
2
3
4
5
6

// k is int; l is int&
auto k = ci, &l = i;
// m is a const int&;p is a pointer to const int
auto &m = ci, *p = &ci;
// error: type deduced from i is int; type deduced from &ci is const int
auto &n = i, *p2 = &ci; 

39. C++ 11, we can get the type of variable or expression by using “decltype” specifier.

1

decltype(f())  sum = x; // sum has whatever type f returns

Here, the compiler does not call f, but uses the type it returns.

1
2
3

int i = 42, *p = &i, &r = i; // decltype of an expression can be a reference type
decltype(r + 0) b;  // ok: addition yields an int; b is an (uninitialized) int
decltype(*p) c;  // error: c is int& and must be initialized

The deference operator is an example of an expression for which decltype returns a reference. The deduction done by decltype depends on the form of its given expression, that is, enclosing the name of a variable in parentheses affects the type returned by decltype.

1
2
3

// decltype of a parenthesized variable is always a reference
decltype((i)) d;  // error: d is int& and must be initialized
decltype(i) e;  // ok: e is an (uninitialized) int

40. C++ 11, we can supply an in-class initializer for a data member. In-class initializers must either be enclosed inside curly braces or follow an = sign.

41. The most common technique for making it safe to include a header multiple times relies on the preprocessor. It is a program that runs before the compiler and changes the source text of our programs.

Strings, Vectors, Arrays

1. A string is a variable-length sequence of characters. A vector holds a variable-length sequence of objects of a given type. Like other built-in types, arrays represent facilities of the hardware, so arrays are less convenient.

2. A using declaration lets us use a name from a namespace without qualifying the name with namespace name. Once the using declaration has been made, we can access name directly. We can also use separate declaration. Headers should not include using Declarations.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <iostream>
// using declarations for names from the standard library
using std::cin;
using std::cout; using std::endl;
int main()
{
   cout << "Enter two numbers:" << endl;
   int v1, v2;
   cin >> v1 >> v2;
   cout << "The sum of " << v1 << " and " << v2
   << " is " << v1 + v2 << endl;
   return 0;
}

3. Here, this is an example of namespace.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

namespace CompanyName
{
   namespace Engine
   {
       class Node;
   }
   
   namespace MyGame
   {
       class Tutorial;
       class TutorialManager
       {
       public:
           TutorialManager();
           ~TutorialManager();
       private:
           static void RemoveNode(Engine::Node* node);
           Tutorial* m_currentTut;
       }
   }
}

4. A string is a variable-length sequence of characters. It is defined in the std namespace.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <string>
using std::string;

int main() {
   string s1;  // default initialization; s1 is the empty string
   string s2 = s1;  // s2 is a copy of s1
   string s3 = "hiya";  // s3 is a copy of the string literal
   string s4(10, 'c');  // s4 is cccccccccc
   string s8 = string(10, 'c'); // copy initialization
}

5. The size() function returns a string::size_type value. The string class and other library types defines several companion types, such as size_type. Although we don’t know the precise type of string::size_type, we do know that it is an unsigned type big enough to hold the size of any string.

6. The string class comparing strategy: (1) If two strings have different lengths and if every character in the shorter string is equal to the corresponding character of the longer string, then the shorter string is less than the longer one. (2) If any characters at corresponding positions in the two strings differ, then the result of the string comparing the first character at which the strings differ.

1
2
3
4
5
6

string str1;
getline(cin, str1); // read a line
cout << str1.size() << endl; // <<, >> operator
string str2(5, 'c');
string str3 = str1 + "," + str2; // =, + operator
bool result = str1 < str2; // <, > compare operator

7. C++ 11, we can use a Range for to change characters in a string. Caution: Subscripts are Unchecked. We need to check that our subscript is less than size().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

string cc("Some String");
for (auto &c:cc)
{
   c = tolower(c); // c is a reference, so the assignment changes the char
}
if (!cc.empty())
{
   cc[0] = toupper(cc[0]); // use subscript operator []
}
cout << cc << endl;

8. A vector is a collection of objects, all of which have the same type. A vector is often referred to as a container because it “contains” other objects. A vector is a class template. C++ has both class and function templates. When we use a template, we specify what kind of class or function we want the compiler to instantiate.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <string>
#include <vector>

using std::vector;
using std::string;

int main() {
   vector<int> ivec;  // ivec holds objects of type int
   vector<vector<string>> file;  // vector whose elements are vectors
   return 0;
}

9. If we use braces and there is no way to use the initializers to initialize the object, then those values will be used to construct the objects.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

vector<int> v1; // initial empty
vector<int> v2(v1); // copy elements of v1 into v2
vector<int> v3(3, 0); // v3 has 3 elements with value 0
vector<int> v4(3); // v4 has 3 elements, each initialized to 0
vector<int> v5{1,2,3}; // C++ 11, initialize from a list of elements
vector<string> articles = {"a", "an", "the"};
vector<string> svec(5, "hello");

vector<string> v7{10}; // v7 has 10 default-initialized elements
vector<string> v8{10, "hi"}; // v8 has 10 elements with value "hi"

10. The body of a range for must not change the size of the sequence over which it is iterating. The subscript operator [] on vector (and string) fetches an existing element; it does not add an element. If the container is empty, the iterators returned by begin and end are equal, they are both off-the-end iterators. In general, we do not know the precise type that an iterator has. As with pointers, we can dereference an iterator to obtain the element denoted by an iterator. Like a const pointer, a const_iterator may read but not write the element it denotes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

vector<int> nums = {1,2,3,4,5,6,7,8};
nums.push_back(9);
for (auto &i : nums)
{
   i *= i;
   cout << i << "\t";
}
vector<int>::size_type length = nums.size();
cout << endl << length << endl;

vector<int>::iterator it;
for (it = nums.begin(); it != nums.end(); it++)
{
   *it *= 10;
   cout << *it << "\t";
}

It is important to realize that loops that use iterators should not add elements to the container.

11. An array is a data structure that is similar to the library vector type. Unlike a vector, arrays have fixed size; we cannot add elements to an array. A default-initialized array of built-in type that is defined inside a function will have undefined values. We cannot initialize an array as a copy of another array.

1
2
3
4
5
6
7
8
9

const unsigned sz = 3;
int ia1[sz] = {0,1,2};  // array of three ints with values 0, 1, 2
int a2[] = {0, 1, 2};  // an array of dimension 3
int a3[5] = {0, 1, 2};  // equivalent to a3[] = {0, 1, 2, 0, 0}
string a4[3] = {"hi", "bye"}; // same as a4[] = {"hi", "bye", ""}

char x1[] = {'C', '+', '+'};  // list initialization, no null
char x2[] = {'C', '+', '+', '\0'}; // list initialization, explicit null
char x3[] = "C++";   // null terminator added automatically

12. When we use a variable to subscript an array, we normally define that variable to have type size_t. size_t is a machine-specific unsigned type that is guaranteed to be large enough to hold the size of any object. As with string and vector, it is up to the programmer to ensure that the subscript value is in range. When we use an array, the compiler ordinarily converts the array to a pointer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

string nums[] = {"one", "two", "three"};  // array of strings
string *p2 = nums;  // equivalent to p2 = &nums[0]

int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
auto ia2(&ia[0]);  // now it's clear that ia2 has type int*
decltype(ia) ia3 = {0,1,2,3,4,5,6,7,8,9};// ia3 is an array of ten ints

int arr[] = {0,1,2,3,4,5,6,7,8,9};
int *p = arr; // p points to the first element in arr
++p;  // p points to arr[1]

13. C++ 11, the new function begin returns a pointer to the first, and end returns a pointer one past the last element.

1
2
3
4
5
6
7
8
9

#include <iterator>
using namespace std;
int main() {
   int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
   int *beg = begin(ia); // pointer to the first element in ia
   int *last = end(ia);  // pointer one past the last element in ia
   ptrdiff_t n = last - beg; // the result of subtracting two pointers
   return 0;
}

14. Unlike subscripts for vector and string, the index of the built-in subscript operator is not an unsigned type.

1
2
3
4

int ia[] = {0,2,4,6,8};  // array with 5 elements of type int
int *p = &ia[2];  // p points to the element indexed by 2
int k = p[-2];  // p[-2] is the same element as ia[0]
cout << *p << "\t" << k << endl; // 4   0

15. C-style character strings are not a type, they are stored in character arrays and are null terminated. By null-terminated we mean that the last character in the string is followed by a null character ‘\0’. The standard C library provides a set of functions operated on C-style strings. However, to use these functions, we can easily miscalculate the size needed for the parameters. In addition to being safer, it is more efficient to use library string rather than C-style strings.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

char ca[] = {'c', '+', '+'}; // not null terminated
char ca2[] = "c++";
const char* ca3 = "c++";
cout << strlen(ca) << "\t" << strlen(ca2) << "\t" << strlen(ca3) << endl;
if (strcmp(ca, ca3) == 0) cout << "equal" << endl; // compare c-style string

char cp1[] = "c"; // if cp1[] = "", strcpy and strcat will be undefined
strcpy(cp1, ca3); // copy ca3 into cp1, size of cp1 should be big enough to hold ca3
strcat(cp1, ca2); // concatenate ca2 onto cp1
cout << cp1 << "\t" << strlen(cp1) << endl;

const char* src = "hi";
char* dest = new char[strlen(src)];
strncpy(dest, src, strlen(src));// safer such as strcpy_s, but not enough
cout << strlen(src) << "\t" << dest << endl;

16. C++ may have to interface to code that uses arrays and C-style strings. C++ library offers some facilities to make it easier.

1
2
3
4
5

string s("hello world"); // initialize a string from a string literal
const char *str = s.c_str(); // the value returned by c_str may be invalid

int arr[] = {0, 1, 2, 3, 4};
vector<int> ivec(begin(arr), end(arr)); // copy array to vector

17. Strictly speaking, there are no multidimensional arrays in C++，they are actually arrays of arrays.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int ia[3][4]; // array of size 3; each element is an array of ints of size 4
int arr[10][20][30] = {0}; // initialize all elements to 0
int ax[3][4] = { // three elements; each element is an array of size 4
   {0, 1, 2, 3},
   {4, 5, 6, 7},
   {8, 9, 7, 8}
};
int axy[3][4] = {0,1,2,3,4,5,6,7,8,9,7,8}; // the nested braces are optional
int ix[3][4] = {{ 0 }, { 4 }, { 8 }};
int ixy[3][4] = {0,3,6,9}; // initialize row 0, the remaining elements are 0

18. C++ 11, we can use a range for with Multidimensional Arrays. Remember that a multidimensional array is really an array of arrays.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

int ia[2][3] = {0,1,2,3,4,5};
// the innermost array must be references, we can only iterator on arrays, not pointers
for (auto &row : ia)
{
   for (auto &col : row) // you can remove '&' here
   {
       cout << col << "\t" ;
       col += 10;
   }
}
cout << endl;
for (int i = 0; i < 6; i++)
{
   cout << *(*ia + i) << "\t";
}
cout << endl;
// we should avoid to write the type of a pointer into an array by using auto or decltype
for (auto p = begin(ia); p != end(ia); ++p)
{
   for (auto q = begin(*p); q != end(*p); ++q)
       cout << *q << "\t";
}

int *ip[4];  // array of pointers to int
int (*ipx)[4];  // pointer to an array of four ints

表达式

1. Every expression in C++ is either an rvalue or an lvalue. When we use an object as rvalue, we use the object’s value. When we use an object as an lvalue, we use the object’s identity(its location in memory).

2. Precendence specifies how the operands are grouped. It says nothing about the order. In the following expression int i = f1() * f2(); We have no way of knowing whether f1 will be called before f2 or vice versa. For operators that do not specify evaluation order, it is an error for an expression to refer to and change the same object. For example, the « operator makes no guarantees about when or how its operands are evaluated.

1
2

int i = 0;
cout << i << " " << ++i << endl; // undefined

There are 4 operators that do guarantee the order in which operands are evaluated. The logical AND (&&) operator guarantees its left-hand operand is evaluated first and its right-hand operator is evaluated only if the left-hand operand is true; logical OR(||) operator ; conditional (? :) operator; comma (,) operator.

3. Order of operand evaluation is independent of precedence and associativity. In an expression such as: f() + g() * h() + j() There are no guarantees as to the order in which these functions are called. (1) when in doubt, parenthesize expressions to force the grouping (2) if you change the value of an operand, don’t use that operand elsewhere in the same expression an important exception to the second rule occurs when the subexpression that changes the operand is itself. For example, in *++iter, the value of iter is the operand to the dereference operator, order is not an issue.

4. C++ 11, the modulus operator is defined so that if m and n are integers and n is nonzero, then (m/n)*n + m%n is equal to m. By implication, if m%n is nonzero, it has the same sign as m.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int i = 1024;
int k = -i; // k is -1024
bool b = true;
bool b2 = -b; // b2 is 1
short short_value = 32767; // max value if shorts are 16 bits
short_value += 1; // this calculation overflows
cout << short_value << endl; // -32768

// if m%n is nonzero, it has same sign as m
cout << -21 % -8 << '\t' << 21 % -5 << endl;

5. Arithmetic and pointer operand with a value of zero are false, all other values are true. The logical AND and OR (&& ||) operators always evaluate their left operand before the right. The right operand is evaluated if and only if the left operand does not determine the result, this strategy is known as short-circuit evaluation. This can be used for checking index of array:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

vector<string> text = {
   "Don't start to wonder why.",
   "You know I love you",
   "when I lie to you"
};
for (const auto &s:text){
   cout << s;
   if (s.empty() || s[s.size() - 1] == '.')
       cout << endl;
   else
       cout << " ";
}

6. C++ 11, we can use a braced initializer list on the right-hand side. Assignment has lower precedence.

1
2
3
4
5
6
7
8

int k = { 3 }; // no narrowing conversion
vector<int> vi; // initial empty
vi = {0, 1, 2}; // use vector operator
int v = k = 0; // assignment is right associative

int i;
if((i = k) != 3) i++; // assignment has lower precedence, so need parentheses
cout << i << endl;

7. The increment(++) and decrement(–) provide two forms of operators: prefix and postfix. The prefix form increments its operand and yields the changed object as its result. The postfix operator increments the operand but yields a copy of the original value as its result. Use postfix operator only when necessary.

1
2
3
4
5

vector<int> v = { 2, 1, 0, -1, -2 };
auto pbeg = v.begin();
// print elements up to the first negative value
while (pbeg != v.end() && *pbeg >= 0)
   cout << *pbeg++ << endl;

8. The dot and arrow operators provide for member access.

1
2

string s = "a str", *p = &s;
cout << s.size() << ' ' << (*p).size() << ' ' << p->size();

9. The conditional operator lets use embed simple if-else logic inside an expression. It has the following form: condition ? expr1 : expr2; Nested conditionals quickly become unreadable. Do not nest more than two or three. The conditional operator has fairly low precedence. When we embed a conditional expression in a large expression, we usually must parenthesize the conditional sub expression.

1
2
3
4
5

int score = 68;
string grade = (score > 90) ? "high pass"
                           : (score < 60) ? "fail" : "pass";
cout << ((score < 60) ? "fail" : "pass") << endl; // print pass
cout << (score < 60) ? "fail" : "pass"; // print 0, cout << (score < 60)

10. There are no guarantees for how the sign bit is handled, we should use unsigned types with bitwise operators. Bits that are shifted off the end are discarded. The left-shift operator («) inserts 0-valued bits on the right. The behavior of the right-shift operator (») depends on the type of the left-hand operand: if that operand is unsigned, the operator inserts 0-valued bits on the left. if it is signed, the result is implementation defined, either copies of the sign bit or 0-valued bits are inserted on the left.

1
2
3

unsigned i = 35;
cout << (1 << i) << endl; // 35 & 31 = 3; 1 << 3, depend on CPU, this is undefined
cout << (1 << 35) << endl; // directly compute

The result of above code is strange, because the right operand is too large. Also, there are other bitwise operators: ~ (NOT), & (AND), ^ (XOR), | (OR)

11. To handle bit operation, we can also use bitset library.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <bitset>
using namespace std;

int main()
{
   bitset<8> bs(6);
   cout << bs << endl; // 00000110
   cout << bs.count() << endl; // 2, the size of bit '1'
   cout << bs.size() << endl; // 8

   bitset<8> tt(6);
   tt.set(0); // set the bit to 1, from right to left
   tt.reset(2); // set the bit to 0
   cout << tt << endl; // 00000011
   if (tt.test(0)) cout << "test if the bit is 1" << endl;
   if (tt.any()) cout << "there is at least one '1' bit" << endl;
   if (tt.none()) cout << "all bits are 0" << endl;

   bitset<8> vs("011");
   cout << vs.to_ulong() << endl; // get bit value, 3

   bitset<16> vec(0xffff);
   vec.flip(0); // reverse the bit
   vec[1].flip();
   cout << vec << endl; // 1111111111111100

   return 0;
}

12. The sizeof operator returns the size, in bytes, of an expression or a type name.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

int a = 1, *p = &a;
size_t value = sizeof a; // return type is size_t
cout << value << endl; // size of int
cout << sizeof p << endl; // size of pointer, the value depend on system
cout << sizeof *p << endl; // size of type to which p points

struct User
{
   int id;
   string name;
   bool hasExpired;
};
cout << sizeof(int) << "\t" << sizeof(string) << "\t" 
   << sizeof(bool) << "\t" << sizeof(User) << endl;

char array[10];
char ax[] = "abcd";
cout << sizeof(array) << endl;
cout << sizeof(ax) << endl; // sizeof will include '/0'

vector<char> vec = {'a', 'b'};
cout << sizeof(vec); // size of the fixed part of this vector

sizeof char or an expression of type char is guaranteed to be 1. sizeof a reference type returns the size of an object of the referenced type. sizeof a pointer returns the size needed hold a pointer. sizeof a dereferenced pointer returns the size of an object of the type to which the pointer points. sizeof an array is the size of the entire array. Note that sizeof does not convert the array to a pointer. sizeof a string or a vector returns only the size of the fixed part of these types.

13. The comma operator takes two operands, which it evaluates from left to right.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

vector<int> ivec = {5, 6, 7};
vector<int>::size_type cnt = ivec.size();
// both ix and cnt are changed through the loop
for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix, --cnt)
{
   ivec[ix] = cnt;
   cout << ivec[ix] << "\t";
}

int x = 0, y = 0;
x == 0 ? ++x, ++y : --x, --y;
cout << endl << x << "\t" << y << endl; // 1    0

14. The arithmetic conversions, convert one arithmetic type to another. If both operands have the same signedness, then the operand with the smaller type is converted to the larger type. When the signedness differs and the type of the unsigned operand is the same as or larger than that of the signed operand, the signed operand is converted to unsigned. The remaining case is when the signed operand has a larger type than the unsigned operand, the result is machine dependent. If all values in the unsigned type fit in the larger type, then the unsigned type is converted to signed type. If the values don’t fit, then the signed operand is converted to unsigned type. For example, if the operands are long and unsigned int, and int and long have the same size, the long will be converted to unsigned int. If the long type has more bits, then the unsigned int will be converted to long.

15. In addition to the arithmetic conversions, there are several additional kinds of implicit conversions. (1) Array to Pointer Conversions: when we use an array, the array is automatically converted to a pointer to the first element in that array. This conversion is not performed when an array is used with decltype or as the operand of the address-of(&), sizeof, or typeid operators. The conversion is also omitted when we initialize a reference to an array. (2) Pointer Conversions: a constant integral value of 0 and the literal nullptr can be converted to any pointer; a pointer to any nonconst type can be converted to void*, and a pointer to any type can be converted to a const void*. (3) Conversions to bool: If the pointer or arithmetic value is zero, the conversion yields false, any other yields true. (4) Conversion to const: we can convert a pointer to a nonconst type or a pointer to the corresponding const type. If T is a type, we can convert a pointer or a reference to T into a pointer or reference to const T. (5) Conversions Defined by Class Types: the compiler will apply automatically. This can be done by define constructor, but not recommend to define this conversion.

16. Sometimes we want to explicitly force an object to be converted to a different type. To do so, we use a cast to do an explicit conversion. A named cast has the following form: cast-name<type> (expression); The type is the target type, and expression is the value to be cast. If type is a reference, the result is an lvalue. (1) static_cast, any well-defined type conversion, other than those involving low-level const, can be requested using a static_cast. It is also useful to perform a conversion that the compiler will not generate automatically. (2) const_cast, change a low-level const in its operand, or say that convert a const object to nonconst type. Once we have cast away the const of an object, the compiler will no longer prevent us from writing to that object. (3) reinterpret_cast, generally performs a low-level reinterpretation of the bit pattern of its operands. A reinterpret_cast is inherently machine dependent. So avoid casts. (4) dynamic_cast, used in combination with inheritance and run-time type identification.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int i = 2, j = 1;
double slope = static_cast<double>(j) / i;
cout << slope << endl;

double d = 1.5;
void* p = &d;
double *dp = static_cast<double*>(p);
cout << *dp << endl;

const int constant = 1;
int* modifier = const_cast<int*>(&constant);
*modifier = 2; // constant can not be really modified
cout << constant << endl; // 1

17. Statement and Exception

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

#include <iostream>
#include <vector>
#include <limits>
#include <stdexcept>

using namespace std;

class MyException{
public:
   MyException(string msg) { err_msg = msg;}
   void ShowErrorMsg() { cerr << err_msg << endl;}
private:
   string err_msg;
};

void TestException(){
   throw MyException("MyException!");
}

void TestStdException(char c){
   if (c < numeric_limits<char>::max())
       throw invalid_argument("exception: argument too large");
}

int main() {

   // if else
   int grade = 75;
   int level;
   if (grade < 60) {
       level = 0;
   }
   else if (grade >= 60 && grade < 80) {
       level = 1;
   }
   else {
       level = 2;
   }

   // switch, break
   switch(level) {
       case 0:
           cout << "Grade : Fail" << endl;
           break;
       case 1:
           cout << "Grade : Pass" << endl;
           break;
       case 2:
           cout << "Grade : Excellent" << endl;
           break;
       default:
           cout << "Unknown level value" << endl;
           break;
   }

   // while statement
   int array[] = {99, 98, 97};
   auto beg = begin(array);
   while (beg != end(array)){
       cout << *beg << "\t";
       ++beg;
   }
   cout << endl;

   // do while
   do{
       --beg;
       cout << *beg << "\t";
   }while(beg != begin(array));
   cout << endl;

   // range for, continue
   vector<int> v = {7, 8, 9};
   for (auto &r : v)
   {
       if (r % 2 == 0)
       {
           continue;
       }
       r *= 2;
   }

   // for statement
   for (int i = 0; i < v.size(); ++i)
   {
       cout << v[i] << "\t";
   }
   cout << endl;

   // exception
   try{
       TestException();
   }catch(MyException& e){
       e.ShowErrorMsg();
   }

   try{
       TestStdException(256);
   }catch(invalid_argument& e){
       cerr << e.what() << endl;
   }

   return 0;
}

函数

1. Arguments are the initializers for a function’s parameters. The first argument initializes the first parameter, the second argument initializes the second parameter, and so on. Although we know which argument initializes which parameter, we have no guarantees about the order in which arguments are evaluated. Parameter names are optional. However, there is no way to use an unnamed parameter. Therefore, parameters ordinarily have names.

2. Objects defined outside any function exist throughout the program’s execution. Such objects are created when the program starts and are not destroyed until the program ends. The lifetime of a local variable depends on how it is defined. Each local static object is initialized before the first time execution passes through the object’s definition. Local statics are not destroyed when a function ends; they are destroyed when the program terminates. If a local static has no explicit initializer, it is value initialized, meaning that local statics of built-in type are initialized to zero.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <iostream>
using namespace std;

size_t count_calls()
{
   static size_t ctr = 0; // value will persist across calls
   return ++ctr;
}

int main() {
   for (size_t i = 0; i != 10; ++i)
       cout << count_calls() << "\t";
   cout << endl;
   return 0;
}

3. When a parameter is a reference, we say that its corresponding argument is “passed by reference” or that the function is “called by reference.” Reference parameters let us effectively return multiple results. When the argument value is copied, the parameter and argument are independent objects. We say such arguments are “passed by value” or alternatively that the function is “called by value.” When we copy a pointer, the value of the pointer is copied. After the copy, the two pointers are distinct. However, We can change the value of that object by assigning through the pointer.

4. When we copy an argument to initialize a parameter, top-level consts are ignored. Arrays have two special properties that affect how we define and use functions that operate on arrays: We cannot copy an array, and when we use an array it is usually converted to a pointer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
using namespace std;

//parameter is a reference to an array
void print(int (&arr)[3])
{
   for (auto elem : arr)
       cout << elem << endl;
}

int main(int argc, char **argv) {
   //the size of an array is part of its type
   int arr[] = {0, 1, 2};
   print(arr);
   // arguments begin in argv[1], argv[0] contains program name
   cout << argv[0] << endl;
   cout << argc << endl;
   return 0;
}

5. We can write a function that takes an unknown number of arguments of a single type by using an initializer_list parameter. An initializer_list is a library type that represents an array of values of the specified type. Ellipsis parameters are in C++ to allow programs to interface to C code that uses a C library facility named varargs. Generally an ellipsis parameter should not be used for other purposes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
#include <stdarg.h>

using namespace std;

void error_msg(int errCode, initializer_list<string> il)
{
   cout << "ErrorCode:" << errCode << endl;
   for (auto elem : il)
       cout << elem << "\t";
   cout << endl;
}

void foo(int errCode, const char* desc, ...)
{
   cout << desc << ":" << errCode << endl;
   char* temp;
   va_list arg_ptr;
   // va_start must appear in front of va_arg, desc is the last parameter
   va_start(arg_ptr, desc);
   while(temp = va_arg(arg_ptr, char*))
   {
       cout << temp << "\t";
   }
   va_end(arg_ptr);
}

int main() {
   error_msg(1, {"are", "you", "ok"});
   cout << endl;
   foo(1, "Error", "No,", "thank", "you", nullptr);
   return 0;
}

6. Never Return a Reference or Pointer to a Local Object. When a function completes, its storage is freed. C++ 11, functions can return a braced list of values. We cannot return an array, but a function can return a pointer or a reference to an array. C++ 11, to simplify the declaration of a pointer to an array, we can use a trailing return type. Trailing returns can be defined for any function, but are most userful for functions with complicated return types.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <iostream>
#include <vector>
#include <stdlib.h>
using namespace std;

// C++ 11, list initializing the return value
vector<string> process()
{
   return {"functionX", "okay"};
}

int testFunc(int a)
{
   return a;
}

int (*ptr)[10];

// a function that returns a pointer to an array
int (*testPFunc1(int i))[10]
{
   return ptr;
}

// a trailing return type
// a function takes an int argument and returns a pointer to an array of ten ints
auto testPFunc2(int i) -> int(*)[10]
{
   return ptr;
}

int odd[] = {1, 3, 5, 7, 9};
int even[] = {0, 2, 4, 6, 8};
decltype(odd) *arrPtrFunc(int i)
{
   return (i % 2) ? &odd : &even; // returns a pointer to the array
}

int main() {
   for (auto s:process())
       cout << s << " ";
   cout << endl;

   typedef int INT;
   using arrTS = int[10];
   typedef int arrT[10]; // arrT is a synonym for the type array of 10 ints
   typedef int (*arrP)[10]; // a pointer to an array
   typedef int (*arrFunc)(int i); // a pointer named arrFunc to a function
   typedef const char* cpstr;

   arrT arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   arrP ap = &arr;
   INT a = (*ap)[9];

   arrFunc foo = testFunc;
   cout << foo(a) << endl;

   int(*funcArr[10])(int a);
   funcArr[0] = testFunc;
   cout << funcArr[0](100) << endl;

   ptr = &arr;
   arrP p1 = testPFunc1(0);
   cout << (*p1)[9] << endl;
   arrP p2 = testPFunc2(0);
   cout << (*p2)[9] << endl;

   cpstr s = "hello";
   cout << s << endl;

   // this returned value from main is a status indicator
   if (true)
       return EXIT_SUCCESS;
   else
       return EXIT_FAILURE;
}

7. If we declare a name in an inner scope, that name hides uses of that name declared in an outer scope. Names do not overload across scopes. In C++, name lookup happens before type checking.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <iostream>
using namespace std;

void print(double i) { cout << i << endl; }
void print(int i) { cout << i << endl;}

int main() {
   void print(int); // new scope: hides previous instance of print
   print(3.14);
   return 0;
}

8. A function specified as inline (usually) is expanded “in line” at each call. The inline is only a request to the compiler. The compiler may choose to ignore this request. This mechanism is meant to optimize small, straight-line functions that are called frequently. Many compilers will not inline a recursive function. A 75-line function will not be expanded inline.

9. A constexpr function is a function that can be used in a constant expression. The return type and the type of each parameter in an expression must be a literal type, and the function body must contain exactly one return statement. In order to be able to expand the function immediately, constexpr functions are implicitly inline.

1
2
3
4

constexpr int new_sz() { return 42; }

// scale(arg) is a constant expression if arg is a constant expression
constexpr size_t scale(size_t cnt) { return new_sz() * cnt; }

A constexpr function is not required to return a constant expression. Unlike other functions, inline and constexpr functions may be defined multiple times. As a result, inline and constexpr functions normally are defined in headers.

10. To conditionally execute debugging code, there are two preprocessor facilities: assert and NDEBUG. assert is a preprocessor macro, that preprocessor variable acts like an inline function. Preprocessor names are managed by preprocessor, not the compiler. As a result, we use preprocessor names directly and not provide a using declaration for assert. The behavior assert depends on the status of a preprocessor variable named NDEBUG. If NDEBUG is defined, assert does nothing. We can “turn off” debugging by providing a #define to define NDEBUG.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <cassert>
using namespace std;

void print()
{
   // __func__, the C++ compiler defines
   // __FILE__ ... the preprocessor defines in debugging
#ifndef NDEBUG
   cout << __FILE__ << endl; // name of the file
   cout << __LINE__ << endl; // current line number
   cout << __TIME__ << endl; // the time the file was compiled
   cout << __DATE__ << endl; // the date the file was compiled
   cerr << __func__ << endl; // name of the function
#endif
}

int main() {
   print();
   assert(true);
   return 0;
}

11. The first step of function matching identifies the candidate functions. A candidate function is a function with the same name as the called function. The second step selects the viable functions from candidate functions. To be viable, a function must have the same number of parameters, and the type of each argument must match or can be converted. The third step determines which viable function provides the best match for the call. An exact match is better than a match that requires a conversion.

1
2

f(double, double); 
f(int, int);

For call f(5.6, 3.14), f(double, double) is a better match. For call f(42, 2.56), the compiler will reject this call because it is ambiguous. Also, for func(long) and func(float), call func(3.14) is ambiguous.

12. A function’s type is determined by its return type and parameters type, not the function’s name. When we use the name of a function as a value, the function is automatically converted to a pointer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <iostream>
using namespace std;

bool compareLength(const string& a, const string& b){
   return a.length() > b.length();
}

// equivalent declare, function will automatically be converted to pointer as argument
void printBigger1(const string& s1, const string& s2, 
   bool (*pf)(const string&, const string&));
void printBigger(const string& s1, const string& s2, 
   bool pf(const string&, const string&)){
   if (pf(s1, s2))
       cout << s1 << endl;
   else
       cout << s2 << endl;
}

typedef bool Func(const string&, const string&); // function type
typedef decltype(compareLength) Func2; // equivalent type
void printBigger2(const string&, const string&, Func);

// decltype returns a function type, if we want a pointer, we must add * ourselves.
typedef bool (*FuncP)(const string&, const string&); // pointer type
typedef decltype(compareLength) *FuncP2; // equivalent type
void printBigger3(const string&, const string&, FuncP2);

// pf points to a function returning bool
bool (*pf)(const string&, const string&);
// declares a function named pf that returns a bool*
bool  *bf (const string&, const string&);

using F = int(int*, int); // F is a function type
using PF = int(*)(int*, int); // PF is a pointer type

// from the inside out, f1 has a parameter list, so f1 is a function
// f1 is preceded by a * so f1 returns a pointer
// the type of that pointer itself has a parameter list
// so the pointer points to a function, the function returns an int
int (*f1(int))(int*, int);
auto f2(int) -> int (*)(int*, int); // use a trailing return

int main() {
   // equivalent assignment and call
   pf = compareLength;
   cout << pf("123", "12") << endl;
   pf = &compareLength;
   cout << pf("123", "12") << endl;
   cout << (*pf)("123", "12") << endl;
   cout << endl;

   printBigger("123", "12", compareLength);
   cout << endl;

   // just call the declared function, so the parentheses is important
   cout << *bf("12", "123") << endl;

   return 0;
}

bool result = false;
bool* bf(const string& a, const string& b){
   result = a.length() > b.length();
   return &result;
}

Classes

1. In C++ we use classes to define our own data types. The fundamental ideas behind classes are data abstraction and encapsulation. Data abstraction is a programming technique that relies on the separation of interface and implementation. The interface of a class consists of the operations that users of the class can execute. The implementation includes the class data members, the bodies of functions that constitute the interface. Encapsulation enforces the separation of a class interface and implementation. A class that is encapsulated hides its implementation, users can use the interface but have no access to the implementation. A class that uses data abstraction and encapsulation defines an abstract data type.

2. Member functions must be declared inside the class, and may be defined inside or outside the class body. Functions defined in the class are implicitly inline. Member functions access the object on which they were called through an extra implicit parameter named this. When we call a member function, “this” is initialized with the address of the object on which the function was invoked. Any direct use of a member of the class is assumed to be an implicit reference through “this”. Because “this” is intended to always refer to “this” object, “this” is a const pointer, we cannot change the address that “this” holds. By default, the type of “this” is a const pointer to the nonconst version of the class type. So we cannot bind “this” to a const object. This fact, in turn, means that we cannot call an ordinary member function on a const object. A const following the parameter list indicates that this is a pointer to const, member functions that use const in this way are const member functions. It means that const member functions cannot change the object on which they are called. Objects that are const, and references or pointers to const objects, may call only const member functions.

3. The job of a constructor is to initialize the data members of a class object. A constructor is run whenever an object of a class type is created. Constructors have the same name as the class, no return type. Classes control default initialization by defining a special constructor, known as the default constructor. The default constructor is one that takes no arguments. If our class does not explicitly define any constructors, the compiler will implicitly define the default constructor: (1) If there is an in-class initializer, use it to initialize the member (2) Otherwise, default-initialize the member. The compiler generates a default constructor automatically only if a class declares no constructors. Classes that have members of built-in or compound type usually rely on the synthesized default constructor only if all such members have in-class initializers. If a class has a member that has a class type, and that class doesn’t have a default constructor, then the compiler can’t initialize that member. For such cases, we must define our own constructor. Constructors should not override in-class initializers except to use a different initial value.

A class can allow another class or function to access its nonpublic members by making that class or function a friend. Friend declarations may appear anywhere in the class.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <iostream>
using namespace std;

// The only difference between struct and class is the default access level
// by default, members are public in struct, private in class
struct Sales_data
{
   friend istream &read(istream&, Sales_data&);
   friend ostream &print(ostream&, const Sales_data&);
public:
   Sales_data() = default; // C++ 11, the default constructor
   Sales_data(const string &s) : bookNo(s) { }
   Sales_data(const string &s, unsigned n, double p): bookNo(s), 
       units_sold(n), revenue(p*n) { }
   Sales_data(istream &);

   string isbn() const { return this->bookNo; }
   Sales_data& combine(const Sales_data&);
private:
   double avg_price() const { return units_sold ? revenue/units_sold : 0; }
   string bookNo; // default initializes bookNo to empty string
   unsigned units_sold = 0; // in-class initializer
   double revenue = 0.0;
};

// the scope operator :: means that this function is declared in Sales_data
Sales_data& Sales_data::combine(const Sales_data &rhs) {
   units_sold += rhs.units_sold;
   revenue += rhs.revenue;
   return *this; // return the object on which the function was called
}

Sales_data add(const Sales_data &lhs, const Sales_data &rhs){
   Sales_data sum = lhs;
   sum.combine(rhs);
   return sum;
}

ostream &print(ostream &os, const Sales_data &item){
   os << item.isbn() << " " << item.units_sold << " "
   << item.revenue << " " << item.avg_price() << endl;
   return os;
}

istream &read(istream &is, Sales_data &item){
   double price = 0;
   is >> item.bookNo >> item.units_sold >> price;
   item.revenue = price * item.units_sold;
   return is;
}

Sales_data::Sales_data(istream &is) {
   read(is, *this);
}

int main() {
   cout << "Please input data: bookNo, units_sold, price" << endl;
   Sales_data item1(cin);
   print(cout, item1);
   return 0;
}

4. A mutable data member is never const, even when it is a member of a const object.

When we provide an in-class initializer, we must do so following an = sign or inside braces.

It is important to understand that friendship is not transitive.

Member function definitions are processed after the compiler processes all of the declarations in the class. If function definitions were processed at the same time as the member declarations, then we would have to order the member functions so that they referred only to names already seen.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

#include <iostream>
#include <vector>
using namespace std;

class Screen; // forward declaration
class Link_screen
{
   // to use the incomplete class Screen, first we need forward declaration
   // then we can only define pointers or references to that class
   Screen* window;
   Link_screen *next;
   Link_screen *prev;
};

class Screen
{
   // friendship is not transitive, so if class Window_mgr has its own friends,
   // those friends have no special access to Screen
   friend class Window_mgr;
public:
   typedef string::size_type pos;
   Screen() = default; // needed because Screen has another constructor
   Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c) { }

   Screen& set(char);
   Screen& set(pos, pos, char);
   char get() const { return contents[cursor]; } // get the character at the cursor
   inline char get(pos r, pos c) const;
   Screen& move(pos r, pos c);
   void some_member() const;
   Screen& display(ostream& os) { do_display(os); return *this; }
   const Screen& display(ostream& os) const { do_display(os); return *this; }
private:
   void do_display(ostream& os) const { os << contents << endl; }

   pos cursor = 0;
   pos height = 0, width = 0; // the row number and column number
   string contents;
   mutable size_t access_ctr; // may change even in a const object
};

// the returned reference is lvalue
inline Screen& Screen::set(char c) {
   contents[cursor] = c;
   return *this;
}

inline Screen& Screen::set(pos r, pos col, char ch) {
   contents[r*width + col] = ch;
   return *this;
}

char Screen::get(pos r, pos c) const {
   pos row = r * width;
   return contents[row + c]; // return character at the given column
}

// specify inline on the definition
inline Screen& Screen::move(pos r, pos c) {
   pos row = r * width;
   cursor = row + c; // move cursor to the column within that row
   return *this;
}

void Screen::some_member() const {
   ++access_ctr; // keep a count of the calls to any member function
}

class Window_mgr
{
public:
   using ScreenIndex = vector<Screen>::size_type;
   void clear(ScreenIndex); // reset the Screen at the given position to all blanks
   ScreenIndex addScreen(const Screen&);
private:
   vector<Screen> screens { Screen(24, 80, ' ') }; // use = sign or inside braces
};

void Window_mgr::clear(ScreenIndex i) {
   Screen &s = screens[i];
   s.contents = string(s.height * s.width, ' ');
}

// :: is needed before ScreenIndex
Window_mgr::ScreenIndex Window_mgr::addScreen(const Screen &s) {
   screens.push_back(s);
   return screens.size() - 1;
}

int main() {
   class Screen myScreen(2, 5, '0'); // this "class" word is useless
   const Screen blank(2, 5, 'X');

   myScreen.set('#').display(cout);
   blank.display(cout);

   Screen::pos ht = 2, wd = 4; // use the scope operator "::"
   Screen scr(ht, wd, '-');
   scr.display(cout);

   return 0;
}

The parameter name will hide the class member name which has the same name with it. So don’t use a member name for a parameter or other local variable. If the compiler doesn’t find the name in function or class scope, it looks for the name in the surrounding scope.

5. We can often, but not always, ignore the distinction between whether a member is initialized or assigned. We must use the constructor initializer list to provide values for members that are const, reference, or of a class type that does not have a default constructor.

1
2
3
4
5
6
7
8

class ConstRef {
public:
   ConstRef(int ii);
private:
   int i;
   const int ci;
   int &ri;
};

For example, we write below code.

1

ConstRef::ConstRef(int ii) { i = ii; ci = ii; ri = i; }

This will be wrong, the right way is using the constructor initializer.

1

ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i) { }

The constructor initializer list sepcifies only the values, not the order in which those initializations are performed. Members are initialized in the order in which they appear in the class definition: the first member is initialized first, then next. It is a good idea to write constructor initializers in the same order as the members are declarde. Moreover, when possible, avoid using members to initialize other members.

6. C++ 11, the use of constructor initializers let us define the delegating constructors. A delegating constructor uses another constructor from its own class to perform its initialization.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Sales_data{
public:
   Sales_data(string s, unsigned cnt, double price):
           bookNo(s), units_sold(cnt), revenue(cnt*price){ }
   // delegating constructor
   Sales_data():Sales_data("", 0, 0) { }
   Sales_data(string s):Sales_data(s, 0, 0) { }
private:
   string bookNo;
   unsigned units_sold = 0;
   double revenue = 0.0;
};

7. The default constructor is used automatically whenever an object is default or value initialized. It happens （1）When we define nonstatic variables or arrays at block scope without initializers （2）When a class that has members of class type uses the synthesized default constructor （3）When members of class type are not explicitly initialized in a constructor initializer list （4）During array initialization when we provide fewer initializers than the size of the array （5）When we define a local static object without an initializer （6）When we explicitly request value initialization by writing an expressions of the form T() where T is the name of a type uses an argument of this kind to value initialize its element initializer. Classes must have a default constructor in order to be used in these contexts. What may be less obvious is the impact on classes that have data members that do not have default constructor.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class NoDefault{
public:
   NoDefault(string&); // this class has no default constructor
};
struct A{
   NoDefault my_mem;
};
A a;        // error: cannot synthesize a constructor for A
struct B{
   B(){ } //  error: no initializer for b_member
   NoDefault b_member;
};

The following declaration of obj is wrong. We should remove the empty parentheses.

1
2
3
4

class Sales_data {
};

Sales_data obj(); // ok, but defines a function, not an object

8. For automatically classs type conversion, only one class-type conversion is allowed. We can prevent use of a constructor in a context that requires an implict conversion by declaring constructor as explicit. The explicit keyword is meaningful only on constructors that can be called with a single argument. The explicit keyword is used only on the constructor declaration inside the class. When a constructor is declarde explicit, it can be used only with the direct form of initialization.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
using namespace std;

class Sales_data{
public:
   Sales_data() = default;
   Sales_data(const string &s, unsigned n, double p):
           bookNo(s), units_sold(n), revenue(p*n){ }

   // this constructor can not be used to implicitly create a Sales_data object
   explicit Sales_data(const string &s):Sales_data(s, 0, 0) { }

   Sales_data& combine(const Sales_data&);
private:
   string bookNo;
   unsigned units_sold = 0;
   double revenue = 0.0;
};

Sales_data& Sales_data::combine(const Sales_data &rhs) {
   units_sold += rhs.units_sold;
   revenue += rhs.revenue;
   return *this;
}

int main() {
   Sales_data item;
   // first, only one class-type conversion is allowed, so "string" can not be removed
   // second, the explicit Sales_data constructor will prevent implicit conversion
   //item.combine(string(""));
   item.combine(Sales_data("")); // force conversion
   // explicit constructors can be used only for direct initialization
   //Sales_data item2 = string("");
   return 0;
}