派生类的默认成员函数

重中之重:

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函

数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类

对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

构造、拷贝构造、赋值重载

class Person
{
public://构造Person(const char* name="peter")//如果在这里没有初始化就必须在派生类构造函数的初始化列表进行初始化:_name(name){cout << "Person()" << 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;}~Person(){cout << "~Person()" << endl;}
protected:string _name;
};//派生类中
//1、构造函数，父类成员调用父类的构造函数完成初始化
class Student : public Person
{
public://构造Student(const char* name="mawenbo", int num=3):Person(name), _num(num){}Student(const Student& s):Person(s)//必须调用基类的拷贝构造进行初始化,_num(s._num){}Student& operator=(const Student& s){if (this != &s){Person::operator=(s);//这里如果不调用基类的将一直循环//operator=(s);_num = s._num;}return *this;}
protected:int _num;
};int main()
{return 0;
}

析构

class Person
{
public:Person(){cout << "Person()" << endl;}~Person(){cout << "~Person()" << endl;}
};
class Student : public Person
{
public:Student(){cout << "Student()" << endl;}~Student(){cout << "~Student()" << endl;}
};
int main()
{Student s;return 0;
}

由运行结果我们可以得出以下几点：

1. 派生类初始化先调用基类构造函数再调用派生类构造函数。

2. 清理的时候先调用派生类的析构再调用基类的析构。

继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员，好比你爸爸的朋友不一定就是你的朋友。

继承与静态成员

class Person
{
public:Person(){_count++;}void Print(){cout << _count << endl;}
public:static int _count;
};int Person::_count = 0;
class Student : public Person
{
public:Student(){Person::_count++;}void Print(){cout << Person::_count++ << endl;}
};int main()
{Person p;p.Print();Student s;s.Print();cout << Person::_count << endl;Person::_count = 3;cout << Person::_count << endl;Person::_count = 99;cout << Person::_count << endl;}

解析：静态变量不属于任何对象，属于全局。当无论在哪里改变出了作用域都会改变。

菱形继承

概述

class A
{
public:int _a;
};
class B : public A
{
public:int _b;
};
class C : public A
{
public:int _c;
};
class D :public B, public C
{
public:int _d;
};

顾名思义，继承的关系像一个菱形一样，如上图所示。

菱形继承的二义性与改进方法（菱形虚拟继承）

二义性

先看代码：

class A
{
public:int _a;
};
class B : public A
{
public:int _b;
};
class C : public A
{
public:int _c;
};
class D :public B, public C
{
public:int _d;
};
int main()
{D d;d._a;return 0;
}

由于B和C里面都有A继承下来的_a，此时我们使用d去访问_a时就会产生二义性，编译器会不知道到底应该访问哪个_a。

菱形虚拟继承

代码如下：

class A
{
public:int _a;
};
class B : virtual public A
{
public:int _b;
};
class C : virtual public A
{
public:int _c;
};
class D :public B, public C
{
public:int _d;
};

我们只需要在继承方式的前面，也就是菱形的腰部位置加两个virtual，就构成了菱形虚拟继承。

此时我们再用d去访问_a就不会报错了，因为此时菱形虚拟继承已经吧B和C中的_a当成一个变量来处理了。

原理

代码如下：

虚拟继承之前

class A
{
public:int _a;
};
class B : public A
{
public:int _b;
};
class C : 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;
}

内存情况:

我们去查看内存的时候发现B和C中的_a是两个值，因而导致二义性。

虚拟继承后

代码如下：

class A
{
public:int _a;
};
class B : virtual public A
{
public:int _b;
};
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;
}

内存情况：

我们发现此时B和C中的_a已经成为一个值了，那么在内存中是怎样实现的呢，并且我们发现在内存中_a被放在了最下边独立于其他成员变量。

我们发现在_b和_c的存储位置上方有一个虚基表指针，我们在内存中去使用他们的指针所指向的地址可以找到他们对应的值，叫做偏移量，当我们用虚基表指针自身的地址与偏移量相加可获得_a的地址，因此内存就是以这种方式来寻找_a存放的位置的。

注意：

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有

菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在

复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言(Object Oriented,OO,也就是面向对象的语言)都没有多继承，如Java。

组合

//继承 is-a关系
class Person
{
protected:string _name;
};
class Student : public Person
{
protected:int _id;
};//组合 has-a关系
class Hair
{
protected:string _colour;
};
class Animal
{
protected:int _age;Hair h;
};

组合的耦合度低，继承的耦合度高，能使用组合就不使用继承，因为继承一定程度的破坏了代码的封装，派生类和基类的依赖关系很强。