C++ primer学习笔记 - 第十五章 面向对象程序设计

一、OOP：概述

• 继承(inheritance)

通过继承机制，可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类

• 动态绑定(dynamic binding)

动态绑定是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。程序运行过程中，把函数（或过程）调用与响应调用所需要的代码相结合的过程称为动态绑定。

• 静态绑定

静态绑定是指在程序编译过程中，把函数（方法或者过程）调用与响应调用所需的代码结合的过程称之为静态绑定。

二、定义基类和派生类

定义基类

定义派生类

每个类控制它自己的成员初始化过程。
首先初始化基类部分，然后按照声明的顺序依次初始化派生类的成员
(派生类可以访问基类的共有成员和受保护成员)

---

声明(不需要派生列表)

class B;
class A :B;

class B;
class A;
class A:B{};

类型转换和继承

继承与普通成员

派生类对象 = 自己的成员 + 基类成员

---

继承与静态成员

基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例
静态成员遵守通用给的访问控制规则，如果基类中的成员是private，则派生类无全访问;
如果静态成员是可访问的，我们既能通过基类使用它也能通过派生类使用它；

---

final关键字(防止类继承)

class A final {};
class B :A{};

---

类型转换
可以从派生类向基类转换,但是基类不能向派生类转换.

当我们用一个派生类对象为一个基类对象初始化或赋值时，只有该派生类对象中的基类部分会被拷贝、移动或赋值，它的派生类部分将被忽略掉.

三、虚函数

那些被virtual关键字修饰的成员函数，就是虚函数

final 关键字:

override 关键字:

override保留字表示当前函数重写了基类的虚函数

• 1.在函数比较多的情况下可以提示读者某个函数重写了基类虚函数（表示这个虚函数是从基类继承，不是派生类自己定义的）
• 2.强制编译器检查某个函数是否重写基类虚函数，如果没有则报错。

虚函数和默认实参:

像其他任何函数一样，虚函数也可以有默认实参。通常，如果有用在给定调用中的默认实参值，该值将在编译时确定。如果一个调用省略了默认值的实参，则所用的值由调用该函数的类型定义，与对象的动态类型无关。

如果基类virtual函数中的默认实参和派生类中的默认实参不同**，则一定会引起错误**。原因在于这个值是在编译时确定，而且只与调用函数的类型有关，而和动态类型无关。也就是说，当动态绑定发生的时候，想要使用派生类中的默认实参，是使用的确是基类的！

回避虚函数机制:

在派生类重写的函数中，如果要调用基类中相应的虚函数，此时如果没有作用域限定，则将陷入无限递归的状态，因此需要加上基类的作用域限定符，才能防止这种情况

友元和继承

友元关系不能传递,同样也不能继承,基类的友元在访问派生类成员时不具有特殊性。

派生类向基类转换的可访问性

• 只有当D公有继承B时，用户代码才能使用派生类向基类的转换；如果D继承B的方式是受保护的或者私有的，则用户代码不能使用该转换

class A{};
class B: public A{};
class C : protected A {};
class D : private A {};
int main()
{
	B b;
	C c;
	D d;
	A a = b;
	A a1 = c;
	A a2 = d;
}

• 无论D以什么方式继承B，D的成员和友元都能使用派生类向基类的转换；派生类向其直接基类的类型转换对于派生类的成员和友元来说永远是可访问的

class A{};
class B : public A { public: void changBToA(B b) { A a = b; } };
class C : protected A { public: void changCToA(C c) { A a = c; } };
class D : private A 
{ 
	friend void friendD(D d);
public: 
	void changDToA(D d) { A a = d; }; };
void friendD(D d)
{
	A a = d;
}

• 如果D继承B的方式是公有或者受保护的，则D的派生类的成员和友元可以使用D向B的类型转换；反之，如果D继承B的方式是私有的，则不能使用,而且D派生类的成员和友元不能使用A

class A{};
class B : public A { public: void changBToA(B b) { A a = b; } };
class D : private A 
{ 
	friend void friendD(D d);
public: 
	void changDToA(D d) { A a = d; }; };
void friendD(D d)
{
	A a = d;
}
class E:B{ public: void changBToA(E e) { A a = e; } };

class F :D { public: void changBToA(F f) { A a = f; } };

四、抽象基类

抽象类（abstract base class,ABC）就是类里定义了纯虚成员函数的类。纯虚函数一般只提供了接口，并不会做具体实现（虽然可以），实现由它的派生类去重写。抽象类不能被实例化(不能创建对象)，通常是作为基类供子类继承，子类中重写虚函数，实现具体的接口。简言之，ABC描述的是至少使用一个纯虚函数的接口，从ABC派生出的类将根据派生类的具体特征，使用常规虚函数来实现这种接口。

纯虚函数:（虚函数的函数体=0）

五、访问控制与继承

继承类型	基类成员访问说明符	派生类成员访问说明符
public	public	public
	protected	private
	private	private
protected	public	protected
	protected	protected
	private	private
private	public	private
	protected	private
	private	private

六、继承中的类作用域

在编译时进行名字查找

一个对象、引用或指针的静态类型决定了该对象的哪些成员是可见的。即使静态类型和动态类型可能不一致，但能使用那些成员仍然是静态类型决定的。

名字冲突和继承

和其他作用域一样，派生类也能重用定义在其基类或间接基类中的名字。此时定义在内层作用域（即派生类）的名字将隐藏定义在外层作用域（即基类）的名字。

struct Base {
	Base() :mem(0) {}
	int get_mem() { return mem; }
protected:
	int mem;
};

struct Derived :Base {
	// 用 i 初始化 Derived::mem  Base::mem 进行默认初始化
	Derived(int i) :mem(i) {}
protected:
	int mem;		// 隐藏基类中的 mem
};

int main()
{
	Base b;
	Derived d(10);
	std::cout << d.get_mem() << std::endl;
	std::cout << b.get_mem() << std::endl;
}

修改派生类

struct Derived :Base {
	// 用 i 初始化 Derived::mem  Base::mem 进行默认初始化
	Derived(int i) :mem(i) {}
	int get_mem(int a) { return mem; }
protected:
	int mem;		// 隐藏基类中的 mem
};

调用d.get_mem() 报错,因为基类中get_mem函数已经被覆盖

通过作用域运算符来使用隐藏的成员

int get_base_mem() { return Base::mem; }

除了覆盖继承而来的虚函数之外，派生类最好不要重用其他定义在基类中的名字

名字查找与继承

假定调用 p->mem()，则依次执行以下四个步骤：

• 首先确定 p 的静态类型。因为我们调用的是一个成员，所以该类型必然是类类型。
• 在 p 的静态类型对应的类中查找 mem。如果找不到，则依次在直接基类中不断查找直到到达继承链的顶端。如果找遍了该类及其基类仍然找不到，则编译器将报错。
• 一旦找到了 mem，就进行常规的类型检查以确认对于当前找到的 mem，本次调用是否合法。
• 假设调用合法，则编译器将根据调用的是否是虚函数而产生不同的代码：
  —如果 mem是虚函数且我们是通过引用或指针进行的调用，则编译器产生的代码将在运行时确定到底运行该函数的哪个版本，依据对象的动态类型。
  —反之，如果 mem不是虚函数或则我们是通过对象进行的调用，则编译器将产生一个常规函数调用。

名字查找优先于类型检查

• 首先确定 p 的静态类型。因为我们调用的是一个成员，所以该类型必然是类类型。
• 在 p 的静态类型对应的类中查找 mem。如果找不到，则依次在直接基类中不断查找直到到达继承链的顶端。如果找遍了该类及其基类仍然找不到，则编译器将报错。
• 如果找到然后看参数是否能匹配。如果没有与之匹配的则，编译错误。

覆盖重载的函数

和其他函数一样，成员函数无论是否事虚函数都能被重载，派生类可以覆盖重载函数的0个或多个实例。如果派生类希望所有的重载版本对它来说是可见的，那么它就需要覆盖所有的版本,或则一个也不覆盖。
可以使用using声明语句,这样我们就无需覆盖基类中的每一个重载版本了。

struct Base {
	Base() :mem("Base") {}
	Base(std::string _mem) :mem(_mem) {}
	std::string get_mem() { return mem; }
protected:
	std::string mem;
};

struct Derived :Base {
	// 用 i 初始化 Derived::mem  Base::mem 进行默认初始化
	Derived(std::string _mem):Base(_mem) {}
	using Base::get_mem;
	int get_mem(int a) { return a; }
};
struct Derived1 :Derived {
	// 用 i 初始化 Derived::mem  Base::mem 进行默认初始化
	Derived1(std::string _mem) :Derived(_mem) {}
};

int main()
{
	Derived d("Derived");
	std::cout << d.get_mem() << std::endl;
	Derived1 d1("Derived1");
	std::cout << d1.get_mem() << std::endl;
}

七、构造函数和拷贝函数

虚析构函数

总的来说虚析构函数是为了避免内存泄露，而且是当子类中会有指针成员变量时才会使用得到的。也就说虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的目的，而防止内存泄露的.

struct Base {
	Base():mem(new std::string("Base")) {}
	Base(std::string s) :mem(new std::string(s)) {}
	virtual ~Base() { std::cout << "~Base()" << std::endl; delete mem; }
protected:
	std::string *mem;
};

struct Derived :Base {
	Derived() :Base("Derived"),mem_p(new std::string("Derived mem_p")) {}
	virtual ~Derived() { 
		std::cout << "~Derived()" << std::endl;
		delete mem_p;
	}
protected:
	std::string* mem_p;
};
int main()
{
	Base *b = new Derived();
	delete b;

}

如果一个类定义一个析构函数，即使它通过=default的形式使用了合成的版本,编译器也不会为这个类合成移动操作.

合成拷贝控制与继承

基类或派生类的合成拷贝控制成员的行为与其他合成的构造函数、赋值运算符或析构函数类型：
它们对类本身的成员依次进行初始化、赋值或销毁的操作
无论基类成员是合成的版本还是自定义的版本都没有太大的影响，唯一的要求是相应的成员是可访问并且不是一个被删除的函数。

继承体系中所有类使用合成的析构函数，派生类隐式得使用而基类通过将其析构函数定义成 =default 而显式地使用。合成地析构函数体是空地，其隐式的析构部分负责销毁类的成员。对于派生类的析构函数来说，除了销毁派生类自己的成员外，还负责销毁派生类的直接基类，该直接基类又销毁它的直接基类，以此类推直至继承链的顶端

---

派生类中删除的拷贝控制与基类的关系:

• 如果基类中的默认构造函数、拷贝构造函数、拷贝赋值运算符或析构函数是被删除的函数或者不可访问，则派生类中对应的成员将是被删除的，原因是编译器不能使用基类成员来执行派生类对象来执行派生类对象基类部分的构造、赋值或销毁操作。
• 如果在基类中有一个不可访问或删除掉的析构函数，则派生类中合成的拷贝构造函数将是被删除的，因为编译器无法销毁派生类对象的基类部分。
• 和过去一样，编译器将不会合成一个删除掉的移动操作。当我们使用 =default 请求一个移动操作时，如果基类中的对应操作是删除的或不可访问的，那么派生类中该函数是被删除的，原因是派生类对象的基类部分不可移动。同样，如果基类的析构函数是删除的或不可访问的，则派生类的移动构造函数也将是被删除的。

派生类的拷贝控制成员

定义派生类的拷贝或移动构造函数

当为派生类定义拷贝或移动构造函数时，通常使用对应的基类构造函数初始化对象的基类部分。
在默认情况下，基类默认构造函数初始化派生类对象的基类部分。
如果想拷贝（或移动）基类部分，则必须在派生类的构造函数初始值列表中显式地使用基类地拷贝（或移动）构造函数。

派生类赋值运算符

与拷贝和移动构造函数一样，派生类的赋值运算符也必须显式地为其基类部分赋值

派生类析构函数

自动调用基类的析构函数
对象销毁的顺序正好与其创建的顺序相反：
派生类析构函数首先执行，然后是基类的析构函数，以此类推，沿着继承体系的反方向直至最后

在构造函数和析构函数中调用虚函数

当构建一个对象时，需要把对象的类和构造函数的类看作是同一个。对虚函数的调用绑定正好符合这种把对象的类和构造函数的类看成同一个的要求，对析构函数也是同样的道理。上述的绑定不但对直接调用虚函数有效，对间接调用也是有效的，这里的间接调用时指通过构造函数（或析构函数）调用另一个函数。

当基类构造函数调用虚函数的派生类版本时会发生什么情况：
这个虚函数可能会访问派生类的成员，如果它不需要访问派生类成员的话，则派生类直接使用基类的虚函数版本就可以了。当执行基类构造函数时，它要用到的派生类成员尚未初始化，如果允许这样的访问，程序可能崩溃。

---

如果构造哈数或则析构函数调用了某个虚函数，则我们应该执行与构造函数或析构函数所属类型相对应的虚函数版本。

继承的构造函数

一个类只初始化它的直接基类，出于同样的原因，一个类也只继承其直接基类的构造函数。
类不能继承默认、拷贝和移动构造。如果派生类没有直接定义这些构造函数，则编译器将为派生类合成它们。
派生类继承基类构造函数的方式是提供了一条注明了（直接）基类名的 using 声明语句。
using 声明语句作用于构造函数时，对于基类的每个构造函数，编译器都在派生类中生成一个形参列表完全相同的构造函数。

---

编译器生成的构造函数形如：

derived(parms) : base(args) { }

derived 是派生类的名字，base 是基类的名字，parms 是构造函数的形参列表，args 将派生类构造函数的形参传递给基类的构造函数。
如果派生类含有自己的数据成员，则这些成员将被默认初始化。

struct Base {
	Base():mem("Base") {}
	Base(std::string s) :mem(s) {}
	std::string mem;
};

struct Derived :Base {

public:
	using Base::Base;
	std::string mem_p = "Derived";
};
int main()
{
	std::string s1("1");
	std::string s2("2");

	Derived d;
	std::cout << d.mem <<" " << d.mem_p << std::endl;
	Derived d1(s1);
	std::cout << d1.mem << " " << d1.mem_p << std::endl;
	// Derived d2(s1,s2); //编译器没有与之匹配的构造函数
}

需要添加派生类对应自己成员的构造函数.