1、C++的特点：

(1)支持面向对象编程机制，如信息隐藏、封装函数、抽象数据类型、继承、多态、函数重载、运算符重载、乏型编程（模板）
（2）继承自C语言的优点：语言简洁、紧凑，使用方便、灵活；拥有丰富的运算符；生成的目标代码质量高，程序执行效率高；可移植性好等。
(3)兼容C语言，并扩充C语言，如内联函数、函数重载、名字空间、更灵活、方便的内存管理（new、delete）、引用。
https://blog.csdn.net/ypshowm/article/details/89240902
C++对C的发展主要体现在：对C语言功能的扩充（详见第三点）、增加了面向对象的机制（详见第一点）

2、C++程序构成

（1）预处理指令；
（2）全局声明部分；
对自己定义的数据类型进行声明、对程序中所用到的变量进行定义。
（3）函数
可以有多个函数，但有且只有一个main()函数

3、从接受一个任务到获得最终结果的步骤

https://editor.csdn.net/md/?articleId=119190654

4、 编辑、编译、连接的作用

编辑：编写源代码，生成.cpp文件
编译：把源程序翻译成二进制的“目标程序”（.obj），对源程序进行语法检查和词法检查。
连接：将一个程序 所有目标程序和系统的库文件以及系统提供的其他信息连接起来，形成.exe文件。
编译后的目标文件还需要通过链接器把启动代码，库代码，和目标代码结合在一起，才能得到执行文件。不能直接运行后缀是.obj的目标文件，只能运行后缀为.exe的可执行文件。

5、该程序运行的结果应该是：This is a C++ program.

6、运行结果：a+b=33

7、运行结果：

8、

#include<iostream>
using namespace std;
//程序使用了cout，需要包含头文件iostream，同时加上using namespace std;
int main()//这里不能有分号
{
	int a,b,c;//没有先定义变量c 
	cin>>a>>b;//整个程序中没有对变量进行赋值。 
	c=a+b;
	cout<<"a+b="<<a+b;//输出流是<<
	return 0;//main函数是int类型，需要有一个返回值；另一种方法是把main函数类型改成void 
} 

9、

#include<iostream>
using namespace std;
int add(int x,int y); //先声明
int main(){
	int a,b,c;//没有先定义变量c 
	cin>>a>>b;//赋值 
	c=add(a,b);//少了分号 
	cout<<"a+b="<<c<<endl;
	return 0;
} 
int add(int x,int y){//函数要么放在main函数之前定义，要么在前面先声明才可以在main后面定义 ，而且这里不能加分号
	int z;//没有定义z 
	z=x+y;
	return(z);
} 

10、

该程序是对输入的三个整数进行从小到大的排序

c++复习 ，教材谭浩强《C++程序设计》第三版（以防你们需要这本书的电子版，特意上传到了蓝奏云），尽管这本书有些小错误，但是谭浩强讲的确实很通俗易懂。因为我是自学，虽然已经买了郑莉的书，但是谭浩强的更易懂。下面是我照着抄的代码，作为记录，方便自己复习。

 

第九章 怎样使用类和对象

构造函数

#include<iostream>
using namespace std;
class box {
	int l, w, h;
public:
	box() {
		l = 10;
		w = 10;
		h = 10;
	}
	int volume() {
		return l * w * h;
	}
};

int main() {
	box box1;//一定不能带括号
	cout << box1.volume() << endl;
}

总之，如果对象没有带参数，就不要带括号！！！如果带了括号，会被认为声明一个返回值类型为box的函数。

 

 

总之，一个类可以不用参数调用的构造函数只能有一个，不然会出现二义性。

析构函数

 各类指针

1.函数指针

调用函数的通常形式“函数名（参数表）”的实质就是“函数代码首地址（参数值）”。函数指针就是专门用于存放函数代码首地址的变量，也就是一旦函数指针指向某个函数，它与函数名的作用完全一样。 声明函数指针时，需要说明函数的返回值，参数列表。

语法形式：数据类型 (*函数指针名)(参数列表)     int(*m)(int, int); //声明函数指针,记得加括号，不然就变成了声明返回值为int指针的函数

赋值语法形式：函数指针名=函数名   m = &max;  //&可省略

调用形式：(*m)(1,2);或者m(1,2)；

2.对象指针：就是用于存放对象地址的指针的变量。

声明形式：类名 *对象指针名;

赋值形式：对象指针名=&对象名;   time* pt=&t;

访问对象成员：(*对象指针名).对象成员;或对象指针名->对象成员；    pt->display();   (*pt).display();

3.指向类成员的指针

1.指向对象非静态数据成员的指针
 声明形式：数据类型 *指针名;  int* s = &t.second;
 赋值形式：指针名=&对象名.数据成员名 (数据是公有才能被访问)

2.指向类静态数据成员的指针
 声明形式：数据类型 *指针名; 
 赋值形式：指针名=&类名::数据成员名(数据是公有才能被访问)  int *c = &time::count;
 int* c2 = &t.count;/也可以和非静态数据成员一样通过对象调用

 3.指向类成员函数的指针
  声明形式：数据类型 (类名::指针名)(参数列表);
  赋值形式：指针名=&类名::成员函数名 (&可以省去)
  void (time::* d)() = &time::display;  //括号不能省掉

#include<iostream>
using namespace std;

class time {
public:
	time(int h, int m, int s) :hour(h), minute(m), second(s) {
		count++;
	}
	void display() {
		cout << hour << ":" << minute << ":" << second << endl;
	}
	int second;
	static int count;
private:
	int hour, minute;
};
int time::count = 0;
int max(int a,int b) {
	return a > b ? a : b;
}

int main() {

	//1.调用函数的通常形式“函数名（参数表）”的实质就是“函数代码首地址（参数值）”
	//函数指针就是专门用于存放函数代码首地址的变量，也就是一旦函数指针指向某个函数，它与函数名的作用完全一样
	//声明函数指针时，需要说明函数的返回值，参数列表。
	//语法形式：数据类型 (*函数指针名)(参数列表) 赋值语法形式：函数指针名=函数名
	int(*m)(int, int); //声明函数指针,记得加括号，不然就变成了声明返回值为int指针的函数
	m = &max;  //&可省略
	cout << m(1, 2) << endl;
	//2.对象指针：就是用于存放对象地址的指针的变量。
	//声明形式：类名 *对象指针名; 赋值形式：对象指针名=&对象名; 访问对象成员：(*对象指针名).对象成员;或对象指针名->对象成员；
	time t(1,2,3);
	time* pt=&t;
	pt->display();
	(*pt).display();
	//3.1指向对象非静态数据成员的指针
	//声明形式：数据类型 *指针名; 
	//赋值形式：指针名=&对象名.数据成员名 (数据是公有才能被访问)
	int* s = &t.second;
	cout << *s << endl;
	//3.2指向对象静态数据成员的指针
	//声明形式：数据类型 *指针名; 
	//赋值形式：指针名=&类名::数据成员名(数据是公有才能被访问)
	int *c = &time::count;
	int* c2 = &t.count;
	cout << *c<<endl; //也可以和非静态数据成员一样通过对象调用
	//3.3指向对象成员函数的指针
	// 声明形式：数据类型 (类名::指针名)(参数列表);
	//赋值形式：指针名=&类名::成员函数名 (&可以省去)
	void (time::* d)() = &time::display;//括号不能省掉
	
}

共用数据的保护

1.常对象

定义形式：类名 const 对象名[(实参表)]；或者const 类名 对象名[(实参表)]; 定义常对象，必须同时对其初始化，之后不能再改变。常对象只能调用常成员函数

2.常数据成员

只能通过构造函数的初始化列表对常数据成员进行初始化，任何其他函数都不能对常数据成员赋值。

3.常成员函数

声明形式：类型 函数名(参数表) const。在声明和定义常成员函数时一定要加const，但调用时可以不加。常成员函数只能引用本类数据成员，而不能修改。

友元

#include<iostream>
using namespace std;
//提前引用声明
class date;
class time {
public:
	time(int, int, int);
	void display(date &d);

private:
	int hour, minute, second;
};
time::time(int a, int b, int c) :hour(a), minute(b), second(c) {

}
class date {
public:
	date(int y,int m,int d):year(y),month(m),day(d) {

	}
	//需要声明类time的display为友元函数，而不是仅仅声明display为友元函数
	friend void time::display(date& d);
private:
	int year, month, day;

};

void time::display(date& d) {
	cout << d.year<<"/"<<d.month<<"/"<<d.day<<"\t";
	cout << hour << ":" << minute << ":" << second << endl;

}

int main() {
	time t(13, 41, 56);
	date d(2020, 11, 28);
	t.display(d);

}

 当声明成员函数为友元函数时候，要记得加类名修饰。

类模板

#include<iostream>
using namespace std;

template <typename T>
class compare {
private:
	T a, b;
public:
	//构造函数
	compare(T a, T b) :a(a), b(b) {
	}
	T max();
	T min();
};
//如果将成员函数写在类外，需要附带template 
//而且类名后面还得加类型<T>
template<typename T>
T compare<T>::min() {
	return a < b ? a : b;
}


template<typename T>
T compare<T>::max() {
	return a > b ? a : b;
}


int main() {
	//需要在类模板名后面用尖括号指定实际的类型名
	compare <int>a(4, 5);
	cout << a.min() << endl;
	compare<double> m(2.2, 8343.0);
	cout << m.min() << endl;

	compare<bool>c(0, 10);
	cout << c.max();
	return 0;
}

 总之，就是一定要记得声明对象时用尖括号说明实际类型，还有函数体放在类外的时候要加template<typename T>; 而且同声明对象一样，也要在类名后面加尖括号说明虚拟类型。

 

第十章运算符重载

运算符重载为成员函数

#include<iostream>
using namespace std;

class complex {
	double real, image;

public:
	complex() {
		real = 0;
		image = 0;
	}
	complex(double real,double image): real(real),image(image){

	}
	complex operator+ (complex& c2) {
		return complex( real+c2.real,image+c2.image); //创建临时无名对象
	}
	complex operator-(complex&);
	void display();
};
complex complex::operator -(complex& c2) {
	return complex(real - c2.real, image - c2.image);
}
void complex::display() {
	cout << "(" << real << "," << image << "i)" << endl;
}

int main() {
	complex c1(5, 6),c2(1,1),c3;
	cout << "c1="; c1.display();
	cout << "c2="; c2.display();
	c3 = c1 + c2;
	cout << "c3=c1+c2="; c3.display();

}

第十一章派生类

其中很重要的就是三种继承方式：public、private、protected。

派生类的构造函数和析构函数

派生类构造函数的一般形式：派生类构造函数名（总参数表）：基类构造函数名（参数表）{派生类新增数据成员的初始化语句 }

在执行派生类的构造函数时，会调用基类的构造函数。

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

class student {

public:
	//定义基类构造函数
	student(int num,string name):num(num),name(name) {

	}
protected:
	int num;
	string name;
};
//声明公有继承
class student1 :public student {
	int age;
	char gender;
public:
	//定义派生类的构造函数
	student1(int num, string name, int age, char gender) :student(num,name),age(age),gender(gender){

	}
	void display() {
		cout << "num:" << num << endl;
		cout << "name:" << name << endl;
		cout << "age:" << age << endl;
		cout << "gender:" << gender << endl;
	}
};



int main() {
	student1 s1(101,"liu",22,'F');
	s1.display();
	return 0;
}

在定义派生类的构造函数时，同时也要给基类的构造函数初始化，注意，这里只是调用基类的构造函数，而不是定义基类的构造函数。

如果在类外定义派生类的构造函数，在类中对构造函数进行原型声明时，不用写“基类构造函数名（参数表）”，只有在定义函数的时候才将它列出。

class student1 :public student {
	int age;
	char gender;
public:
	//声明派生类的构造函数
	student1(int num, string name, int age, char gender);
	void display() {
		cout << "num:" << num << endl;
		cout << "name:" << name << endl;
		cout << "age:" << age << endl;
		cout << "gender:" << gender << endl;
	}
};

//在类外定义构造函数
student1::student1(int num, string name, int age, char gender) :student(num, name), age(age), gender(gender) {

}

多层级派生时的构造函数

一个类不仅可以派生出一个派生类，派生类还可以继续派生。在写构造函数数时，派生类只需要初始化直接基类的构造函数，无须列出每一级间接基类。

#include<string>
#include<iostream>
using namespace std;
//声明间接基类
class student {
public:
	//定义基类构造函数
	student(int num,string name):num(num),name(name) {
	}
protected:
	int num;
	string name;
};
//声明直接基类
class student1 :public student {
	int age;
public:
	//声明派生类的构造函数，只需要写直接基类的参数表即可。
	student1(int num, string name, int age) :student(num, name), age(age) {

	};
	void display1() {
		cout << "num:" << num << endl;
		cout << "name:" << name << endl;
		cout << "age:" << age << endl;
	}
};
//声明派生类
class student2 :public student1 {
	char gender;
public:
	student2(int num,string name,int age,char gender):student1(num,name,age),gender(gender) {
	}
	void display2() {
		display1();
		cout << "gender:" << gender << endl;
	}
};
int main() {
	student2 s2(101,"liu",22,'F');
	s2.display2();
	return 0;
}

派生类的析构函数

派生类是不能继承基类的析构函数的，也需要通派生类的析构函数去调用基类的析构函数。析构函数的调用顺序与构造函数正好相反：先执行派生类自己的析构函数，对派生类新增加的成员进行清理，然后调用子对象的析构函数，对子对象进行清理，最后调用基类的析构函数，对基类进行清理。

多重继承引起的二义性问题

int main{
    C c1;
    c1.A::a=3; //需要用指明c1的调用的是哪一个直接基类的成员
    c1.A::display(); //需要用指明c1的调用的是哪一个直接基类的成员
}

 

虚基类

注意：虚基类并不是在声明基类时声明的，而是在声明派生类时，指定继承方式时声明的。 声明虚基类的方式：

class 派生类名：virtual 继承方式 基类名;

在最后的派生类中，不仅要对其直接基类进行初始化，还要虚基类进行初始化。C++编译系统只执行对最后的派生类对虚基函数的调用，而忽略掉虚基类的其他派生类（如类类C、类B），这就保证了虚基类的数据成员不会被多次初始化。

#include<string>
#include<iostream>
using namespace std;
//声明公共基类
class person {
protected:
	string name;
	char sex;
	int age;
public:
	person(string name,char sex,int age):name(name),sex(sex),age(age){}
};
//person类的直接派生类,声明继承虚基类
class teacher :virtual public person {
public:
	//构造函数
	teacher(string name, char sex, int age,string title) :person(name, sex, age), title(title) {
	}
protected:
	string title;
};
//person类的直接派生类，用virtual声明person为虚基类
class student :virtual public person {
public:
	student(string name, char sex, int age, float score) :person(name, sex, age), score(score) {
	}
protected:
	float score;
};
//声明多重继承graduate类
class graduate :public student, public teacher {
	//要给直接基类初始化，还要给间接基类初始化
public:
	graduate(string name, char sex, int age,string title,float score,float wage):person(name,sex,age),teacher(name,sex,age,title),student(name,sex,age,score),wage(wage) {
	}
	void display() {
		cout << "name:" << name << endl;
		cout << "sex:" << sex << endl;
		cout << "age:" << age << endl;
		cout << "title:" << title << endl;
		cout << "score:" << score << endl;
		cout << "wage:" << wage << endl;
	}
protected:
	float wage;
};
int main() {
	graduate g1("wang", 'f', 22, "assistant", 90, 10000);
	g1.display();
}

累死我了，在给graduate写初始化列表时，真的太长一串了。虚基类牛逼，要给所有的基类初始化。

基类与派生类的转换

注意：只能用子类的对象给其基类对象进行赋值，而不能用基类的对象对其子类对象进行赋值。 

 

第十二章 多态性与虚函数

 

 

C++语言基础：
1. C++11增加了long long 类型，表示最小尺寸为64的整数。
2. 浮点数运算使用double，通常运算速度更快。
3. 超过int容量时使用long long类型，无符号数使用unsigned。
4. 切勿混用带符号类型和无符号类型，会隐式向无符号类型转换。
5. 指定字面值的类型前缀L表示宽字符，后置ULL表示无符号长整数。
6. C++中变量和对象通常意义下是一样的。
7. 对象是具有某种数据类型的内存空间。
8. 对象的初始化与赋值是两回事。
9. 引用不是对象，它只是为一个已经存在的对象所起的另一个名字。
10. 指针是指向另一种类型的复合类型，指针对象本身是一个对象，通常所说的指针指的就是指针对象。
11. 默认情况下，const对象只在文件内部有效，如果想在多个文件内共享const对象，必须在定义和声明之前添加extern关键字。
12. const对象一般是在.cpp中extern定义并初始化，在头文件中extern声明使用。
13. 常量引用是对const的引用，不能使用引用修改对象的值。
14. 不允许将非常量的引用绑定到常量对象上，但允许将常量引用绑定到非常量对象上。
15. 指向常量的指针不能用于改变其所指对象的值。
16. typedef和using两种方法可以为类型创建别名。
17. C++11引入auto关键字，让编译器替我们去分析表达式所属的类型。
18. C++11新标准规定可以为类内部成员提供一个类内初始值。
19. 头文件保护符依赖于预处理命令，与#pragma once相比，#ifndef易于跨平台。
20. 头文件不应该包含using声明。
21. C++语言规定&&操作符只有当左侧运算对象为真时才检查右侧对象，||操作符只有当左侧运算符为假时才检查右侧对象。
22. 运算符操作数之间存在算数转换和整形提升。
23. 尽量避免类型强转，必须时使用static_cast<>()来进行类型强转。
24. 函数无须改变形参引用的值，最好将其声明为常量引用。
25. 当以数组为形参时，通常显示的传递一个表示数组大小的形参。
26. main函数int main(int argc, char *argv[]){...}, argc为数组元素个数，argv[0]一定保持的是程序的名字，可选实参从argv[1]开始，argv[argc]一定为0。
27. C++11提供了可变数量的形参initializer_list<T> 来表示形参列表，类似于标准库的vector使用方法。
28. 在含有return语句循环后面也应该有一条return语句，因为循环可能不会被执行就退出，很多编译器无法发现此类错误。
29. 不要返回局部对象的引用或指针。
30. C++语言中名字查找先于类型检查。
31. 可以使用预处理命令来编写自己的条件调试代码，如#ifndef NDEBUG ... #endif。
32. C++编译器，预处理器提供了5个对于调试很有用的名字__func__,__FILE__,__LINE__,__TIME__,__DATE__。

类：
1. 类的基本思想是数据抽象和封装，数据抽象是一种依赖于接口和实现分离的编程(及设计)技术。
2. 类的成员函数通过一个名为this的隐藏形参来访问调用它的那个对象。
3. 默认情况下this是一个隐式的指向类类型的常量指针，保存的是调用对象的地址，不允许改变this的指向，但可以改变this指向的对象。
4. 类允许将const关键字置于成员函数参数列表之后，则该函数为常量成员函数，不能在其中改变调用它的对象的内容，成员函数的定义必须与声明匹配。
5. 与类相关的非成员函数可以声明为类的友元函数，类内部前置friend声明，友元函数可以访问类的私有成员，类外函数声明和定义不加friend前缀。
6. 类的构造函数和类同名，没有返回值，支持重载，任务是初始化类对象的数据成员，不能被声明为const的。
7. 类包含内置类型和复合类型的成员，只有当这些成员全都被赋予了类内的初始值时，这个类才适合使用合成的默认构造函数。
8. C++11允许使用后置关键字 = default指定默认构造函数和析构函数，带有形参的构造函数通常使用构造函数初始值列表来初始化数据成员。
9. 访问说明符加强类的封装性，public成员可以被整个程序访问，private成员仅可被类的成员函数访问。
10. class和struct关键字定义类的唯一区别是默认的访问权限不一样。
11. 类内部可以使用inline关键字显示的声明内联函数，类外定义，内联函数一般与类定义在同一个头文件中。
12. 类的前向声明，可以定义类的指针和引用，也可以作为参数或者返回值类型。
13. 类成员初始化的顺序与它们在类定义中出现的顺序一致，构造函数初始化列表不影响这个顺序。
14. 具有单个形参的构造函数声明可以前置explicit关键字来阻止隐式转换，定义前不加explicit关键字，只能用于直接初始化。
15. 前置static表明该成员为类的静态成员，归整个类共有，类的静态成员需要在.cpp中单独定义，定义不加static关键字，具有全局作用域。
16. 静态成员函数不与任何对象绑定，不能使用this指针，只能使用类的静态数据成员。

拷贝控制：
1. 拷贝构造函数，拷贝赋值运算符，析构函数统称为类的拷贝控制。
2. 拷贝构造函数与类名相同，无返回值，参数几乎总是一个自身类类型的const引用，通常不应该是explicit的。
3. 合成的拷贝构造函数会将其参数的非static成员依次拷贝到正在创建的对象中，指针只是浅拷贝。
4. 拷贝初始化将在下述情况中发生:使用=赋值运算符赋值新的对象;将一个对象作为实参传递给一个非引用类的形参;返回一个非引用类型的对象;用花括号列表初始化4一个数组的元素或聚合类的成员;标准库的insert和push等操作。
5. 使用关键字“operator运算符”作为函数名来重载运算符，常见的重载有=,==,!=,<<,+,<等。
6. 当重载运算符是一个成员函数时，this绑定到左侧运算对象，参数数量比运算对象少一个。
7. 重载赋值运算符=通常应该返回一个指向其左侧运算对象的引用，参数一般是自身类类型的const引用。
8. 析构函数释放对象使用的资源，并销毁对象的非static数据成员，当一个对象被销毁，就会调用析构函数。
9. 析构函数由~加类名构成，没有返回值，不接受参数，不能被重载，动态分配内存的类几乎总是需要析构函数。
10. 隐式销毁一个内置类型的指针，不会delete掉它所指向的对象。
11. 需要析构函数的类肯定也需要拷贝构造函数和重载赋值操作，拷贝和赋值几乎是等同的存在。
12. C++11允许后置=delete来阻止初始化，拷贝和赋值操作，旧标准通常声明其函数为private的来阻止这些操作。
13. 标准库IO类属于不能拷贝的类型，只能通过引用参数或引用返回值传递。

面向对象：
1. 面向对象的程序设计的核心思想是数据抽象、继承和动态绑定。
2. 基类需要将两种函数区分开来，希望派生类进行覆盖的函数和希望派生类直接继承的函数。
3. 基类希望派生类覆盖实现的函数声明为虚函数virtual，C++11允许后置override显示表明派生类改写的虚函数。
4. 基类通常应该定义一个虚析构函数，即时该函数不执行任何操作也是如此。
5. 当且仅当使用一个基类的引用或指针调用一个虚函数时将发生动态绑定。
6. 通常建议在设计时只使用单继承和公有继承public。
7. 基类希望派生类可以访问，但禁止其他用户访问的成员定义为protected。
8. 派生类不能继承基类的构造函数，拷贝构造函数，但能够继承析构函数。
9. 派生类对象含有与其基类对应的组成部分，允许将基类的指针或引用绑定到派生类对象的基类部分上，此时编译器会隐式的执行派生类到基类的类型转换。
10. 派生类向基类的隐式转换只对指针或引用类型有效，不存在基类向派生类的隐式转换。
11. 如果不特别指明，派生类对象的基类部分会像数据成员一样默认初始化，特别指明的情况下需要通过基类构造函数进行初始化。
12. 派生类对象的初始化顺序为首选初始化基类部分，然后按照声明的顺序依次初始化派生类成员。
13. 遵循基类的接口，应该只通过调用基类的构造函数来初始化从基类继承来的成员，不应该由派生类直接赋值，派生类构造函数应该只初始化它的直接基类。
14. 基类的静态成员在派生类中也只存在唯一实例。
15. C++11提供了防止继承发生的方法，在类的定义时后置关键字final。
16. 当使用基类的引用和指针时，实际上我们并不清楚该引用或指针所绑定的对象的真实类型。
17. 对非虚函数的调用和通过对象进行的虚函数调用都是在编译时绑定的。
18. 基类的一个函数被声明为virtual虚函数，在派生类中仍然是虚函数，派生类可以不使用virtual关键字。
19. 派送类覆盖了某个虚函数时，该函数的名称、形参、返回值必须基类中的完全匹配。
20. 派生类的虚函数调用它覆盖的基类的虚函数版本时需要使用作用域运算符::来回避虚函数机制。
21. 基类可以将虚函数后置=0声明为纯虚函数，纯虚函数无须定义。
22. 含有纯虚函数的类是抽象基类，抽象基类不能实例化对象，抽象基类负责定义接口，派生类覆盖实现接口。
23. 派生类的成员将隐藏同名的基类成员，除继承的虚函数外，派生类最好不要重用其基类的名字。
24. 理解派生类函数的调用过程中的名字查找和类型检查规则对于理解C++继承至关重要，名字查找先于类型检查。
25. 如果基类的析构函数不是虚函数，则delete一个指向派生类对象的基类指针将产生未定义的行为。
26. 容器和存在继承关系的类型无法兼容，当我们希望在容器中存放具有继承关系的对象时，我们通常的做法是基类的指针(更好的选择是智能指针)而非对象。
27. 继承为“是一种Is a”的关系，组合为“有一个has a”的关系，尽量多使用组合而非继承。
28. 友元关系不能被传递，也不能被继承。
29. 派生类的合成默认构造函数会先调用基类的合成默认构造函数。
30. 如果在派生类中显式调用基类的构造函数，只能在构造函数的初始化列表中调用，并且只能调用其直接父类的。
31. 当使用struct包含另外一个struct时，实际为C语言方式的继承，通常将内部的struct置于最前，此时可以用于类型强转。
32. 析构函数的执行顺序与构造函数完全相反。

异常处理：
1. 异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理。
2. 异常处理使用try{}catch(){ }语句块捕获，使用throw语句抛出异常。
3. 异常抛出后，捕获异常的过程为栈展开过程，沿着嵌套函数的调用链不断向外层查找，如没有被捕获，则终止当前程序。
4. 栈展开过程中对象按照作用域被自动销毁，调用的析构函数不应该抛出异常。
5. 编译器使用异常抛出表达式throw对异常对象进行拷贝初始化，意味着该对象类必须存在可访问的析构函数和拷贝构造函数，异常处理完毕后异常对象被销毁。
6. 当抛出一条表达式时，该表达式的静态编译时类型决定了异常对象的类型，如抛出一个基类指针，则实际指向的派生类对象被切断，只有基类部分被抛出。
7. catch子句的异常声明类型决定了处理代码所能捕获的异常类型，支持引用和非引用类型，通常情况下，最好使用引用类型。
8. catch语句的匹配过程按照其出现的顺序逐一匹配，所以越是专门的catch越应该置于前端，基类则放在最后。
9. 捕获所有异常的catch语句为 catch(...){ }，可以匹配任意的异常类型。
10. C++11中提供了noexcept说明某个函数不会抛出异常，方便编译器优化，语法是在声明和定义语句后置，如void func(int a) noexcept;。
11. 标准库异常类继承关系，exception-->(bas_cast,runtime_error,logic_error,bad_alloc)-->(invalid_argument,out_of_range,overflow_error,...)。
12. 标准库异常对象存在一个what虚函数成员，返回类型const char*，负责返回用于初始化异常对象的信息。
13. 我们可以编写自定义的异常类，一般都是继承标准库的异常类扩展。
14. Google的C++编程规范表明程序要根据适当情况慎重选择使用异常捕获和处理。
15. 异常发生期间正确执行了清理工作的程序被称作“异常安全”的代码。

命名空间：
1. 命名空间是为防止命名冲突提供了可控机制，每个命名空间有自己独立的作用域。
2. 定义命名空间 namespace NS{  }，命名空间可以嵌套定义，C++11引入内联命名空间inline namespace。
3. 命名空间可以是不连续的，可以跨越多个文件，多处定义同一个命名空间则为打开。
4. 命名空间的定义和使用都应该在#include后面，否则即是将整个.h文件名字都重新定义在命名空间内，容易造成错误。
5. 一般情况下，在.h文件内部定义或打开命名空间，.h文件一般包含属于该命名下的类型、变量和函数等成员。
6. 命名空间的使用包括using声明using NS::name;导入一条名字。 using指示using namespace NS;导入命名空间所有名字。
7. 一般在.h对应的实现cpp文件中使用using指示，通常在文件顶部#include下面；在用到该命名空间成员的其他.cpp中使用using声明，头文件不应该使用using声明。
8. 可以为命名空间创建别名简化命名空间的使用，如namespace primer = cplusplus_primer;
9. 全局命名空间以隐式的方式声明，并且在所有程序中存在， 如::member_name。
10. 未命名的命名空间namespace { }，该空间内的变量拥有静态生命周期，一般用来取代文件内的static静态声明，该空间的名字不需要前缀，直接使用。
11. 与其他命名空间不同，未命名的命名空间仅在特定文件内部有效，不能跨越多个文件，多个文件内定义的未命名空间相互独立，毫无关联。