一.初始化列表（初始化列表中必须有的两个内容）
1.类中const的成员变量：
①特点：不能修改 必须初始化 在构造函数后面加冒号 格式为：“:变量名(值)”
也就是说 常量必须在初始化列表中初始化
②执行顺序：构造函数先执行初始化列表 然后执行函数中的内容
1 #include<iostream>
2 using namespace std;
3
4 class CPerson
5 {
6 public:
7 const int a;
8 public:
9 CPerson():a(100)
10 {
11
12 }
13 void Show()
14 {
15 cout << a << endl;
16 }
17 };
18
19 int main()
20 {
21 CPerson ps;
22 ps.Show();
23
24 return 0;
25 }
2.组合关系的类中的构造函数有参数：
①例：包含了另一个类的对象要执行指定的构造函数
1 #include<iostream>
2 using namespace std;
3
4 class CHead
5 {
6 public:
7 CHead(int a)
8 {
9
10 }
11 };
12
13 class CPerson
14 {
15 public:
16 CHead head;
17 public:
18 CPerson():head(100)
19 {
20
21 }
22 };
23
24 int main()
25 {
26 CPerson ps;
27
28 return 0;
29 }
二.const常函数和常量对象
1.常函数：
①基本格式：void Show() const{ .. }
②特点：不能修改类中的成员变量
可以理解为 常函数参数括号中传的指针已经变成const CPerson* this这种指针了（拿CPerson为例）
也就是说 this已经变成const类型 这种指针的指向是不可以修改的 但是可以使用
2.常量对象：
①格式：const CPerson ps;
②特点：常量对象只能调用常函数 不能使用普通函数
可以理解为ps.Show(const CPerson*); 传入对象的地址类型不可改变
下面是一个常函数和常量函数的简单例子：
1 #include<iostream>
2 using namespace std;
3
4 class CPerson
5 {
6 public:
7 int m_nAge;
8 public:
9 CPerson()
10 {
11 m_nAge = 100;
12 }
13 public:
14 void Show() const
15 {
16 cout << m_nAge << endl;
17 }
18 void Show1()
19 {
20 m_nAge = 200;
21 cout << m_nAge << endl;
22 }
23 };
24
25 int main()
26 {
27 const CPerson ps;
28 CPerson ps1;
29 ps.Show();
30 ps1.Show1();
31
32 return 0;
33 }
三.虚函数与多态
1.引入：
①重载：同名 参数列表不同 调用父类的内容时要加作用域
②重写：同名 参数列表相同 全一致
③隐藏：是纵向重载 只要同名就好
2.父类的指针指向子类的对象：
①例如：CFather* pFather = new CSon;
②注意：这类指针只能看到父类的东西 但是子类的指针不能指向父类的对象
3.虚函数与多态：利用父类的复用性 充当接口类
①虚函数：virtual
作用：通过父类的指针调用子类的函数
注意：虚函数实现多态是基于重写来实现的 这使父类的指针具有多种形态
如果子类中重写了父类的函数 那么在虚函数列表中父类就被子类所覆盖
覆盖基于虚函数的重写 重写在子类中进行重写
1 #include<iostream>
2 using namespace std;
3
4 class CWater
5 {
6 public:
7 virtual void Show()
8 {
9 cout << "CWater::Show()" << endl;
10 }
11 };
12
13 class CMilk : public CWater
14 {
15 public:
16 void Show()
17 {
18 cout << "CMilk::Show()" << endl;
19 }
20 };
21
22 class CBeer : public CWater
23 {
24 public:
25 void Show()
26 {
27 cout << "CBeer::Show()" << endl;
28 }
29 };
30
31 void Bottle(CWater* cw)
32 {
33 cw -> Show();
34 }
35
36 int main()
37 {
38 CMilk cm;
39 CBeer cb;
40
41 Bottle(&cm);
42 Bottle(&cb);
43
44 return 0;
45 }
②多态：
用父类的指针指向子类 通过父类的指针调用子类成员函数
1 #include<iostream>
2 using namespace std;
3
4 class CFather
5 {
6 public:
7 virtual void AA()
8 {
9 cout << "CFather::AA()" << endl;
10 }
11 virtual void BB()
12 {
13 cout << "CFather::BB()" << endl;
14 }
15 void CC()
16 {
17 cout << "CFather::CC()" << endl;
18 }
19 };
20
21 class CSon : public CFather
22 {
23 public:
24 virtual void AA()
25 {
26 cout << "CSon::AA()" << endl;
27 }
28 void CC()
29 {
30 cout << "CSon::CC()" << endl;
31 }
32 void DD()
33 {
34 cout << "CSon::DD()" << endl;
35 }
36 };
37
38 int main()
39 {
40 CFather* cf1 = new CSon;
41
42 cf1 -> AA();
43 cf1 -> BB();
44 cf1 -> CC();
45
46 return 0;
47 }
4.（感觉上面整理的好乱）总结虚函数与多态：
①什么是多态：
父类的指针指向一个子类的对象 通过父类的指针调用实际子类的成员函数 这样才会使父类指针具有多种形态
②多态基于什么实现：
多态基于虚函数 虚函数基于重写
③多态的实现原理：虚函数列表和虚指针
在虚函数列表中 表中的每个元素都是一个函数指针 指向虚函数 或重写的虚函数
虚函数列表是在编译的时候就存在的 每一个类都有一个（对于普通的单继承来说）
虚指针就是记录使用哪一个列表的指针 在构造函数中被初始化 指向子类虚函数列表 这个指针是一个类成员
虚指针在创建对象的时候存在 在这个对象的首地址的前4个字节就是这个指针
那么我们就可以把调用一个虚函数理解为：通过虚指针拿到虚函数列表中的函数指针来实现调用的
④优缺点：
优点就是提高了复用性 扩展性
缺点就是安全性比较低 空间和效率问题也比较差
最后再放一个典型的例子加深理解：这段代码的输出足以说明这个问题
1 #include<iostream>
2 using namespace std;
3
4 class CFather
5 {
6 public:
7 void AA()
8 {
9 cout << "CFather::AA()" << endl;
10 }
11 virtual void BB()
12 {
13 cout << "CFather::BB()" << endl;
14 }
15 };
16
17 class CSon : public CFather
18 {
19 public:
20 void AA()
21 {
22 cout << "CSon::AA()" << endl;
23 }
24 virtual void BB()
25 {
26 cout << "CSon::BB()" << endl;
27 }
28 };
29
30 int main()
31 {
32 CFather* cf = new CSon;
33 cf -> AA();
34 cf -> BB();
35
36 CFather* cf1 = new CFather;
37 cf1 -> AA();
38 cf1 -> BB();
39
40 CSon* cs = new CSon;
41 cs -> AA();
42 cs -> BB();
43
44 return 0;
45 }
5.调用函数的区别：
①调用普通函数 调用哪一个函数 跟指针类型有关
②调用虚函数 看当前使用的虚函数列表是哪一个类的
③有作用域的话代表已经确定了 作用域的优先级别是最高的
6.纯虚函数：
①格式：virtual void 函数名() = 0;
②注意：
如果一个类包含纯虚函数 那这个类叫抽象类 抽象类是不可以定义对象的
在派生类中一定要实现纯虚函数 那么这个派生类 也叫具体类
如果一个类中的所有函数都是纯虚函数 那么这个类叫接口类
1 #include<iostream>
2 using namespace std;
3
4 class CPerson
5 {
6 public:
7 virtual void Eat() = 0;
8 };
9
10 class CChina : public CPerson
11 {
12 virtual void Eat()
13 {
14 cout << "CChina::Eat()" << endl;
15 }
16 };
17
18 int main()
19 {
20 CPerson* cp = new CChina;
21 cp -> Eat();
22
23 return 0;
24 }
原文地址：https://www.cnblogs.com/Aaaaaalei0612/p/9195188.html