Hi！这里是山幺幺的c++ primer系列。写这个系列的初衷是，虽然在学校学习了c++，但总觉得对这门语言了解不深，因此我想来啃啃著名的c++ primer，并在这里同步记录我的学习笔记。由于我啃的是英文版，所以笔记是中英文夹杂的那种。另外由于已有一定的编程基础，所以这个系列不会含有太基础的知识，想入门的朋友最好自己啃书嘻嘻~

关于数据抽象

核心思想

separation of interface (operations that users of the class can execute) and implementation (成员、函数等)，即encapsulation (封装)：users of the class can use the interface but have no access to the implementation

封装的好处

User code cannot inadvertently corrupt the state of an encapsulated object
The implementation of an encapsulated class can change over time without requiring changes in user-level code

this

通过对象调用成员函数时会隐式传该对象的地址

total.isbn() // 等价于
Sales_data::isbn(&total) // 此时，this绑定total

a const pointer to the nonconst version of the class type，所以 (by default) we cannot bind this to a const object，也就是说不能直接通过常对象调用其成员函数

常成员函数

std::string isbn() const { return bookNo; }

参数 list 后的 const 表示：常成员函数中的 this 是 const T *const 型，即 this 指向常量
isbn函数may read but not write to 成员变量
常变量、指向常变量的指针\引用只能调用常成员函数

关于作用域

一个类是一个作用域

定义在类外的成员函数，其名字前要加类名

Sales_data& Sales_data::combine(const Sales_data &rhs) { ... }

关于编译顺序

先编译 member declarations，再编译 member function bodies
所以 member function bodies may use other members of their class regardless of where in the class those members appear

I/O相关

栗子

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;
}
ostream &print(ostream &os, const Sales_data &item)
{
  os << item.isbn() << " " << item.units_sold << " "
  << item.revenue << " " << item.avg_price();
  return os;
}

注意

IO classes are types that cannot be copied, so we may only pass them by reference

Constructors

特点

没有return type
一个类可以有多个constructors，类似于重载
与类同名
不能被声明为const：定义一个常对象时，the object does not assume its “constness” until after the constructor completes the object’s initialization，因此，constructors can write to const objects during their construction

默认构造函数

class testClass
{
public:
    testClass();                    /* 默认构造函数1 */
    testClass(int a, char b);        /* 构造函数 */
    testClass(int a=10,char b='c');    /* 默认构造函数2 */

private:
    int  m_a;
    char m_b;
};

默认构造函数有两种：无参或所有参数都有默认值
一个类只能有一个默认构造函数，所以上段代码中的1和2不能共存
无论有没有其他构造函数，最好要自己定义一个默认构造函数，原因如下：
1. 若定义了其他构造函数，则编译器不会定义synthesized default constructor，那么该类就没有默认构造函数了，此时 testClass A; 这句话会报错，因为必须提供两个参数a和b
2. synthesized default constructor给的初始值可能是不合适的，对于内置类型或复合类型的变量，可能会初始化为未定义
3. sometimes the compiler is unable to synthesize one. For example, 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.

synthesized default constructor

若程序员未定义任何构造函数，编译器会定义构造函数：compiler-generated constructor is known as the synthesized default constructor
没有参数
初始化步骤
1. 若有 in-class initializer（即类中有 int x = 0之类的），则使用它
2. 否则，用 default-initialize

in-class initializer

= 型：int x = 0;
{} 型：std::vector<Screen> screens{Screen(24, 80, ' ') };

= default

Sales_data() = default;

= default 的含义是让编译器generate synthesized default constructor

只有一个参数的constructor

可以把参数隐式转换为类类型，比如下面这段代码中：the compiler automatically creates a Sales_data object from the given string. That newly generated (temporary) Sales_data is passed to combine

class Sales_data {
public:
  // defines the default constructor as well as one that takes a string argument
  Sales_data(std::string s = ""): bookNo(s) { }
  Sales_data &combine(const Sales_data& s) { ... }
}

string null_book = "9-999-99999-9";
// constructs a temporary Sales_data object with units_sold and revenue equal to 0 and bookNo equal to null_book
item.combine(null_book);

只允许隐式转换一次

// error: requires two user-defined conversions:
// (1) convert "9-999-99999-9" to string
// (2) convert that (temporary) string to Sales_data
item.combine("9-999-99999-9");
// ok: explicit conversion to string, implicit conversion to Sales_data
item.combine(string("9-999-99999-9"));
// ok: implicit conversion to string, explicit conversion to Sales_data
item.combine(Sales_data("9-999-99999-9"));
item.combine(static_cast<Sales_data>("9-999-99999-9"));

特殊情形：用输入构造对象

Sales_data::Sales_data(std::istream&) { ... };
item.combine(cin);

禁止隐式转换：explicit（这个关键字只对含单个参数的constructor有用，且只能出现在class中）

class Sales_data {
public:
  Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) { }
  explicit Sales_data(const std::string &s): bookNo(s) { }
  explicit Sales_data(std::istream&);
};
// 下面的编译不通过
item.combine(null_book); // error: string constructor is explicit
item.combine(cin); // error: istream constructor is explicit

// error: explicit allowed only on a constructor declaration in a class header
explicit Sales_data::Sales_data(istream& is) { read(is, *this); }

explicit的另一个性质：explicit Constructors Can Be Used Only for Direct Initialization

Sales_data item1 (null_book); // ok: direct initialization
// error: cannot use the copy form of initialization with an explicit constructor
Sales_data item2 = null_book;

使用explicit constructor的library class

vector<T> v(n); // 使用了explicit constructor

Constructor Initializer List

Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) { }

若只提供了s，则units_sold和revenue会被synthesized default constructor初始化
即使没有Constructor Initializer List，the members of this object are still initialized before the constructor body is executed
Members that do not appear in the constructor initializer list are initialized by the corresponding in-class initializer (if there is one) or are default initialized
执行完Constructor Initializer List才会执行函数体

用Constructor Initializer List初始化与赋值

此为Constructor Initializer List初始化

Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) { }

此为赋值

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

Constructor Initializer List初始化与赋值的不同程度取决于the type of the data member
必须Constructor Initializer List初始化的情形：① const成员 ② 引用成员 ③ 没有默认构造函数的类的对象

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

// error: ci and ri must be initialized
ConstRef::ConstRef(int ii)
{ // assignments:
  i = ii; // ok
  ci = ii; // error: cannot assign to a const
  ri = i; // error: ri was never initialized
}

// ok: explicitly initialize reference and const members
ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i) { }

初始化顺序

Members are initialized in the order in which they appear in the class definition
与Constructor Initializer List无关

class X {
  int i;
  int j;
public:
  // undefined: i is initialized before j
  X(int val): j(val), i(j) { }
};

Delegating Constructors

A delegating constructor uses another constructor from its own class to perform its initialization
栗子

class Sales_data {
public:
  // nondelegating constructor initializes members from corresponding arguments
  Sales_data(std::string s, unsigned cnt, double price): bookNo(s), units_sold(cnt), revenue(cnt*price) { }
  // remaining constructors all delegate to another constructor
  Sales_data(): Sales_data("", 0, 0) {}
  Sales_data(std::string s): Sales_data(s, 0,0) {}
  Sales_data(std::istream &is): Sales_data() { read(is, *this); }
  // ...
};

Copy, Assignment, and Destruction

synthesized

若未定义这些操作，编译器会synthesize them for us
编译器生成的操作 execute by copying, assigning, or destroying each member of the object
the synthesized versions are unlikely to work correctly for classes that allocate resources that reside outside the class objects themselves：比如，管理动态内存的类

Access Specifiers

public

accessible to all parts of the program
定义了类的接口

private

accessible to the member functions of the class
封装了类的实现

struct与class

struct 默认是 public
class 默认是 private

Friend

定义及性质

一个类的友元函数/类可以access its nonpublic members
friendship没有传递性和交换性
友元的声明只能在类内，但可以在类内任何位置，效果等价
在friend声明语句中（即开头是friend的语句）可以使用未声明的类和非成员函数
在friend声明语句中出现的name（不含友元函数/类本身）被视为对该友元所在scope可见，友元函数/类本身（哪怕在声明的同时定义了，也）被视为不可见

struct X {
  friend void f() { /* friend function can be defined in the class body */ }
  X() { f(); } // error: no declaration for f
  void g();
  void h();
};
void X::g() { return f(); } // error: f hasn't been declared
void f(); // declares the function defined inside X
void X::h() { return f(); } // ok: declaration for f is now in scope

友元函数

友元函数的定义：在类中加一句该函数的声明，并以friend开头（友元函数声明可以出现在类内的任何位置）

class Sales_data {
// friend declarations for nonmember Sales_data operations added
friend Sales_data add(const Sales_data&, const Sales_data&);
friend std::istream &read(std::istream&, Sales_data&);
friend std::ostream &print(std::ostream&, const Sales_data&);
// other members and access specifiers as before
public:
...

类中对友元函数的声明并不是general function declaration，friend functions must be declared/defined outside the class before they can be used（不过有的编译器并不要求这样）
可以在类内定义友元函数，自动inline

友元类

class Screen {
  // Window_mgr members can access the private parts of class Screen
  friend class Window_mgr;
  // ... 
};

友元成员函数

class Screen {
  // Window_mgr::clear must have been declared before class Screen
  friend void Window_mgr::clear(ScreenIndex);
  // ... 
};

上段代码要求按顺序完成如下步骤：① define the Window_mgr class, which declares, but cannot define, clear（因为Screen must be declared before clear can use the members of Screen）② define class Screen, including a friend declaration for clear ③ define clear, which can now refer to the members in Screen

类中的type definition

栗子

class Screen {
public:
  typedef std::string::size_type pos;
  // alternative way to declare a type member using a type alias
  using pos = std::string::size_type;
private:
  pos cursor = 0;
  pos height = 0, width = 0;
  std::string contents;
};

注意

unlike ordinary members, members that define types must appear before they are used

如何把成员函数变为inline

member functions defined inside the class are automatically inline

在类中的声明前加上inline

class Screen {
public:
  char get() const { return contents[cursor]; } // implicitly inline
  inline char get(pos ht, pos wd) const; // explicitly inline
  Screen &move(pos r, pos c); // can be made inline later
  ...
}

在类外的定义前加上inline

inline // we can specify inline on the definition
Screen &Screen::move(pos r, pos c)
{
  pos row = r * width; // compute the row location
  cursor = row + c ; // move cursor to the column within that row
  return *this; // return this object as an lvalue
}

mutable Data Members

即使在 const 对象中，mutable data members 也不是 const 的
任何成员函数，包括 const 成员函数都 may change a mutable member
定义格式：mutable T variable_name

return *this;

返回类型为引用 vs 为非引用

myScreen.move(4,0).set('#');
// 若move的返回类型是Screen&，则等价于
myScreen.move(4,0); // return 当前对象的引用，即 return 的是左值，not a copy of the object
myScreen.set('#');
// 若move的返回类型是Screen，则等价于
Screen temp = myScreen.move(4,0); // the return value would be copied
temp.set('#'); // the contents inside myScreen would be unchanged

关于const

A const member function that returns *this as a reference should have a return type that is a reference to const
常对象只能调用常函数；非常对象可以调用常函数和非常函数，但有重载时，非常函数是一个更好的匹配

类对象的定义

Sales_data item1; // default-initialized object of type Sales_data
class Sales_data item1; // equivalent declaration

第二行是从c继承过来的

类的声明

class Screen;

声明后，it’s known that Screen is a class type but not known what members that type contains
只声明而未定义的类类型只能用于：define pointers or references to such types；declare (but not define) functions that use it as a parameter or return type
只有在定义了类之后，才能定义该类的对象，因为编译器需要知道该对象需要多大的存储空间
类的data members只能是定义了的类类型（有一个例外：）
因为在类的body complete前该类都是未定义的，所以a class cannot have data members of its own type
只要类名出现，就认为该类已声明，因此a class can have data members that are pointers or references to its own type
member function bodies中可以用any name defined inside the class（因为函数体最后编译），但函数的parameter list和return type中只能使用在该函数之前出现的name，栗子：

typedef double Money;
string bal;
class Account {
public:
  Money balance() { return bal; } // 这里的Money是double，bal是Money
  typedef int Money; // error：不能再定义Money了
  typedef double Money; // error：哪怕是相同的double也不可
private:
  Money bal;
};

一般来说，an inner scope can redefine a name from an outer scope，但如果该name是一个type，则类不可以redefine它

类的作用域

对于在类外定义的成员函数：parameter list and the function body中可以直接出现类中定义的类型；返回类型中要用类中定义的类型，则必须加上“类名::”【Because the return type appears before the name of the class is seen, it appears outside the scope of class Window_mgr】

class Window_mgr {
public:
  ScreenIndex addScreen(const Screen&, ScreenIndex);
  ...
};

Window_mgr::ScreenIndex Window_mgr::addScreen(const Screen &s, ScreenIndex i) { 
  ... 
}

类的编译过程

步骤

第一步：编译member declarations
第二步：Function bodies are compiled only after the entire class has been seen

成员函数的找名过程

对于成员函数中使用的name，找名过程如下：

第一步：look for a declaration of the name inside the member function and precede the use of the name
第二步：look for a declaration inside the class. All the members of the class are considered
第三步：look for a declaration that is in scope before the member function definition

int height; // defines a name subsequently used inside Screen

class Screen {
public:
  typedef std::string::size_type pos;
  void dummy_fcn(pos);
private:
  pos cursor = 0;
  pos height = 0, width = 0;
};

void Screen::dummy_fcn(pos height) {
  cursor = width * height; // the parameter height
  cursor = width * this->height; // member height
  cursor = width * Screen::height; // member height
  cursor = width * ::height;// the global height
}

定义对象vs定义函数

定义函数

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

定义对象

Sales_data obj; // ok: obj is a default-initialized object

Aggregate Classes（聚合类）

定义

满足如下条件的是aggregate class：

所有data members都是public
没有定义任何constructor
没有in-class initializer
没有base classes
没有virtual functions

栗子

struct Data {
  int ival;
  string s;
};

初始化

格式

Data val1 = { 0, "Anna" };

if the list of initializers has fewer elements than the class has members, the trailing members are value initialized

Literal Classes

定义

data members are all of literal type的聚合类是literal class；满足如下条件的非聚合类是literal class：
- data members all must have literal type
- 至少有一个constexpr constructor
- in-class initializer for built-in type必须是constant expression，in-class initializer for class必须使用那个class的constexpr constructor
- must use default definition for its destructor

特性

literal class的constructor可以是constexpr function
constexpr constructor的要求：函数体必须为空、必须initialize every data member、initializers must either use a constexpr constructor or be a constant expression
constexpr constructor的作用：generate objects that are constexpr、generate parameters or return types in constexpr functions
Literal Classes可以包含非constexpr的函数，也可以作为普通类型使用，但作为constexpr常量时，只能使用其constexpr的构造函数和成员函数
Literal Classes可以让constexpr常量在编译时初始化，参与编译时的优化，而不是像static那样推迟到程序启动时，这使得constexpr常量对象可以被放在程序的资源中

栗子

class Debug {
public:
  constexpr Debug(bool b = true): hw(b), io(b), other(b) { }
  constexpr Debug(bool h, bool i, bool o): hw(h), io(i), other(o) { }
   constexpr bool any() { return hw || io || other; }
  void set_io(bool b) { io = b; }
  void set_hw(bool b) { hw = b; }
  void set_other(bool b) { hw = b; }
private:
  bool hw; // hardware errors other than IO errors
  bool io; // IO errors
  bool other; // other errors
};

静态成员

static的含义

静态成员associated with class, not object

声明静态成员

栗子：each Account object will contain two data members—owner and amount. There is only one interestRate object that will be shared by all the Account objects.

class Account {
public:
  void calculate() { amount += amount * interestRate; }
  static double rate() { return interestRate; }
  static void rate(double);
private:
  std::string owner;
  double amount;
  static double interestRate;
  static double initRate();
};

静态成员函数

not bound to any object，所以没有this指针，函数体内无法使用this，也不能call a nonstatic member（因为需要implicitly使用this）
不能be declared as const（const是表明：函数不会修改该函数访问的目标对象的数据成员，而静态成员函数只能访问其参数、静态数据成员和全局变量，这些数据都不是对象状态的一部分，所以肯定不会修改“目标对象的数据成员”，没必要用const）

使用静态成员

用scope operator

r = Account::rate();

用该类的object/reference/pointer

Account ac1;
Account *ac2 = &ac1;
// equivalent ways to call the static member rate function
r = ac1.rate(); // through an Account object or reference
r = ac2->rate(); // through a pointer to an Account object

成员函数可以直接使用静态成员

class Account {
public:
  void calculate() { amount += amount * interestRate; }
private:
  static double interestRate;
};

定义静态成员

在类外定义静态成员函数时，不需要再写static关键字

void Account::rate(double newRate)
{
  interestRate = newRate;
}

静态成员的初始化

not defined when we create objects of the class，因此也not initialized by the class’ constructors
we must define and initialize each static data member outside the class body & outside any functions（因此生存期until the program completes）【除了下面的特殊情况：“静态数据成员的In-Class Initialization”】
a static data member may be defined only once

double Account::interestRate = initRate();

静态数据成员的In-Class Initialization

对const integral类型的静态数据成员，可以in-class initialize（但最好是在类外初始化）
对constexprs of literal type类型的静态数据成员，必须in-class initialize，且initializer必须是constant expression
若const或constexpr静态数据成员只在contexts where the compiler can substitute the member’s value中使用（比如下面这段代码），则可以不在类外定义它；否则（比如要pass Account::period to a function that takes a const int&），必须在类外定义它，而且如果它有In-Class Initialization，那么类外的定义不能给它初始值

class Account {
public:
  static double rate() { return interestRate; }
  static void rate(double);
private:
  static constexpr int period = 30;// period is a constant expression
  double daily_tbl[period];
};
// 类外定义
constexpr int Account::period; // initializer provided in the class definition

静态成员的特殊性质

静态数据成员可以是已声明而未定义的类型，比如，其类型可以是该类本身

class Bar {
public:
  // ...
private:
  static Bar mem1; // ok: static member can have incomplete type
  Bar *mem2; // ok: pointer member can have incomplete type
  Bar mem3; // error: data members must have complete type
};

we can use a static member as a default argument
PS：使用非静态数据成员做为默认参数是错误的，因为这时没有一个具体的对象，无法从中得到成员的值

class Screen {
public:
  Screen& clear(char = bkground);
private:
  static const char bkground;
};

C++ primer 第七章-类

关于数据抽象

核心思想

封装的好处

this

常成员函数

关于作用域

关于编译顺序

I/O相关

栗子

注意

Constructors

特点

默认构造函数

synthesized default constructor

in-class initializer

= default

只有一个参数的constructor

Constructor Initializer List

用Constructor Initializer List初始化 与 赋值

初始化顺序

Delegating Constructors

Copy, Assignment, and Destruction

synthesized

Access Specifiers

public

private

struct与class

Friend

定义及性质

友元函数

友元类

友元成员函数

类中的type definition

栗子

注意

如何把成员函数变为inline

mutable Data Members

return *this;

返回类型为引用 vs 为非引用

关于const

类对象的定义

类的声明

类的作用域

类的编译过程

步骤

成员函数的找名过程

定义对象vs定义函数

定义函数

定义对象

Aggregate Classes（聚合类）

定义

栗子

初始化

Literal Classes

定义

特性

栗子

静态成员

static的含义

声明静态成员

静态成员函数

使用静态成员

定义静态成员

静态成员的初始化

静态数据成员的In-Class Initialization

静态成员的特殊性质

用Constructor Initializer List初始化与赋值