目录：
- 前言
- 一、继承的概念及定义
- （一）概念
- （二）继承定义
- 继承关系和访问限定符
- 继承基类成员访问方式的变化
- 二、基类和派生类对象赋值转换
- 三、继承中的作用域
- 四、派生类的默认成员函数
- 五、继承与友元
- 六、继承与静态成员
- 七、复杂的菱形继承及菱形虚拟继承
- 菱形继承
- 虚继承
- 组合
- 补充
前言
| 打怪升级：第50天 |
|---|
 |
一、继承的概念及定义
（一）概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，他允许类在保持原有特性的基础上进行拓展，增加新的功能，这样产生的类叫做子类或者派生类。
继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
示例：
class Person
{
public:
void Print()
{
cout << "name : " << _name << endl;
cout << "age : " << _age << endl;
}
protected:
string _name = "小李子";
int _age = 20;
};
// Person类作为父类，被student 和 teacher继承后，父类的public 和 protected 成员（变量和函数）都会变成子类的一部分，可以在子类中进行访问。
class Student : public Person
{
private:
string _s_id = "000"; // 学号
};
class Teacher : public Person
{
private:
string _t_id = "100"; // 工号
};
void Test_person1()
{
Student s1;
s1.Print();
Teacher t1;
t1.Print();
}
运行实例：
（二）继承定义
继承关系和访问限定符
继承基类成员访问方式的变化
基类的私有成员（private）子类无论如何都是不可见的，基类的保护成员（protected）和共有成员（public）在子类中的受继承方式限制，一般都使用 public继承，也就都是可见的；
这就好比父亲挣得钱和 父亲藏的私房钱，父亲挣的钱一家人都可以用，但是私房钱只有父亲自己可以用，哪怕是儿子也不行。
这里有一个小问题：子类可以访问到父类的私有成员（私房钱）吗，
我们上面讲：父类的私有成员在子类中不可见，既然不可见（不知道老爸私房钱藏在哪里），那是不是就不能使用？
- 总结
- 基类private成员在派生类中无论以何种方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类不管来类内还是类外都无法访问到。
- 基类private成员在派生类中是访问不到的，如果想要在派生类中可以访问，但是在类外不能访问到，就需要使用protected。可以看出：保护成员限定符是因继承才出现的（c++刚问世的时候只设置了私有和共有，在C++2.0时才加入了保护成员）。
- 基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
- 使用关键字class时默认的访问和继承方式是private， 使用struct 时默认的访问和继承方式是public，不过最好显示写出继承方式；
- 在实际运用中一般使用都是public继承，几乎很少使用 protected/private继承。
- 一句话总结：权限可以缩小但不可放大（类比：const变量不能被非const变量引用）。
二、基类和派生类对象赋值转换
-
派生类可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法加切片或者切割。
寓意把派生类中基类那部分切出来赋值过去。 -
基类对象不能赋值给派生类对象。
-
基类的指针或引用可以通过强制类型转换赋值给派生类的指针或引用。但是只有访问基类成员时才是安全的，否则可能造成越界。
三、继承中的作用域
- 在继承体系中，基类和派生类都有独立的作用域；
- 子类和父类中有同名成员，子类成员将屏蔽对父类同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类对象中，可以使用 基类：：基类成员显示访问）。
- 注意：成员函数只要函数名相同就构成隐藏。（区分函数重载：在同一作用域内，函数名相同而参数不同）；
- 注意在实际的继承体系里面最好不要定义同名的成员。
class Person
{
public:
void Print()
{
cout << "name : " << _name << endl;
cout << "age : " << _age << endl;
}
string _name = "小李子";
int _age = 20;
};
class Student : public Person
{
public:
void Print()
{
cout << "id :" << _s_id << endl;
}
string _s_id = "000"; // 学号
};
class Teacher : public Person
{
public:
void Print()
{
cout << "id :" << _t_id << endl;
}
string _t_id = "100"; // 工号
};
void Test_Person3()
{
Student s1;
s1.Person::Print(); // 隐藏，显示调用同名成员
s1.Print();
cout << endl;
Teacher t1;
t1.Person::Print();
t1.Print();
}
四、派生类的默认成员函数
6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何生成的呢？
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。 - 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
- 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能
保证派生类对象先清理派生类成员再清理基类成员的顺序。 - 派生类对象初始化先调用基类构造再调派生类构造。
- 派生类对象析构清理先调用派生类析构再调基类的析构。（保证进栈出栈顺序）。
- 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
class Person
{
public:
Person(string name = "小李子", int age = 20)
:_name(name)
, _age(age)
{}
void Print()
{
cout << "name : " << _name << endl;
cout << "age : " << _age << endl;
}
string _name;
int _age;
};
class Student : public Person
{
public:
Student(string name = "小李子", int age = 20, string id = "000")
:Person(name, age) // 显示调用基类的构造
, _s_id(id)
{}
Student(const Student& s)
:Person(s) // 显示调用
, _s_id(s._s_id)
{}
void Print()
{
Person::Print();
cout << "id :" << _s_id << endl;
cout << endl;
}
string _s_id; // 学号
};
void Test_Person4()
{
Student s1;
s1.Print();
Student s2("陈平安", 40);
s2.Print();
Student s3("裴钱", 26, "001");
s3.Print();
Student s4 = s3;
s4.Print();
}
class Base
{
public:
Base(int val = 10)
:b_val(val)
{
cout << "Base()" << endl;
}
Base(const Base& b)
:b_val(b.b_val)
{
cout << "Base(const Base&)" << endl;
}
Base& operator=(const Base& b)
{
if (&b != this)
{
b_val = b.b_val;
cout << "Base::operator=()" << endl;
}
return *this;
}
~Base() { cout << "~Base()" << endl; }
int b_val;
};
class Son: public Base
{
public:
Son(int val1 = 10, int val2 = 20)
:Base(val1)
,s_val(val2)
{
cout << "Son()" << endl;
}
Son(const Son& b)
:Base(b) // 派生类对象初始化基类对象
,s_val(b.s_val)
{
cout << "Son(const Base&)" << endl;
}
Son& operator=(const Son& s)
{
if (&s != this)
{
Base::operator=(s); // 显示调用基类的赋值
s_val = s.s_val;
cout << "Son::operator=()" << endl;
}
return *this;
}
~Son() { cout << "~Son()" << endl; }
int s_val;
};
void Test_p5()
{
Son s1;
cout << endl;
Son s2 = s1;
cout << endl;
Son s3;
s3 = s1;
cout << endl;
Son s4(1, 2);
cout << endl;
}
注意：在派生类的构造和赋值中 如果我们不显示调用基类的赋值和拷贝构造，编译器不会自动调用。
五、继承与友元
友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
void main()
{
Person p;
Student s;
Display(p, s);
}
六、继承与静态成员
**基类定义了static静态成员，则整个继承体系里面只有这样一个静态成员。**无论派生出多少个子类，都只有一个static成员实例。
class Base
{
public:
static int cnt;
};
int Base::cnt = 0; // 静态成员变量需要在类外初始化，且初始化时不需要加static
class Son1 :public Base
{
public:
Son1()
{
++cnt;
}
};
class Son2 :public Base
{
public:
Son2()
{
++cnt;
}
};
void Test_Static1()
{
Son1 s1_1;
Son1 s1_2;
cout << "cnt = " << s1_2.cnt << endl;
Son2 s2_1;
Son2 s2_2;
cout << "cnt = " << s2_2.cnt << endl;
}
七、复杂的菱形继承及菱形虚拟继承
菱形继承
菱形继承造成的影响：Child从父类Student中继承了Person类的属性，又从父类Teacher中也继承了Person类的属性，那么此时，Child类中就有了两份Person类属性，
这会有两个问题：二义性和数据冗余
- 我们访问Person类属性时不能确定访问的到底是从父类STudent中继承下来的还是从父类Teacher中继承下来的；
- 多份的Person类属性会造成数据的冗余。
虚继承
为了解决菱形继承带来的问题，我们祖师爷在C++3.0给出了解决方案：虚继承
关键字：virtual（虚拟）
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;
};
void Test_1()
{
D d1;
d1.B::_a = 10;
d1.C::_a = 30;
}
这里有盆友可能会提出疑问：我们解决数据冗余不就是为了节省空间吗，这里多增加了一个A，而且父类中的A也还存在，并且A中存放的地址还指向另外一块区域，这样不就更加浪费空间了吗，难道我们的祖师爷在当时设计虚继承时“喝了假酒”，所以这部分写出问题来啦？
虚继承原理解析：
很多人说c++的语法复杂，多继承就是一个体现：有了多继承就会有菱形继承，有了菱形继承就会有菱形虚拟继承，底层实现就很复杂，
并且编译器在背后为我们做的一系列操作也是有时间消耗的，所以一般不建议写出多继承，一定不要写菱形继承！
由于c++现世的时间非常早，当时的参考资料较少，因此设计上难免会有一些不合理的地方（如多继承、string类等等），我们的前辈也在对c++不断的进行缝缝补补，后世的一些OO语言在参考了c++之后就限制了继承的操作，如Java就只有单继承没有多继承。
组合
class A
{
public:
int _a1;
protected:
int _a2;
};
class B :public A
{
public:
void Init()
{
_a1 = 10;
_a2 = 20;
}
};
class C
{
public:
void Init()
{
_aa._a1 = 10;
// _aa._a2 = 20; // 不可访问
}
A _aa; // 组合 -- c中有a
};
