本文为《C++ Primer》的读书笔记

OOP: 概述

继承

通过继承(inheritance) 联系在一起的类构成一种层次关系。通常在层次关系的根部有一个基类(base class), 其他类则直接或间接地从基类继承而来，这些继承得到的类称为派生类(derived class)。基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员

例如，对书店中图书的不同定价策略建模。我们首先定义一个名为Quote的基类。Quote的对象表示按原价销售的书籍。Quote 派生出另一个名为Bulk_quote的类，它表示可以打折销售的书籍

这些类将包含下面的两个成员函数：

isbn() , 返回书籍的ISBN编号。该操作不涉及派生类的特殊性，因此只定义在Quote类中
net_price(size_t), 返回书籍的实际销售价格，前提是用户购买该书的数量达到一定标准。这个操作显然是类型相关的， Quote和Bulk_quote都应该包含该函数

在C++中，基类将类型相关的函数与派生类不做改变直接继承的函数区分对待。对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数(virtual function)

class Quote {
    
    
public:
	std::string isbn() const;
	virtual double net_price(std::size_t n) const;
};

派生类必须通过使用类派生列表(class derivation list)明确指出它是从哪个（哪些）基类继承而来的。类派生列表的形式是： 首先是一个冒号，后面紧跟以逗号分隔的基类列表，其中每个基类前面可以有访问说明符：

class Bulk_quote : public Quote {
    
    
public:
	// Bulk_quote继承了Quote
	double net_price(std::size_t) const override;
};

派生类必须在其内部对所有重新定义的虚函数进行声明。派生类可以在这样的函数之前加上virtual关键字，但是并不是非得这么做。C++11新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，具体措施是在该函数的形参列表之后增加一个override关键字

动态绑定

通过使用动态绑定(dynamic binding), 我们能用同一段代码分别处理Quote 和Bulk_quote的对象。例如：

// 计算并打印销售给定数量的某种书所得的费用
double print_total(ostream &os, const Quote &item, size_t n)
{
    
    
	// 根据传入item形参的对象类型调用Quote::net _price或者Bulk_quote::net_price
	double ret = item.net_price(n);
	os << "ISBN: "<< item.isbn() // 调用Quote::isbn
		<< " # sold: " << n << " total due: " << ret << endl;
	return ret;
}

因为函数print_total的item形参是基类Quote的一个引用，所以我们既能使用基类Quote的对象调用该函数，也能使用派生类Bulk_quote的对象调用它。因为在上述过程中函数的运行版本由实参决定，即在运行时选择函数的版本，所以动态绑定有时又被称为运行时绑定(run-time binding)

C++中， 当我们使用基类的引用（或指针）调用一个虚函数时将发生动态绑定

定义基类和派生类

定义基类

我们首先完成Quote类的定义：

class Quote {
    
    
public:
	Quote() = default;
	Quote(const std::string &book, double sales_price):
				bookNo(book), price(sales_price) {
    
     }
	std::string isbn() const {
    
     return bookNo; }
	// 返回给定数量的书籍的销售总额
	// 派生类负责改写并使用不同的折扣计算算法
	virtual double net_price(std::size_t n) const
			{
    
     return n * price; }
	virtual ~Quote() = default; // 对析构函数进行动态绑定
private:
	std::string bookNo;
protected:
	double price = 0.0;		// 代表普通状态下不打折的价格
};

基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此

成员函数与继承

在C++语言中，基类必须将它的两种成员函数区分开来：

一种是基类希望其派生类进行覆盖的函数，基类通常将其定义为虚函数(virtual function)
另一种是基类希望派生类直接继承而不要改变的函数

当我们使用指针或引用调用虚函数时，该调用将被动态绑定。根据引用或指针所绑定的对象类型不同，该调用可能执行基类的版本，也可能执行某个派生类的版本。成员函数如果没被声明为虚函数，则其解析过程发生在编译时而非运行时

任何构造函数之外的非静态函数都可以是虚函数
关键字virtual只能出现在类内部的声明语句之前而不能用于类外部的函数定义
如果基类把一个函数声明成虚函数，则该函数在派生类中隐式地也是虚函数

定义派生类

派生类必须通过使用类派生列表(class derivation list)明确指出它是从哪个（哪些）基类继承而来的。类派生列表的形式是：首先是一个冒号，后面紧跟以逗号分隔的基类列表，其中每个基类前面可以有以下三种访问说明符中的一个： public、protected或者private

访问说明符的作用是控制派生类从基类继承而来的成员是否对派生类的用户可见。如果一个派生是公有的，则基类的公有成员也是派生类接口的组成部分。此外，我们能将公有派生类型的对象绑定到基类的引用或指针上

派生类必须将其继承而来的成员函数中需要覆盖的那些重新声明：

class Bulk_quote : public Quote {
    
    
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string&, double, std::size_t, double);
	// 覆盖基类的函数版本以实现基于大量购买的折扣政策
	double net_price(std::size_t) const override;
private:
	std::size_t min_qty = 0; //适用折扣政策的最低购买量
	double discount = 0.0; // 以小数表示的折扣额
}

我们的Bulk_quote类从它的基类Quote那里继承了isbn函数和bookNo、price等数据成员。此外，它还定义了net_price 的新版本，同时拥有两个新增加的数据成员min_qty 和discount

大多数类都只继承自一个类，这种形式的继承被称作“ 单继承“

派生类中的虚函数

派生类经常（但不总是）覆盖它继承的虚函数。如果派生类没有覆盖其基类中的某个虚函数，则派生类会直接继承其在基类中的版本

派生类可以在它覆盖的函数前使用virtual 关键字，但不是非得这么做。C++11新标准允许派生类显式地注明它使用某个成员函数覆盖了它继承的虚函数。具体做法是在形参列表后面、或者在const成员函数的const关键字后面、或者在引用成员函数的引用限定符后面添加一个关键字override

派生类向基类的类型转换

在一个对象中，继承自基类的部分和派生类自定义的部分不一定是连续存储的

因为在派生类对象中含有与其基类对应的组成部分，所以我们能把派生类的对象当成基类对象来使用，而且我们也能将基类的指针或引用绑定到派生类对象中的基类部分上

Quote item;
Bulk_quote bulk;
Quote *p = &bulk;			// p指向bulk的Quote部分
Quote &r = bulk;			// r绑定到bulk的Quote部分

这种转换通常称为派生类到基类的(derived-to-base)类型转换。和其他类型转换一样，编译器会隐式地执行派生类到基类的转换。这种隐式特性意味着我们可以把派生类对象或者派生类对象的引用用在需要基类引用的地方：同样的，我们也可以把派生类对象的指针用在需要基类指针的地方

派生类构造函数

尽管在派生类对象中含有从基类继承而来的成员，但是派生类并不能直接初始化这些成员。和其他创建了基类对象的代码一样，派生类也必须使用基类的构造函数来初始化它的基类部分

Bulk_quote(const std::string& book, double p,
			std::size_t qty, double disc) :
			Quote(book, p), min_qty(qty), discount(disc) {
    
    }

除非我们特别指出，否则派生类对象的基类部分会像数据成员一样执行默认初始化

首先初始化基类的部分，然后按照声明的顺序依次初始化派生类的成员

派生类使用基类的成员

派生类可以访问基类的公有成员和受保护成员：

// 如果达到了购买书籍的某个最低限世值， 就可以享受折扣价格了
double Bulk_quote::net_price(size_t cnt) const
{
    
    
	if (cnt >= min_qty)
		return cnt * (1 - discount) * price;
	else
		return cnt * price;
}

派生类的作用域嵌套在基类的作用域之内。因此，对于派生类的一个成员来说，它使用派生类成员的方式与使用基类成员的方式没什么不同

关键概念：遵循基类的接口
必须明确一点：每个类负责定义各自的接口。要想与类的对象交互必须使用该类的接口，即使这个对象是派生类的基类部分也是如此。
因此，派生类对象不能直接初始化基类的成员。尽管从语法上来说我们可以在派生类构造函数体内给它的公有或受保护的基类成员赋值，但是最好不要这么做。和使用基类的其他场合一样，派生类应该遵循基类的接口，并且通过调用基类的构造函数来初始化那些从基类中继承而来的成员

继承与静态成员

如果基类定义了一个静态成员，则在整个继承体系中只存在该成员的唯一定义。不论从基类中派生出来多少个派生类，对于每个静态成员来说都只存在唯一的实例

class Base {
    
    
public :
	static void statmem();
]
class Derived : public Base {
    
    
	void f(const Derived&};
};

静态成员遵循通用的访问控制规则，如果基类中的成员是private的，则派生类无权访问它。假设某静态成员是可访问的，则我们既能通过基类使用它也能通过派生类使用它：

void Derived::f(const Derived &derived_obj)
{
    
    
	Base::statmem(); 		// 正确： Base定义了statmem
	Derived::statmem(); 	// 正确： Derived继承了statmem
	// 正确： 派生类的对象能访问基类的静态成员
	derived_obj.statmem();	// 通过Derived对象访问
	statmem();				// 通过this对象访问
}

派生类的声明

派生类的声明中包含类名但是不包含它的派生列表：

class Bulk_quote : public Quote; //错误： 派生列表不能出现在这里
class Bulk_quote; //正确： 声明派生类的正确方式

一条声明语句的目的是令程序知晓某个名字的存在以及该名字表示一个什么样的实体，如一个类、一个函数或一个变量等。派生列表以及与定义有关的其他细节必须与类的主体一起出现

被用作基类的类

如果我们想将某个类用作基类，则该类必须已经定义而非仅仅声明：

class Quote; // 声明但未定义
// 错误： Quote必须被定义
class Bulk_quote : public Quote {
    
     ... };

这一规定的原因显而易见：派生类中包含并且可以使用它从基类继承而来的成员，为了使用这些成员，派生类当然要知道它们是什么。因此该规定还有一层隐含的意思，即一个类不能派生它本身

一个类是基类，同时它也可以是一个派生类：

class Base {
    
     /* ... */ };
class D1: public Base {
    
     /* ... */ } ;
class D2: public D1 {
    
     /* ... */ };

在这个继承关系中，Base是D1的直接基类(direct base), 同时是D2的间接基类(indirect base)。最终的派生类将包含它的直接基类的子对象以及每个间接基类的子对象

类型转换与继承

通常情况下，如果我们想把引用或指针绑定到一个对象上，则引用或指针的类型应与对象的类型一致，或者对象的类型含有一个可接受的const类型转换规则。存在继承关系的类是一个重要的例外：我们可以将基类的指针或引用绑定到派生类对象上

可以将基类的指针或引用绑定到派生类对象上有一层极为重要的含义：当使用基类的引用（或指针）时，实际上我们并不清楚该引用（或指针）所绑定对象的真实类型。该对象可能是基类的对象，也可能是派生类的对象

和任何其他成员一样，派生类向基类的类型转换也可能会由于访问受限而变得不可行

静态类型与动态类型

当我们使用存在继承关系的类型时，必须将一个变量或其他表达式的静态类型(static type)与该表达式表示对象的动态类型(dynamic type)区分开来

表达式的静态类型在编译时总是已知的，它是变量声明时的类型或表达式生成的类型
动态类型则是变量或表达式表示的内存中的对象的类型。动态类型直到运行时才可知

例如：

// item的静态类型是Quote&, 它的动态类型则依赖于item绑定的实参
double ret = item.net_price(n);

如果表达式既不是引用也不是指针，则它的动态类型永远与静态类型一致

基类的指针或引用的静态类型可能与其动态类型不一致

不存在从基类向派生类的隐式类型转换……

之所以存在派生类向基类的类型转换是因为每个派生类对象都包含一个基类部分，而基类的引用或指针可以绑定到该基类部分上。一个基类的对象既可以以独立的形式存在，也可以作为派生类对象的一部分存在

因为一个基类的对象可能是派生类对象的一部分，也可能不是，所以不存在从基类向派生类的自动类型转换：

Quote base;
Bulk_quote* bulkP = &base;		// 错误： 不能将基类转换成派生类
Bulk_quote& bulkRef = base;		// 错误： 不能将基类转换成派生类

除此之外还有一种情况显得有点特别，即使一个基类指针或引用绑定在一个派生类对象上，我们也不能执行从基类向派生类的转换：

Bulk_quote bulk;
Quote *itemP = &bulk;
Bulk_quote *bulkP = itemP;		// 错误： 不能将基类转换成派生类

编译器在编译时无法确定某个特定的转换在运行时是否安全，这是因为编译器只能通过检查指针或引用的静态类型来推断该转换是否合法。如果在基类中含有一个或多个虚函数，我们可以使用dynamic_cast请求一个类型转换，该转换的安全检查将在运行时执行。同样，如果我们已知某个基类向派生类的转换是安全的，则我们可以使用static_cast来强制覆盖掉编译器的检查工作

……在对象之间不存在类型转换

派生类向基类的自动类型转换只对指针或引用类型有效，在派生类类型和基类类型之间不存在这样的转换。很多时候，我们确实希望将派生类对象转换成它的基类类型，但是这种转换的实际发生过程往往与我们期望的有所差别

请注意，当我们初始化或赋值一个类类型的对象时，实际上是在调用某个函数。当执行初始化时，我们调用构造函数；而当执行赋值操作时，我们调用赋值运算符。这些成员通常都包含一个参数，该参数的类型是类类型的const版本的引用。因为这些成员接受引用作为参数，所以派生类向基类的转换允许我们给基类的拷贝移动操作传递一个派生类的对象

例如，我们的书店类使用了合成版本的拷贝和赋值操作：

Bulk_quote bulk;		// 派生类对象
Quote item(bulk);		// 使用Quote::Quote(const Quote&)构造函数
item = bulk;			// 调用Quote::operator= (const Quote&)

当构造item时，运行Quote的拷贝构造函数。该函数负责拷贝bulk中Quote部分的成员，同时忽略掉bulk中Bulk_quote 部分的成员。类似的，对于将bulk赋值给item 的操作来说，只有bulk中Quote部分的成员被赋值给item

因为在上述过程中会忽略Bulk_quote部分，所以我们可以说bulk的Bulk_quote部分被切掉 (sliced down)了

虚函数

C++中， 当我们使用基类的引用或指针调用一个虚成员函数时会执行动态绑定。因为我们直到运行时才能知道到底调用了哪个版本的虚函数，所以所有虚函数都必须有定义，而不管它是否被用到了

对虚函数的调用可能在运行时才被解析

当某个虚函数通过指针或引用调用时，编译器产生的代码直到运行时才能确定应该调用哪个版本的函数。被调用的函数是与绑定到指针或引用上的对象的动态类型相匹配的那一个

关键概念： C++的多态性
OOP 的核心思想是多态性(polymorphism)。我们把具有继承关系的多个类型称为多态类型，因为我们能使用这些类型的“ 多种形式” 而无须在意它们的差异。引用或指针的静态类型与动态类型不同是C++支持多态性的根本所在

派生类中的虚函数

当我们在派生类中覆盖了某个虚函数时，可以再一次使用virtual 关键字指出该函数的性质。然而这么做并非必须，因为一旦某个函数被声明成虚函数，则在所有派生类中它都是虚函数

一个派生类的函数如果覆盖了某个继承而来的虚函数，则它的形参类型必须与被它覆盖的基类函数完全一致。同样，派生类中虚函数的返回类型也必须与基类函数匹配。但该规则存在一个例外，当类的虚函数返回类型是类本身的指针或引用时，上述规则无效。也就是说，如果D由B派生得到则基类的虚函数可以返回B*而派生类的对应函数可以返回D*, 只不过这样的返回类型要求从D到B的类型转换是可访问的

`final` 说明符：防止继承的发生

C++11新标准提供了一种防止继承发生的方法，即在类名后跟一个关键字final:

class NoDerived final {
    
     /* */ };
class Base {
    
    /* */};

class Last final : Base {
    
     /* */ };		// Last是final的；我们不能继承Last
class Bad : NoDerived {
    
     /* */ };		// 错误： NoDerived是final的
class Bad2 : Last {
    
     /* */);				// 错误： Last是final的

我们还能把某个函数指定为final。之后任何尝试覆盖该函数的操作都将引发错误：

struct D2 : B {
    
    
	// 从B继承f2() 和f3() 覆盖f1(int)
	void f1(int) const final; //不允许后续的其他类覆盖f1(int)
};

struct D3 : D2 {
    
    
	void f2();				// 正确： 覆盖从间接基类B继承而来的f2
	void fl(int) const;		// 错误： D2已经将f2声明成final
};

`override` 说明符

派生类如果定义了一个函数与基类中虚函数的名字相同但是形参列表不同，这仍然是合法的行为。编译器将认为新定义的这个函数与基类中原有的函数是相互独立的。这时，派生类的函数并没有覆盖掉基类中的版本。就实际的编程习惯而言，这种声明往往意味着发生了错误，因为我们可能原本希望派生类能覆盖掉基类中的虚函数，但是一不小心把形参列表弄错了

要想调试并发现这样的错误显然非常困难。在C++11新标准中我们可以使用override关键字来说明派生类中的虚函数。这么做的好处是在使得程序员的意图更加清晰的同时让编译器可以为我们发现一些错误，后者在编程实践中显得更加重要。 如果我们使用override标记了某个函数，但该函数并没有覆盖已存在的虚函数，此时编译器将报错：

struct B {
    
    
	virtual void f1(int) const;
	virtual void f2();
	void f3();
};

struct D1 : B {
    
    
	void fl(int) const override;	// 正确： fl与基类中的fl匹配
	void f2(int) override;			// 错误： B没有形如f2(int)的函数
	void f3() override;				// 错误： f3不是虚函数
	void f4() override;				// 错误： B没有名为f4的函数
};

final和override说明符出现在形参列表（包括const或引用修饰符）以及尾置返同类型之后

虚函数与默认实参

虚函数也可以拥有默认实参。如果某次函数调用使用了默认实参，则该实参由本次调用的静态类型决定。换句话说，如果我们通过基类的引用或指针调用函数，则使用基类中定义的默认实参，即使实际运行的是派生类中的函数版本也是如此

因此，如果虚函数使用默认实参，则基类和派生类中定义的默认实参最好一致

回避虚函数的机制

在某些情况下，我们希望对虚函数的调用不要进行动态绑定，而是强迫其执行虚函数的某个特定版本。仅用作用域运算符可以实现这一目的，例如下面的代码：

// 强行调用基类中定义的虚函数版本而不管baseP的动态类型到底是什么
// 该调用将在编译时完成解析
double undiscounted = baseP->Quote::net_price(42);

通常情况下，只有成员函数（或友元）中的代码才需要使用作用域运算符来回避虚函数的机制

什么时候我们需耍回避虚函数的默认机制呢？
通常是当一个派生类的虚函数调用它覆盖的基类的虚函数版本时。在此情况下，基类的版本通常完成继承层次中所有类型都要做的共同任务，而派生类中定义的版本要执行一些与派生类本身密切相关的操作。如果一个派生类虚函数需要调用它的基类版本，但是没有使用作用域运算符，则在运行时该调用将被解析为对派生类版本自身的调用，从而导致无限递归

抽象基类

假设我们希望扩展书店程序并令其支持几种不同的折扣策略。除了购买超过一定数量享受折扣外，我们也可能提供另外一种策略，即购买不超过某个限额时可以享受折扣，但是一旦超过限额就要按原价支付。或者折扣策略还可能是购买量超过一定数量后购买的全部书籍都享受折扣，否则全都不打折

上面的每个策略都要求一个购买量的值和一个折扣值。我们可以定义一个新的名为Disc_quote的类来支持不同的折扣策略，其中Disc_quote负责保存购买量的值和折扣值。其他的表示某种特定策略的类（如Bulk_quote)将分别继承自Disc_quote, 每个派生类通过定义自己的net_price函数来实现各自的折扣策略

在定义Disc_quote类之前，首先要确定它的net_price函数完成什么工作。显然我们的Disc_quote 类与任何特定的折扣策略都无关，因此Disc_quote 类中的net_price函数是没有实际含义的

我们可以在Disc_quote类中不定义新的net_price, 此时，Disc_quote将继承Quote中的net_price函数。然而，这样的设计可能导致用户编写出一些无意义的代码。用户可能会创建一个Disc_quote对象并为其提供购买量和折扣值，如果将该对象传给一个像print_total这样的函数，则程序将调用Quote版本的net_price。显然，最终计算出的销售价格并没有考虑我们在创建对象时提供的折扣值，因此上述操作毫无意义

纯虚函数

认真思考上面描述的情形我们可以发现，关键问题并不仅仅是不知道应该如何定义net_price, 而是我们根本就不希望用户创建一个Disc_quote 对象。Disc_quote类表示的是—本打折书籍的通用概念，而非某种具体的折扣策略

我们可以将net_price定义成纯虚(pure virtual)函数。这样做可以清晰明了地告诉用户当前这个net_price函数是没有实际意义的。和普通的虚函数不一样，一个纯虚函数无须定义。我们通过在函数体的位置（即在声明语句的分号之前）书写=0就可以将一个虚函数说明为纯虚函数。其中， =0只能出现在类内部的虚函数声明语句处：

// 用于保存折扣值和购买量的类，派生类使用这些数据可以实现不同的价格策略
class Disc_quote : public Quote {
    
    
public:
	Disc_quote() = default;
	Disc_quote(const std::string& book, double price,
			std::size_t qty, double disc):
			Quote(book, price), quantity(qty), discount(disc) {
    
     }
	double net_price(std::size_t) const = 0;
protected:
	std::size_t quantity= 0;
	double discount= 0.0;
};

尽管我们不能直接定义这个类的对象，但是Disc_quote的派生类构造函数将会使用Disc_quote的构造函数来构建各个派生类对象的Disc_quote部分

值得注意的是，我们也可以为纯虚函数提供定义，不过函数体必须定义在类的外部

含有纯虚函数的类是抽象基类

含有（或者未经覆盖直接继承）纯虚函数的类是抽象基类(abstract base class)。抽象基类负责定义接口，而后续的其他类可以覆盖该接口。我们不能（直接）创建一个抽象基类的对象：

// Disc_quote声明了纯虚函数，而Bulk_quote将覆盖该函数
Disc_quote discounted; //错误：不能定义Disc_quote的对象
Bulk_quote bulk; //正确： Bulk_quote中没有纯虚函牧

派生类构造函数只初始化它的直接基类

接下来可以重新实现Bulk_quote了，这一次我们让它继承Disc_quote而非直接继承Quote:

// 当同一书籍的销售量超过某个值时启用折扣
// 折扣的值是一个小于1的正的小数值，以此来降低正常销售价格
class Bulk_quote : public Disc_quote {
    
    
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string& book, double price, std::size_t qty, double disc):
			Disc_quote(book, price, qty, disc) {
    
    }
	// 覆盖基类中的函数版本以实现一种新的折扣策略
	double net_price(std::size_ t) const override;
} ;

这个版本的Bulk_quote 的直接基类是Disc_quote, 间接基类是Quote。每个Bulk_quote对象包含三个子对象一个（空的）Bulk_quote部分、一个Disc_quote子对象和一个Quote子对象

关键概念：重构
在Quote的继承体系中增加Disc_quote类是重构(refactoring) 的一个典型示例。重构负责重新设计类的体系以便将操作和／或数据从一个类移动到另一个类中。对于面向对象的应用程序来说，重构是一种很普遍的现象
值得注意的是，即使我们改变了整个继承体系，那些使用了Bulk_quote或Quote的代码也无须进行任何改动。不过一旦类被重构（或以其他方式被改变），就意味着我们必须重新编译含有这些类的代码了

访问控制与继承

受保护的成员

一个类使用protected关键字来声明那些它希望与派生类分享但是不想被其他公共访问使用的成员：

和私有成员类似，受保护的成员对类的用户来说是不可访问的
和公有成员类似，受保护的成员对派生类的成员和友元来说是可访问的
派生类的成员或友元只能通过派生类对象来访问基类的受保护成员。派生类对一个基类对象中的受保护成员没有任何访问特权

为了理解最后一条规则，请考虑如下的例子：

class Base (
protected:
	int prot_mem;
};
class Sneaky : public Base {
    
    
	friend void clobber(Sneaky&);	// 能访问Sneaky::prot_mem
	friend void clobber(Base&);		// 不能访问Base::prot_mem
	int j;							// j默认是private
};

// 正确： clobber 能访问Sneaky 对象的private 和protected 成员
void clobber(Sneaky &s) {
    
     s.j = s.prot_mem = 0; }
// 错误： clobber 不能访问Base 的protected 成员
void clobber(Base &b) {
    
     b.prot_mem = 0; }

如果派生类（及其友元）能访问基类对象的受保护成员，则上面的第二个clobber (接受一个Base&)将是合法的。该函数不是Base的友元，但是它仍然能够改变一个Base对象的内容。如果按照这样的思路，则我们只要定义一个形如Sneaky的新类就能非常简单地规避掉protected提供的访问保护了

要想阻止以上的用法，我们就要规定派生类的成员和友元只能访问派生类对象中的基类部分的受保护成员；对于普通的基类对象中的成员不具有特殊的访问权限

公有、私有和受保护继承

某个类对其继承而来的成员的访问权限受到两个因素影响：一是在基类中该成员的访问说明符，二是在派生类的派生列表中的访问说明符。举个例子，考虑如下的继承关系：

class Base {
    
    
public:
	void pub_mem();
protected:
	int prot_mem;
private:
	char priv_mem;
};

struct Pub_Derv : public Base {
    
    
	// 正确：派生类能访问protected 成员
	int f() {
    
     return prot_mem; }
	// 错误： private 成员对于派生类来说是不可访问的
	char g() {
    
     return priv_mem; }
};

struct Priv_Derv : private Base {
    
    
	// private不影响派生类的访问权限
	int f1() const {
    
     return prot_mem; } 
};

派生访问说明符对派生类的成员（及友元）能否访问其直接基类的成员没什么影响。对基类成员的访问权限只与基类中的访问说明符有关。Pub_Derv 和Priv_Derv都能访问受保护的成员prot_mem, 同时它们都不能访问私有成员priv_mem

派生访问说明符的目的是控制派生类用户（包括派生类的派生类在内）对基类成员的访问权限：

Pub_Derv d1;
Priv_Derv d2;
d1.pub_mem();	// 正确: pub_mem在派生类中是public的
d2.pub_mem();	// 错误: pub_mem在派生类中是private的

Pub_Derv和Priv_Derv都继承了pub_mem函数。如果继承是公有的，则成员将遵循其原有的访问说明符，此时d1可以调用pub_mem。在Priv_Derv中，Base的成员是私有的，因此类的用户不能调用pub_mem

派生访问说明符还可以控制继承自派生类的新类的访问权限：

struct Derived_from_Public : public Pub_Derv {
    
    
	// 正确： Base::prot_mem在Pub_Derv中仍然是protected的
	int use_base() {
    
     return prot_mem; }
}

struct Derived_from_Private : public Priv_Derv {
    
    
	// 错误： Base::prot_mem在Priv_Derv中是private的
	int use_base() {
    
     return prot_mem; }
};

Priv_Derv 的派生类无法执行类的访问，对它们来说，Priv_Derv继承自Base的所有成员都是私有的

假设我们之前还定义了一个名为Prot_Derv的类，它采用受保护继承，则Base的所有公有成员在新定义的类中都是受保护的。Prot_Derv的用户不能访问pub_mem, 但是Prot_Derv的成员和友元可以访问那些继承而来的成员

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

派生类向基类的转换是否可访问由使用该转换的代码决定，同时派生类的派生访问说明符也会有影响。假定D继承自B:

只有当D公有地继承B时，用户代码才能使用派生类向基类的转换。如果D继承B的方式是受保护的或者私有的，则用户代码不能使用该转换
不论D以什么方式继承B, D的成员函数和友元都能使用派生类向基类的转换：派生类向其直接基类的类型转换对派生类的成员和友元来说永远是可访问的
如果D继承B的方式是公有的或者受保护的，则D的派生类的成员和友元可以使用D向B的类型转换；反之，如果D继承B的方式是私有的，则不能使用

对于代码中的某个给定节点来说，如果基类的公有成员是可访问的，则派生类中向基类的类型转换也是可访问的；反之则不行

关键概念：类的设计与受保护的成员
不考虑继承的话，我们可以认为一个类有两种不同的用户：普通用户和类的实现者。其中，普通用户编写的代码使用类的对象，这部分代码只能访问类的公有（接口）成员；实现者则负责编写类的成员和友元的代码。
如果进一步考虑继承的话就会出现第三种用户，即派生类。基类把它希望派生类能够使用的部分声明成受保护的。普通用户不能访问受保护的成员，而派生类及其友元仍旧不能访问私有成员。
和其他类一样．基类应该将其接口成员声明为公有的；同时将其实现的部分分成两组：一组可供派生类访问protected，另一组只能由基类及基类的友元访问private。

友元与继承

就像友元关系不能传递一样，友元关系同样也不能继承。基类的友元在访问派生类成员时不具有特殊性，类似的，派生类的友元也不能随意访问基类的成员：

class Base {
    
    
	// 添加friend声明，其他成员与之前的版本一致
	friend class Pal;	// Pal在访问Base的派生类时不具有特殊性
}
class Pal {
    
    
public:
	int f(Base b) {
    
     return b.prot_mem; } //正确： Pal是Base的友元
	int f2(Sneaky s) {
    
     return s.j; } //错误： Pal不是Sneaky的友元
	// 对基类的访问权限由基类本身控制，即使对于派生类的基类部分也是如此
	int f3(Sneaky s) {
    
     return s.prot_mem; } //正确： Pal是Base的友元
};

如前所述，每个类负责控制自己的成员的访问权限，因此尽管看起来有点儿奇怪，但f3确实是正确的。Pal是Base的友元，所以Pal能够访问Base对象的成员，这种可访问性包括了Base对象内嵌在其派生类对象中的情况

class D2 : public Pal {
    
    
public:
	int mem(Base b)
		{
    
     return b.prot_mem; } // 错误：友元关系不能继承
}

改变个别成员的可访问性

有时我们需要改变派生类继承的某个名字的访问级别，通过使用using声明可以达到这一目的：

class Base {
    
    
public:
	std::size_t size() const {
    
     return n; }
protected:
	std::size_t n;
};

class Derived : private Base {
    
    	// 注意： private 继承
public:
	// 保持对象尺寸相关的成员的访问级别
	using Base::size;
protected:
	using Base::n;
};

我们使用using声明语句改变了成员的可访问性。改变之后，Derived的用户将可以使用size成员，而Derived的派生类将能使用n

通过在类的内部使用using声明语句，我们可以将该类的直接或间接基类中的任何可访问成员标记出来。using声明语句中名字的访问权限由该using声明语句之前的访问说明符来决定

默认的继承保护级别

使用struct和class关键字定义的类具有不同的默认访问说明符。类似的，默认派生运算符也由定义派生类所用的关键字来决定。默认情况下，使用class关键字定义的派生类是私有继承的；而使用struct关键字定义的派生类是公有继承的：

class Base {
    
     / * ... * / } ;
struct Dl : Base {
    
     / * ... * / } ; // 默认public 继承
class D2 : Base (/ * ... * / } ; // 默认private 继承

人们常常有一种错觉，认为在使用struct和class定义的类之间还有更深层次的差别。事实上，唯一的差别就是默认成员访问说明符及默认派生访问说明符：除此之外，再无其他不同之处

一个私有派生的类最好显式地将private声明出来，而不要仅仅依赖于默认的设置。显式声明的好处是可以令私有继承关系清晰明了，不至于产生误会

继承中的类作用域

每个类定义自己的作用域，在这个作用域内我们定义类的成员。当存在继承关系时，派生类的作用域嵌套在其基类的作用域之内。如果一个名字在派生类的作用域内无法正确解析，则编译器将继续在外层的基类作用域中寻找该名字的定义

在编译时进行名字查找

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

例如：

class Disc_quote : public Quote {
    
    
public:
	std::pair<size_t, double> discount_policy() const
		{
    
     return {
    
    quantity, discount}; }
	// 其他成员与之前的版本一致
};

Bulk_quote bulk;			
Bulk_quote *bulkP = &bulk;	// 静态类型与动态类型一致
Quote *itemP = &bulk;		// 静态类型与动态类型不一致
bulkP->discount_policy();	// 正确： bulkP的类型是Bulk_quote*
itemP->discount_policy();	// 错误： itemP的类型是Quote*

尽管bulk中确实含有一个名为discount_policy的成员，但是该成员对itemP却是不可见的。itemP的类型是Quote的指针，意味着对discount_policy的搜索将从Quote开始

名字冲突与继承

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

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

struct Derived : Base {
    
    
	Derived(int i): mem(i) {
    
    }
	int get_mem() {
    
     return mem; }		
protected:
	int mem;	// 隐藏基类中的mem
};


// get_mem中mem引用的解析结果是定义在Derived中的名字
Derived d(42);
cout << d.get_mem() << endl; // 打印42

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

可以通过作用域运算符来使用一个被隐藏的基类成员：

struct Derived : Base {
    
    
	int get_base_mem () {
    
     return Base::mem; }
	// ...
}

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

关键概念：名字查找与继承

假定我们调用p->mem()（或者obj.mem()), 则依次执行以下4个步骤：

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

名字查找先于类型检查

声明在内层作用域的函数并不会重载声明在外层作用域的函数。因此，定义派生类中的函数也不会重载其基类中的成员，派生类将在其作用域内隐藏该基类成员

也可以通过作用域运算符调用基类被隐藏的函数

struct Base {
    
    
	int memfcn();
};
struct Derived : Base (
	int memfcn(int);
};
Derived d; 
d.memfcn(10);	// 调用Derived::memfcn
d.memfcn();		// 错误：参数列表为空的memfcn被隐藏了
d.Base::memfcn();	// 正确：调用Base:: memfcn

要注意的是， d.memfcn()是非法的。为了解析这条调用语句，编译器首先在Derived 中查找名字memfcn，所以查找过程终止。Derived 中的memfcn 版本需要一个int 实参，所以该调用语句是错误的

虚函数与作用域

我们现在可以理解为什么基类与派生类中的虚函数必须有相同的形参列表了。假如基类与派生类的虚函数接受的实参不同，则我们就无法通过基类的引用或指针调用派生类的虚函数了。例如：

class Base {
    
    
public:
	virtual int fcn();
};
class D1 : public Base {
    
    
public:
	int fcn(int);	// 隐藏基类的fcn, 这个fcn不是虚函数
	// D1 继承了Base::fcn()的定义,此时D1 拥有了两个名为`fcn` 的函数
	virtual void f2();
};
class D2 : public D1 (
public:
	int fcn(int);		// 是一个非虚函数， 隐藏了D1::fcn(int)
	int fcn();			// 覆盖了Base的虚函数fcn
	void f2();			// 覆盖了D1的虚函数f2
};

给定上面定义的这些类后，我们来看几种使用其函数的方法：

Base bobj; D1 d1obj; D2 d2obj;
Base *bpl = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;
bpl->fcn(); 		//虚调用， 将在运行时调用Base::fcn
bp2->fcn(); 		//虚调用， 将在运行时调用Base::fcn
bp3->fcn(); 		//虚调用， 将在运行时调用D2::fcn

D1 *d1p = &d1obj; D2 *d2p = &d2obj;
bp2->f2(); 			//错误： Base没有名为f2的成员
d1p->f2(); 			//虚调用， 将在运行时调用D1::f2()
d2p->f2(); 			//虚调用， 将在运行时调用D2::f2()

Base *p1 = &d2obj; D1 *p2 = &d2obj; D2 *p3 = &d2obj;
p1->fcn(42); 	//错误： Base中没有接受一个int的fcn
p2->fcn(42);	//静态绑定， 调用D1::fcn(int)
p3->fcn(42);	//静态绑定， 调用D2::fcn(int)

覆盖重载的函数

如果派生类希望基类某个成员函数的所有重载版本对它来说都是可见的，那么它就需要覆盖所有的版本，或者一个也不覆盖

但有时一个类仅需覆盖重载集合中的一些而非全部函数，此时，如果我们不得不覆盖基类中的每一个版本的话，显然操作将极其烦琐

一种好的解决方案是为重载的成员提供一条using声明语句，这样我们就无须覆盖基类中的每一个重载版本了。using声明语句指定一个名字而不指定形参列表，所以一条基类成员函数的using声明语句就可以把该函数的所有重载实例添加到派生类作用域中。此时，派生类只需要定义其特有的函数就可以了，而无须为继承而来的其他函数重新定义

类内using声明的一般规则同样适用于重载函数的名字：基类函数的每个实例在派生类中都必须是可访问的。对派生类没有重新定义的重载版本的访问实际上是对using声明点的访问

构造函数与拷贝控制

和其他类一样，位于继承体系中的类也需要控制当其对象执行一系列操作时发生什么样的行为，这些操作包括创建、拷贝、移动、赋值和销毁。如果一个类（基类或派生类）没有定义拷贝控制操作，则编译器将为它合成一个版本

虚析构函数

继承关系对基类拷贝控制最直接的影响是基类通常应该定义一个虚析构函数，这样我们就能动态分配继承体系中的对象了。如前所述，当我们delete一个动态分配的对象的指针时将执行析构函数。如果该指针指向继承体系中的某个类型，则有可能出现指针的静态类型与被删除对象的动态类型不符的情况。如果这样的话，编译器就必须清楚它应该执行的是基类还是派生类的析构函数。和其他函数一样， 我们通过在基类中将析构函数定义成虚函数以确保执行正确的析构函数版本：

class Quote {
    
    
public:
	// 如果我们删除的是一个指向派生类对象的基类指针， 则需要虚析构函数
	virtual ~Quote() = default; //动态绑定析构函数
};

和其他虚函数一样， 析构函数的虚属性也会被继承。因此，无论Quote的派生类使用合成的析构函数还是定义自己的析构函数，都将是虚析构函数。只要基类的析构函数是虚函数，就能确保当我们delete基类指针时将运行正确的析构函数版本：

Quote *itemP = new Quote;
delete itemP;				// 调用Quote的析构函数
itemP = new Bulk_quote;
delete itemP;				// 调用Bulk_quote的析构函数

如果基类的析构函数不是虚函数，则delete一个指向派生类对象的基类指针将产生未定义的行为

之前我们曾介绍过一条经验准则，即如果一个类需要析构函数，那么它也同样需要拷贝和赋值操作。基类的析构函数并不遵循上述准则，它是一个重要的例外。一个基类总是需要析构函数，而且它能将析构函数设定为虚函数。此时，该析构函数为了成为虚函数而令内容为空，我们显然无法由此推断该基类还需要赋值运算符或拷贝构造函数

虚析构函数将阻止合成移动操作

基类需要一个虚析构函数这一事实还会对基类和派生类的定义产生另外一个间接的影响： 如果一个类定义了析构函数，即使它通过=default的形式使用了合成的版本，编译器也不会为这个类合成移动操作

合成拷贝控制与继承

基类或派生类的合成拷贝控制成员不仅对类本身的成员依次进行初始化、赋值或销毁的操作，还负责使用直接基类中对应的操作对一个对象的直接基类部分进行初始化、赋值或销毁

值得注意的是，唯一的要求是相应的成员应该可访问并且不是一个被删除的函数

例如：
在我们的Quote继承体系中，所有类都使用合成的析构函数。其中，派生类隐式地使用而基类通过将其虚析构函数定义成=default 而显式地使用。一如既往，合成的析构函数体是空的，其隐式的析构部分负责销毁类的成员。派生类的析构函数除了销毁派生类自己的成员外，还负责销毁派生类的直接基类，该直接基类又销毁它自己的直接基类，以此类推直至继承链的顶端

如前所述，Quote因为定义了析构函数而不能拥有合成的移动操作，因此当我们移动Quote对象时实际使用的是合成的拷贝操作。如我们即将看到的那样， Quote没有移动操作意味着它的派生类也没有

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

基类或派生类也能将其合成的默认构造函数或者任何一个拷贝控制成员定义成被删除的函数。此外，某些定义基类的方式也可能导致有的派生类成员成为被删除的函数：

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

例如：

class B {
    
    
public:
	B();
	B(const B&) = delete;
	// 其他成员， 不含有移动构造函数
};
class D : public B (
	// 没有声明任何构造函数
};
D d; //正确： D的合成默认构造函数使用B的默认构造函数
D d2(d); //错误： D的合成拷贝构造函数是被删除的
D d3(std::move(d)); // 错误： 隐式地使用D的被删除的拷贝构造函数

基类B含有一个可访问的默认构造函数和一个显式删除的拷贝构造函数。因为我们定义了拷贝构造函数，所以编译器将不会为B合成一个移动构造函数。因此，我们既不能移动也不能拷贝B的对象。如果B 的派生类希望它自己的对象能被移动和拷贝，则派生类需要自定义相应版本的构造函数。当然，在这一过程中派生类还必须考虑如何移动或拷贝其基类部分的成员。在实际编程过程中，如果在基类中没有默认、拷贝或移动构造函数，则一般情况下派生类也不会定义相应的操作

移动操作与继承

如前所述， 大多数基类都会定义一个虚析构函数。因此在默认情况下， 基类通常不含有合成的移动操作，而且在它的派生类中也没有合成的移动操作。

当我们确实需要执行移动操作时应该首先在基类中进行定义。一旦Quote定义了自己的移动操作，那么它必须同时显式地定义拷贝操作（否则编译器不会合成拷贝操作）：

class Quote {
    
    
public:
	Quote() = default;
	Quote(const Quote&) = default;
	Quote(Quote&&) = default;

	Quote& operator=(const Quote&) = default;//拷贝赋值
	Quote& operator=(Quote&&) = default; //移动赋值
	virtual ~Quote() = default;
	// 其他成员与之前的版本一致
};

通过上面的足义，我们就能对Quote的对象逐成员地分别进行拷贝、移动、赋值和销毁操作了。而且除非Quote的派生类中含有排斥移动的成员，否则它将自动获得合成的移动操作

派生类的拷贝控制成员

派生类的构造函数、拷贝函数、移动构造函数、移动拷贝函数、赋值运算符不仅要管理派生类成员，还要管理派生类的基类部分。而析构函数只负责销毁派生类自己分配的资源（对象的成员是被隐式销毁的：类似的，派生类对象的基类部分也是自动销毁的）

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

当为派生类定义拷贝或移动构造函数时，我们通常使用对应的基类构造函数初始化对象的基类部分：

class Base {
    
     /* ... */) ;
class D: public Base {
    
    
public:
	D(const D& d) : Base(d)   // 拷贝基类成员
		/* D的成员的初始值 */ {
    
    /* ．．． */}
	D(D&& d): Base(std::move(d)) //移动基类成员
		/* D的成员的初始值 */ {
    
    /* ．．． */}
};

初始值Base(d)将一个D对象传递给基类构造函数。尽管Base可以包含一个参数类型为D的构造函数，但是在实际编程过程中，Base(d)一般会匹配Base的拷贝构造函数。D类型的对象d将被绑定到该构造函数的Base&形参上。Base的拷贝构造函数负责将d的基类部分拷贝给要创建的对象。假如我们没有提供基类的初始值的话，基类部分被默认初始化，而非拷贝

派生类赋值运算符

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

// Base::operator=(const Base&) 不会被自动调用
D &D::operator=(const D &rhs)
{
    
    
	Base::operator=(rhs); //为基类部分赋值
	// ...
	return *this;
}

派生类析构函数

在析构函数体执行完成后，对象的成员会被隐式销毁。类似的，对象的基类部分也是隐式销毁的。因此，派生类析构函数只负责销毁由派生类自己分配的资源：

class D: public Base {
    
    
public:
	// Base: : ~Base袚自动调用执行
	~D() {
    
     /* 该处由用户定义清除派生类成员的操作*/ }
};

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

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

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

因为在构造函数中，派生类对象的基类部分将首先被构建。当执行基类的构造函数时，该对象的派生类部分是未被初始化的状态。类似的，销毁派生类对象的次序正好相反，因此当执行基类的析构函数时，派生类部分已经被销毁掉了。由此可知，当我们执行上述基类成员的时候，该对象处于未完成的状态。

为了能够正确地处理这种未完成状态，编译器认为对象的类型在构造或析构的过程中仿佛发生了改变一样。也就是说，当我们构建一个对象时，需要把对象的类和构造函数的类看作是同一个：对虚函数的调用绑定正好符合这种把对象的类和构造函数的类看成同一个的要求；对于析构函数也是同样的道理。上述的绑定不但对直接调用虚函数有效，对间接调用也是有效的，这里的间接调用是指通过构造函数（或析构函数）调用另一个函数。

为了理解上述行为，不妨考虑当基类构造函数调用虚函数的派生类版本时会发生什么情况。这个虚函数可能会访问派生类的成员，毕竟，如果它不需要访问派生类成员的话，则派生类直接使用基类的虚函数版本就可以了。然而，当执行基类构造函数时，它要用到的派生类成员尚未初始化，如果我们允许这样的访问，则程序很可能会崩溃

继承的构造函数

在C++11新标准中， 派生类能够重用其直接基类定义的构造函数。这些构造函数并非以常规的方式继承而来，但是为了方便，我们不妨姑且称其为“ 继承“的。一个类只初始化它的直接基类，因此， 一个类也只继承其直接基类的构造函数。类不能继承默认、拷贝和移动构造函数。如果派生类没有直接定义这些构造函数，则编译器将为派生类合成它们

派生类继承基类构造函数的方式是提供一条注明了（直接）基类名的using声明语句。例如：

class Bulk_quote : public Disc_quote {
    
    
public:
	using Disc_quote::Disc_quote; //继承Disc_quote的构造函数
	double net_price(std::size_t) const;
};

通常情况下，using声明语句只是令某个名字在当前作用域内可见。而当作用于构造函数时，using声明语句将令编译器产生代码。对基类的每个构造函数，编译器都生成一个与之对应的派生类构造函数。这些编译器生成的构造函数形如：

derived(parms) : base (args) {
    
     }

其中， derived是派生类的名字， base是基类的名字，parms是构造函数的形参列表，args将派生类构造函数的形参传递给基类的构造函数。在我们的Bulk_quote类中，继承的构造函数等价于：

Bulk_quote(const std::string& book, double price, std::size_t qty, double disc):
	Disc_quote(book, price, qty, disc) {
    
    }

如果派生类含有自己的数据成员，则这些成员将被默认初始化

继承的构造函数的特点

和普通成员的using声明不一样，一个构造函数的using声明不会改变该构造函数的访问级别。而且，一个using声明语句不能指定explicit 或constexpr。如果基类的构造函数是explicit 或者constexpr，则继承的构造函数也拥有相同的属性

当一个基类构造函数含有默认实参时，这些实参并不会被继承。相反， 派生类将获得多个继承的构造函数，其中每个构造函数分别省略掉一个含有默认实参的形参。例如，如果基类有一个接受两个形参的构造函数，其中第二个形参含有默认实参，则派生类将获得两个构造函数：一个构造函数接受两个形参（没有默认实参），另一个构造函数只接受一个形参，它对应于基类中最左侧的没有默认值的那个形参

如果基类含有几个构造函数，则除了两个例外情况，大多数时候派生类会继承所有这些构造函数

第一个例外是派生类可以继承一部分构造函数，而为其他构造函数定义自己的版本。如果派生类定义的构造函数与基类的构造函数具有相同的参数列表，则定义在派生类中的构造函数将替换继承而来的构造函数
第二个例外是默认、拷贝和移动构造函数不会被继承。这些构造函数按照正常规则被合成。继承的构造函数不会被作为用户定义的构造函数来使用，因此，如果一个类只含有继承的构造函数，则它也将拥有一个合成的默认构造函数

容器与继承

当我们使用容器存放继承体系中的对象时，通常必须采取间接存储的方式。因为不允许在容器中保存不同类型的元素，所以我们不能把具有继承关系的多种类型的对象直接存放在容器当中。

即使可以使用基类的容器存储派生类对象，但当派生类对象被赋值给基类对象时，其中的派生类部分将被“切掉＂，因此容器和存在继承关系的类型无法兼容

在容器中放置（智能）指针而非对象

当我们希望在容器中存放具有继承关系的对象时，我们实际上存放的通常是基类的指针（更好的选择是智能指针）。这些指针所指对象的动态类型可能是基类类型，也可能是派生类类型：

vector<shared_ptr<Quote>> basket;
basket.push_back(make_shared<Quote>("0-201-82470-1", 50));
basket.push_back(make_shared<Bulk_quote>("0-201-54848-8", 50, 10, .25));
// 调用Quote定义的版本；打印562.5, 即在15*&50中扣除掉折扣全额
couT << basket.back()->net_price(l5) << endl;

编写`Basket`类

对于C++面向对象的编程来说，一个悖论是我们无法直接使用对象进行面向对象编程。相反，我们必须使用指针和引用。因为指针会增加程序的复杂性，所以我们经常定义一些辅助的类来处理这种复杂情况。首先，我们定义一个表示购物篮的类：

class Basket {
    
    
public:
	// Basket使用合成的默认构造函数和拷贝控制成员
	void add_item(const std::shared_ptr<Quote> &sale)
		{
    
     items.insert(sale); }
	// 打印每本书的总价和购物篮中所有书的总价
	double total_receipt(std::ostream&) const;
private:
	// 该函数用于比较shared_ptr, multiset成员会用到它
	static bool compare(const std::shared_ptr<Quote> &lhs, const std::shared_ptr<Quote> &rhs)
		{
    
     return lhs->isbn () < rhs->isbn (); }
	// multiset保存多个报价， 按照compare成员排序
	// 因为shared_ptr 没有定义小于运算符， 所以为了对元素排序我们必须提供自己的比较运算符
	std::multiset<std::shared_ptr<Quote>, decltype(compare)*>  items {
    
     compare };

double Basket::total_receipt(ostream &os) const
{
    
    
	double sum = 0.0; //保存实时计算出的总价格
	// iter 指向ISBN 相同的一批元素中的第一个
	// upper_bound 返回一个迭代器， 该迭代器指向这批元素的尾后位置
	for (auto iter = items.cbegin(); iter != items.cend(); iter = items.upper_bound(*iter)) {
    
    
		//print_total调用了虚函数net_price, 因此最终的计算结果依赖于**iter 的动态类型
		sum += print_total(os, **iter, items.count(*iter));
	}
	os << "Total Sale: " << sum << endl; 		// 打印最终的总价格
	return sum;
}

我们的下一步是重新定义add_item, 使得它接受一个Quote对象而非shared_ptr。我们将定义两个版本，一个拷贝它给定的对象，另一个则采取移动操作：

void add_item(const Quote& sale);
void add_item(Quote&& sale);

唯一的问题是add_item不知道要分配的类型。为了解决上述问题，我们给Quote 类添加一个虚函数，该函数将申请—份当前对象的拷贝

class Quote {
    
    
public:
	// 该虚函数返回当前对象的一份动态分配的拷贝
	virtual Quote* clone() const & {
    
    return new Quote(*this);}
	virtual Quote* clone() && {
    
    return new Quote(std::move(*this));}
	// 其他成员与之前的版本一致
};

class Bulk_quote:public Quote {
    
    
	Bulk_quote* clone() const & {
    
    return new Bulk_quote(*this);}
	Bulk_quote* clone() && {
    
    return new Bulk_quote(std::move(*this));}
	// 其他成员与之前的版本一致
};

我们可以使用clone很容易地写出新版本的add_item:

class Basket {
    
    
public:
	void add_item(const Quote& sale) // 拷贝给定的对象
		{
    
     items.insert(std::shared_ptr<Quote>(sale.clone())); }
	void add_item(Quote&& sale) //移动给定的对象
		{
    
     items.insert(std::shared_ptr<Quote>(std::move(sale).clone( ))); }
	// 其他成员与之前的版本一致
};

类设计者的工具(四)：面向对象程序设计

目录

OOP: 概述

继承

动态绑定

定义基类和派生类

定义基类

成员函数与继承

定义派生类

派生类中的虚函数

派生类向基类的类型转换

派生类构造函数

派生类使用基类的成员

继承与静态成员

派生类的声明

被用作基类的类

类型转换与继承

静态类型与动态类型

不存在从基类向派生类的隐式类型转换……

……在对象之间不存在类型转换

虚函数

对虚函数的调用可能在运行时才被解析

派生类中的虚函数

final 说明符：防止继承的发生

override 说明符

虚函数与默认实参

回避虚函数的机制

抽象基类

纯虚函数

含有纯虚函数的类是抽象基类

派生类构造函数只初始化它的直接基类

访问控制与继承

受保护的成员

公有、私有和受保护继承

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

友元与继承

改变个别成员的可访问性

默认的继承保护级别

继承中的类作用域

在编译时进行名字查找

名字冲突与继承

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

关键概念：名字查找与继承

名字查找先于类型检查

虚函数与作用域

覆盖重载的函数

构造函数与拷贝控制

虚析构函数

虚析构函数将阻止合成移动操作

合成拷贝控制与继承

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

移动操作与继承

派生类的拷贝控制成员

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

派生类赋值运算符

派生类析构函数

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

继承的构造函数

容器与继承

在容器中放置（智能）指针而非对象

编写Basket类

猜你喜欢

`final` 说明符：防止继承的发生

`override` 说明符

编写`Basket`类