Chapter 2

2.3.1
void vector_init(Vector& v, int s) ,Vector& 中&指定通过非常量引用的方式传递v
2.3.2
class Vector {
public:
    Vector(int s): elem{new double[s]}, sz{s} {} //使用成员初始化器列表来初始化Vector成员
}
enum class Traffic_Light {red, blue, green}; 
//class 指明枚举是强类型，强类型是什么？不想限制具体类型就去掉class

2.4.1 分离编译

库通常是分离编译。

using namespace std; 
class Vector 
{ public : 
    Vector(int s):elem{new double[s]},sz{s}{}//构造函数，使用列表初始化
}

语句含义是 首先从自由存储获取s个double类型的元素，用一个指向这些元素的指针初始化elem；然后使用s初始化sz。

2.4.3.2不变式

在类中假定某事为真的声明为类的不变式

2.4.3.3静态断言

3.2.1.1 

const 表示不会修改调用的对象

class complex{
	double re, im;
public:
	complex(double r, double i): re{r},im{i} {}
	complex(double r):re{r}, im{0} {}
	complex():re{0}, im{0} {}

	double real() const {return re;}; //const是修饰什么的？const 表示不会修改所调用的对象
	void real(double d) {re = d;};
	double imag() const {return im;};
	void imag(double d){im = d;};

	complex& operator+=(complex z) {re+=z.re;im+=z.im;return *this; };
	complex& operator-=(complex z) {re-=z.re; im -= z.im; return *this;};
	complex& operator *= (complex);
	complex& operator /= (complex);
};

3.2.2

含有纯虚函数的类成为抽象类。

一元后置运算符&表示“……的引用”，类似于指针，唯一区别是无需使用前置运算符 *访问所引用的值。在指定函数的参数类型时，引用很有用。例如通过void sort(vector<double>& v) ,通过把参数类型定义成引用，在调用sort函数时就不必把实参拷贝给形参；还有一种情况是即不想修改实参的内容，又希望节省参数拷贝的代码，此时可以使用const 引用，例如double sum(const vector<double>&)

#include <stdlib.h>
#include <iostream>


using namespace std;

class Vector{
	//……
};

class Container{
public:
	virtual double& operator[](int) = 0;
	virtual int size() const = 0;
	virtual ~Container() {};
};

void use(Container& c){
	const int sz = c.size();
	for(int i = 0; i != sz; ++i){
		cout<<c[i]<<'\n';
	}
}

class Vector_container:public Container{
	Vector v;
public:
	Vector_container(int s):v(s){}
	~Vector_container(){}

	double& operator[](int i){return v[i];}
	int size() const {return v.size();}
};

void g(){
	Vector_container vc {10, 9, 8, 7, 6, 5};
	use(vc);
}

class List_Container: public Container{
	std::list<double> ld;
public:
	List_Container() {}
	~List_Container() {}
}

void h(){
	List_Container lc = {1 ,2 ,3, 4};
	use(lc);
}

这段代码的关键点是use(Container& )并不清楚它的实参是Vector_Container还是List_Container，它只要连接Container定义的接口就可以了。不论List_container的实现发生了变化还是我们使用了Container的一个全新派生类，都不需要重新编译use(Container&)

3.3.1

类作为资源句柄，类负责通过指针访问一个对象。

this预定义在成员函数中，它指向调用该成员函数的那个对象

3.3.2  移动容器

移动构造函数

Vector::Vector(Vector&& a)
    :elem{a.elem},
    sz{a.sz}
{
    a.elem = nullptr;
    a.sz = 0;
}

符号&& 表示“右值引用”；