一、模板进阶

1. 非类型模板参数

模板参数分为==类型形参==和==非类型形参==

• 类型形参 即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

• 非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

这里我们引入一个例子来说明问题：

#define N 10
template<class T>
class arr {
   
   
public:
     //...
private:
     T _a[N];
};

void test1() {
   
   
     arr<int> arr;
}

这里有一个缺陷，因为N是固定的，所以我们想要同时定义两个大小分别为10和20的数组是做不到的。

所以，C++中引入了非类型模板参数，在这里我们不仅仅可以传入不同的类型形参来定义不同的模板类，还可以传递不同的非类型形参来指定大小。当然了，==非类型模板参数是可以给定缺省值的，如果我们不传，他就默认使用却缺省值。==

template<class T, int N = 20>
class Array
{
   
   
public:
    //N = 100;  error
private:
    T _a[N];
};

💕 注意：

• 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
• 非类型的模板参数必须在编译期就能确认结果(实参只能是常量)。

---

2. 模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码， ==但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理==，比如：==实现了一个专门用来进行小于比较的函数模板。==

我们以日期类为例：

这里我们分装了一个简单的日期类，可以正常进行日期大小的比较。然后下面我们实现一个专门用来==进行小于比较的函数模板==：

template<class T>
bool Less(T left, T right)
{
   
   
    return left < right;
}

这里我们可以看到，这里的比较出现了错误，因为在Less内部，比较的是d3和d4的地址，而这显然是不符合我们的预期的。所以比较结果发生了错误。为了解决这种问题，就需要对模板进行特化。即：==在原模板类的基础上，针对特殊类型所进行特殊化的实现方式==。模板特化中分为函数模板特化与类模板特化。

---

2.1 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板。
2. 关键字template后面接一对空的尖括号<>。
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型。
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

template<>
bool Less<Date*>(Date* left, Date* right)
{
   
   
    return *left < *right;
}

这里我们可能会想到，与其这样做我们为什么不直接再重载一次<运算符呢？而且重载一次<运算符，所有的指针类型的比较就都可以解决了。其实我们这样考虑是非常正确的，因为重载可以一次性解决各种问题。一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出（函数重载）。

所以，对于一些参数类型复杂的函数模板我们一般直接使用函数重载来实现，这种方法实现简单明了，代码的可读性高，容易书写，因此==函数模板一般不建议特化。==

---

2.2 类模板特化

全特化

全特化即是将模板参数列表中所有的参数都确定化。

//类模板
template<class T>
struct Less
{
   
   
    bool operator()(const T& l, const T& r) const
    {
   
   
        return l < r;
    }
};
//全特化
template<>
struct Less<Date*>
{
   
   
    bool operator()(const Date* l, const Date* r) const
    {
   
   
        return *l < *r;
    }
};

偏特化

任何针对模版参数进一步进行条件限制设计的特化版本。

偏特化有两种方式—— 部分特化和 参数更进一步的限制

💕 部分特化—— 将模板参数类表中的一部分参数特化

cpp template<class T1,class T2> class Data { public: Data() { cout << "Data<T1, T2>" << endl; } private: T1 _d1; T2 _d2; }; //部分特化 template<class T> class Data<T,int> { public: Data() { cout << "Data<T1, int>" << endl; } private: T1 _d1; T2 _d2; };
💕 参数进一步限制—— 针对模板参数更进一步的条件限制所设计出来的一个特化版本。




cpp int main() { Data<int, int> d1; Data<int*, char*> d2; Data<int*, int> d3; Data<double, int> d4; Data<int*, int*> d5; Data<int&, char&> d6; Data<int&, char*> d7; return 0; }

这里我们通过偏特化对模板参数进行进一步限制，我们在传参的时候，符合什么参数类型就会调用该参数类型的特化模板。



**
## 3. 模板的分离编译
### 3.1 什么是分离编译
==一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程==称为分离编译模式 。但是我们自从学了STL容器后，模拟的每一个容器都不会 将它分为.h和.cpp的分离编译的模式，这是什么原因呢？下面我们来看看一下类模板的分离编译会出现什么样的问题。
**
### 3.2 模板的分离编译
这里我们来实现一个简单的模板分离编译来看一下会发生什么事情。




当我们编译我们的程序时就会发现，这里出现了一个链接错误。下面我们来分析一下出现这种现象的原因：

我们先来回顾一下一个C语言或者C++程序变成一个可执行程序需要经历的阶段，分别是预处理、编译、汇编、链接。
> 预处理： 头文件的展开、宏替换、条件编译、去掉注释...
> 编译： 检查语法，生成汇编代码
> 汇编： 汇编代码转换成二进制机器码
> 链接： 合并段表、符号表等生成可执行程序

因为在预处理、编译、汇编这三个阶段每个源文件都是独立进行的、只有在链接的时候他们才会合并到一起形成我们的可执行程序。




下面我们来分析一下报错的原因：

（1） 预处理和编译阶段会将func.h的头文件分别展开到func.cpp和Test.cpp这两个头文件中，并将两个展开后的代码转换成汇编代码。

（2） 汇编阶段，由于Test.cpp中只有Add函数的声明，所以汇编指令会在声明的地方给Add函数一个无效的地址，同时，在Add.cpp中，由于没有Add函数实例化后的代码，所以不会生成具体的加法函数，因此，Add.cpp中在汇编阶段对应的函数也是无效地址。

（2） 链接阶段，因为链接阶段将func.cpp和Test.cpp中符号表中的内容合并的时候因为两个函数的地址对应不上，所以就会发生链接错误。

解决方法
> 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的(强烈推荐)
> 模板定义的位置显式实例化。（不实用，不推荐）

为什么我们不推荐使用在模板定义的位置显示实例化这种方式呢？




这种方式虽然说也能达到我们的目的，每次调用不同类型的模板函数的时候我们都需要修改func.cpp中的显示实例化的类型，所以这样不仅繁琐，而且也失去了模板本来的意义了。
**
### 3.3 模板总结
【优点】
> 1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
> 2. 增强了代码的灵活性

【缺点】
> 1. 模板会导致代码膨胀问题，也会导致编译时间变长
> 2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误
**
# 二、继承
## 1. 继承的概念及定义
💕 继承的概念：
> 继承(inheritance)机制是面向对象程序设计 使代码可以复用的最重要的手段，它允许程序员在 保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承 呈现了面向对象
程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用， 继
承是类设计层次的复用。

cpp class Person { public: void Print() { cout << "name:" << _name << endl; cout << "age:" << _age << endl; } protected: string _name = "peter"; // 姓名 int _age = 18; // 年龄 }; class Student : public Person { protected: int _stuid; // 学号 }; int main() { Student s; s.Print(); return 0; }


Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student复用了Person的成员。在监视窗口中我们可以看到Student对象中变量的复用，并且调用Print成员函数后可以看到成员函数的复用。

💕 继承的定义：

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类



💕 继承关系和访问限定符




总结：
> 1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的 不可见是指基类的私
有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
都不能去访问它。
> 2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在
派生类中能访问，就定义为protected。可以看出 保护成员限定符是因继承才出现的。
> 3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他
成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
> 4. ==使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public==， 不过
最好显示的写出继承方式。
> 5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承， 也不提倡
使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
面使用，实际中扩展维护性不强。
> 6. 继承如果 不特别指明是protected继承或private继承，则都是指public继承。





*
## 2. 基类和派生类对象赋值转换
> 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去 。
> 基类对象不能赋值给派生类对象。
> 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。



cpp class Person { protected: string _name; string _sex; int _age; }; class Student : public Person { public: int _No; }; int main() { // 中间不存在类型转换,不会产生临时变量 // 子类对象可以赋值给父类对象/指针/引用 Student s; Person p = s; Person& rp = s; Person* ptrp = &s; // 中间存在类型转换,会产生临时变量,临时变量具有常性 int i = 1; double d = 2.2; i = d; const int& ri = d; return 0; }


**
## 3. 继承中的作用域
> 1. 在继承体系中 基类和 派生类都有独立的作用域。
> 2. 子类和父类中有同名成员，== 子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
也叫重定义==。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
> 3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
> 4. 注意在实际中在 继承体系里面最好 不要定义同名的成员。

cpp class Person { public: void func() { cout << "Person::func()" << endl; } protected: string _name = "小李子"; // 姓名 int _num = 111; // 身份证号 }; class Student : public Person { public: void func() { cout << "Student::func()" << endl; } protected: int _num = 999; // 学号 }; void Test() { Student s1; s1.func(); s1.Person::func(); };


这里的父类和子类的func函数构成了隐藏（重定义），==并不是构成函数重载==，因为构成重载的条件是在同一作用域，而父类和子类的作用域是不同的。

一道选择题

关于同名隐藏的说法正确的是（ ）
A. 同一个类中，不能存在相同名称的成员函数。
B. 在基类和子类中，可以存在相同名称但参数列表不同的函数，他们形成重载。
C. 在基类和子类中，不能存在函数原型完全相同的函数，因为编译时会报错。
D. 成员函数可以同名，只要参数类型不同即可，成员变量不能同名，即使类型不同。
答案：D
解析：A 选项：可以存在，如函数重载。B、C 选项：基类与子类函数名字相同，参数不同，形成的是隐藏，可以共存。D 选项：成员函数在同一个类里面同名，此时构成了重载，但变量一定不能同名，故正确。

---

4. 派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。==如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。==
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化==先调用基类构造再调派生类构造==。
6. 派生类对象析构清理==先调用派生类析构再调基类的析构==。
7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，==子类析构函数和父类析构函数构成隐藏关系==。

class Person {
   
   
public:
    //构造函数
    Person(const char* str = "peter")
        :_name(str)
    {
   
   
        cout << "Person(const char* str)" << endl;
    }

    //拷贝构造
    Person(const Person& p)
        :_name(p._name)
    {
   
   
        cout << "Person(const Person& p)" << endl;
    }

    //赋值运算符重载函数
    Person& operator=(const Person& p)
    {
   
   
        cout << "Person& operator=(const Person& p)" << endl;
        //这里我们需要判断，防止自己给自己赋值
        if (this != &p)
            _name = p._name;
        return *this;
    }

    //打印信息函数
    void Print()
    {
   
   
        cout << "姓名:" << _name << endl;
    }

    //析构函数
    ~Person()
    {
   
   
        cout << "~Person()" << endl;
    }

protected:
    string _name;//姓名
};

class Student :public Person
{
   
   
public:
    //构造函数
    Student(const char* str = "张三", int num = 0)
        :Person(str)
        , _num(num)
    {
   
   
        cout << "Student(const char* str,int num)" << endl;
    }

    //拷贝构造
    Student(const Student& s)
        :Person(s)
        , _num(s._num)
    {
   
   
        cout << "Student(const Student& s)" << endl;
    }

    //赋值运算符重载
    Student& operator=(const Student& s)
    {
   
   
        if (this != &s) {
   
   
            Person::operator=(s);//必须指定父类作用域，否则会无限递归调用子类赋值重载
            _num = s._num;
        }
        cout << "Student& operator=(const Student& s)" << endl;
        return *this;
    }

    //打印信息函数Print
    void Print()
    {
   
   
        cout << "姓名:" << _name << "学号:" << _num << endl;
    }

    //析构函数
    ~Student()
    {
   
   
        //Person::~Person();//——这种写法是不合法的，
        //因为编译器会将析构函数统一处理成destructor
        //所以我们需要指定类域,但是如果先释放父类的资源，可能会导致内存泄漏
        cout << "~Student()" << endl;
    }
private:
    int _num;//学号
};

这里我们需要注意的是子类的析构函数会在被调用完成后自动调用弗雷德析构函数清理父类的成员，这样才能保证子类对象先清理子类成员再清理父类成员的顺序，如果我们要是再子类的析构函数中调用父类的析构函数，就无法保证子类的析构函数先被析构。那么为什么要先析构子类后析构父类呢？
其实这是因为父类是在子类之前定义的，如果子类中有父类所申请的资源，那么如果要是先析构父类的话，子类中的父类资源将无法被析构，这样就会造成内存泄漏。

---

5. 继承与友元or静态成员

💕 继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

在这里父类的友元函数中是不能访问子类的私有和保护成员的，如果我们想让友元函数也能访问子类的protected和private成员，那么需要在子类中声明一下友元函数。

💕 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。 无论派生出多少个子
类，都只有一个static成员实例 。由于静态成员是为所有类对象共享的，不属于任何一个具体的对象，所以，在父类中定义了一个静态成员，那么这个静态成员也属于所有的子类及其对象，所以整个继承体系中无论有多少个父类或者子类，都只有一个static成员。

class Person
{
   
   
public:
    Person() {
   
    ++_count; }
protected:
    string _name; // 姓名
public:
    static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
   
   
protected:
    int _stuNum; // 学号
};
class Graduate : public Student
{
   
   
protected:
    string _seminarCourse; // 研究科目
};
void TestPerson()
{
   
   
    Student s1;
    Student s2;
    Student s3;
    Graduate s4;
    cout << " 人数 :" << Person::_count << endl;
}

---

面试题

下面程序的运行结果是什么，并解释原因：

class Person {
   
   
public:
    Person() {
   
    ++_count; }

    void Print() {
   
   
        cout << this << endl;
    }

public:
    string _name; // 姓名
    static int _count; // 统计人的个数。
};
int Person::_count = 0;  //在类外对静态成员进行定义初始化

int main()
{
   
   
    Person* ptr = nullptr;
    cout << ptr->_name << endl;   //1
    ptr->Print();                 //2
    cout << ptr->_count << endl;  //3

    (*ptr).Print();                //4
    cout << (*ptr)._count << endl; //5

    return 0;
}

• 显然，除了第1个的结果是编译错误外，别的都能够正常运行。因为第1个会发生空指针的解引用。
• 第2个运行正确的原因是成员函数存在于代码区，所以不会发生空指针的解引用，虽然成员函数调用需要传递this指针，但是ptr是Person类型的指针，所以ptr的值0x0000会被当做this指针传递给Print()函数，所以会打印0x0000。
• 第3个程序中，count是静态成员变量，不属于对象，同时他存在于静态区，所以也不会发生ptr的解引用。所以直接打印count的值。
• 第4个程序和第5个程序其实本质上和第2个和第3个是等价的，所以也不会发生空指针的解引用。

如何实现一个不能被继承的类？

class A
{
   
   
public:
    static A CreateObj()
    {
   
   
        return A();
    }
private:
    A()
    {
   
   }
};

class B : public A
{
   
   };

int main()
{
   
   
    A::CreateObj();
    return 0;
}

虽然这种方式能够实现一个不能够被继承的类，但是由于我们将类的构造函数私有化了，所以这里我们不能够直接实例化一个父类对象，只能够间接利用类域调用静态成员函数来实例化一个匿名对象。

在这里C++11提供了另外一种方式，使用关键字final来修饰一个类，那么这个类将不能够被继承：

---

6. 复杂的菱形继承及菱形虚拟继承

单继承： 一个子类只有一个直接父类时称这个继承关系为单继承



多继承： 一个子类有两个或以上直接父类时称这个继承关系为多继承



菱形继承： 多继承的一种特殊情况



**
### 菱形继承的二义性和数据冗余

我们看下面的继承方式：
> 从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份
cpp class Person { public: string _name; // 姓名 }; class Student : public Person { protected: int _num; //学号 }; class Teacher : public Person { protected: int _id; // 职工编号 }; class Assistant : public Student, public Teacher { protected: string _majorCourse; // 主修课程 };






这里我们可以通过指定作用域来解决二义性问题，但却解决不了数据冗余的问题，因为还是会调用两次父类的构造函数。

💕 解决方法—— 虚拟继承 （virtual）



==虚拟继承可以解决菱形继承的二义性和数据冗余的问题==。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。 但是我们在实际开发中要尽量避免使用菱形继承。
**
### 虚拟继承的原理
我们给定一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。

cpp class A { public: int _a; }; // class B : public A class B : virtual public A { public: int _b; }; // class C : public A class C : virtual public A { public: int _c; }; class D : public B, public C { public: int _d; }; int main() { D d; d.B::_a = 1; d.C::_a = 2; d._b = 3; d._c = 4; d._d = 5; return 0; }

💕 普通菱形继承下的的对象模型：



这里我们可以看到，D对象中存在三部分的成员，B继承下来的成员，C继承下来的成员和D自生的成员，同时，由于B和C同时继承了A，所以D对象中存在两份A的成员，从而造成了数据冗余和二义性问题。

💕 菱形虚拟继承下的的对象模型：




在这里我们发现，B和C对象中不再有A的成员，但是B和C中却多了一个指针，当我们查看该指针指向的内存窗口时，发现该窗口的第二个整形的值恰好为B/C对象的起始地址与A对象的起始地址的偏移量。

但是我们发现这两个表中，偏移量没有存到第一个位置，因为第一个位置是为以后多态做准备的。



==在这里虚继承的类对象记录虚继承类的偏移量也满足了切片的场景。==



当然了，有了虚基表指针，无论创建多少个菱形对象模型，他们都用的是一个虚基表指针，虚基表里面存储了虚继承对象的存储地址与虚基类地址的偏移量，虚继承对象可以根据这个偏移量来找到虚基类。

下面是上面的Person关系菱形虚拟继承的原理解释：



## 7. 继承的总结和反思

> 1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
形继承就有菱形虚拟继承，底层实现就很复杂。==所以一般不建议设计出多继承，一定不要设
计出菱形继承。否则在复杂度及性能上都有问题。==
> 2. 多继承可以认为是C++的缺陷之一，很多后来的面向对象语言都没有多继承，如Java

继承和组合

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
• ==优先使用对象组合，而不是类继承==
• 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 实际尽量多去用组合。组合的耦合度低，代码维护性好。==不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。== 类之间的关系可以用继承，可以用组合，就用组合。

// Car和BMW Car和Benz构成is-a的关系
class Car{
   
   
protected:
    string _colour = "白色"; // 颜色
    string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car{
   
   
public:
    void Drive() {
   
   cout << "好开-操控" << endl;}
};
class Benz : public Car{
   
   
public:
    void Drive() {
   
   cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire{
   
   
protected:
    string _brand = "Michelin"; // 品牌
    size_t _size = 17; // 尺寸
};
class Car{
   
   
protected:
    string _colour = "白色"; // 颜色
    string _num = "陕ABIT00"; // 车牌号
    Tire _t; // 轮胎
};

8. 笔试面试题

1. 什么是菱形继承？菱形继承的问题是什么？
2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的
3. 继承和组合的区别？什么时候用继承？什么时候用组合？
4. 派生类的默认成员函数有哪些特点？

---