继承
1.概念及定义：
1.1概念
继承机制是面对对象程序设计使代码可以复用的手段，它允许程序员在保持原有类特性的基础上进行拓展，增加功能，形成新的类，这样产生的类，被称为派生类。继承呈现了面对对象程序设计的层次结构，体现了简单到复杂的认知程度。
class Father
{
public:
void Print()
{
cout << "name :" << _name << endl;
cout << "_age :" << _age << endl;
}
protected:
string _name = "Peter";
int _age = 18;
};
//继承之后父类的成员都会变成子类的一部分。这里体现了Son复用了Father的成员。
class Son : public Father
{
protected:
int _stuid;
};
int main()
{
Son s;
f.Print();
system("pause");
return 0;
}
1.2 定义
定义格式：
继承关系和访问限定符：
继承基类成员访问的变化
总结：
1.基类private成员在派生类中都是不可见的。这里的不可见是指基类的private成员还是会被继承到派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不可以访问基类的private成员。
2.如果基类对象不想再类外被直接访问，需要再基类将对象定义位protected成员。
3. 有上面的表格可知，基类的私有成员再子类都是不可见的。其他的成员在子类的访问方式会缩小。
4. 使用关键字class时候的访问限定符时private，使用struct的默认继承方式时public。
5. 实际使用提倡使用public继承。
2.基类和派生类的赋值转换
1.派生类对象可以赋值给 基类的对象/基类的引用/基类的指针。这里就是常说的切片或者说切割。
2.基类对象不能赋值给派生对象
3.基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须确认基类的指针时只想派生类对象时是安全的。
切片示意图：
代码样例：
class Person
{
protected:
string _name;
string _sex;
int _age;
};
class Student : public Person
{
public:
int _No;
};
void Test()
{
//1.派生类可以赋值给基类对象/指针/引用
Student s;
Person p = s;
Person* pp = &s;
Person& rp = s;
//2.基类对象不能赋值给派生类对象
//s = p;
//3.基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &s;
Student* ps1 = (Student*)pp;//可以转换
ps1->_No = 10;
pp = &p;
Student* ps2 = (Student*)pp;//可以转换，但会出现越界访问问题。
ps2->_No = 10;
}
继承中的作用域：
1.在继承体系中，基类和派生类都有独立的作用于。
2.子类和父类有同名函数，子类将屏蔽父类对同名函数的访问，这种情况被称为隐藏或者重定义
3.需要注意的是如果是成员函数的隐藏，只需要是函数名相同就可以构成隐藏。
4.注意在实际使用中少使用隐藏。
下面就是构成隐藏的经典案例：
//Person中的_num与Student中的_num构成了隐藏导致输出结果与预期的不同
class Person
{
public:
string _name = "aoliao";//姓名
int _num = 1;//学号
};
class Student : public Person
{
public:
void Print()
{
cout << "姓名：" << _name << endl;
cout << "身份证号：" << _num << endl;
cout << "学号：" << _num << endl;
}
protected:
int _num = 101;//学号
};
void Test()
{
Student s;
s.Print();
}
int main()
{
Test();
system("pause");
}
//A对B不构成重载，因为不在同一个作用域、
//A对B构成隐藏，成员函数名只要相同就构成隐藏
class A
{
public:
void func()
{
cout << "func" << endl;
}
};
class B : public A
{
public:
void func(int i)
{
A::func();
cout << "func(int i) ->" << i<<endl;
}
};
void Test1()
{
B b;
b.func(10);
}
int main()
{
Test1();
system("pause");
}
4.派生类的默认成员函数
1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表显示调用
2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
3.派生类的operate=必须调用基类的operator=完成基类的复制
4.派生类的析构函数会在被调用完成后自动调用基类的析构函数qing’li基类成员。保证先清理派生类对象再清理基类对象
5.派生类对象的初始化先调用基类构造再调用派生类构造。
6.派生类对象析构清理先调用派生类析构再调用基类的析构
代码实现：
class Person
{
public:
Person(const char* name = "Peter")
:_name(name)
{
cout << "Person()" << endl;
}
Person(const Person& p)
:_name(p._name)
{
cout << "Person(&)" << 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;
};
class Student : public Person
{
public:
Student(const char* name, int mun)
:Person(name)
, _num(_num)
{
cout << "Student()" << endl;
}
Student(const Student& s)
:Person(s)
, _num(s._num)
{
cout << "Student(const Student& s)" << endl;
}
Student& operator=(const Student& s)
{
cout << "Student& operator=(const Student& s)" << endl;
if (this != &s)
{
Person ::operator=(s);
_num = s._num;
}
return *this;
}
~Student()
{
cout << "~Student()" << endl;
}
protected:
int _num;
};
如果类不想被继承：
1.将构造函数定义为private
2.用关键字final
5.继承及友元
友元不能被继承，派生类不能访问基类的友元。
6.继承及静态成员
基类定义了static静态成员，则整个继承体系中只有一个这样的成员，不管有多少个子类都只有一个static成员。
7.复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接的父类
多继承：一个子类有两个及以上的直接父类时这个继承被称为多继承。
菱形继承：多继承的一种特殊情况
菱形继承存在的问题：
从下面的代码和图片可以看出，菱形继承有二义性和数据冗杂的问题。
用虚拟继承可以解决二义性的问题
//菱形继承
class Person
{
public:
string _name;
};
//class Student : virtual public Person//借用虚拟继承解决菱形继承的二义性和冗余性
class Student : public Person
{
protected:
int _num;
};
//class Teacher : virtual public Person
class Teacher : public Person
{
protected:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse;
};
//
void Test()
{
Assistant a;
//无法访问，存在二义性
//a._name = "aoliao";
//需要指定访问哪个父类的成员可以解决二义性，但是存在数据冗余的问题
a.Student::_name = "aoliao";
a.Teacher::_name = "maliao";
}
研究数据冗余问题
代码实现
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;
};
void Test1()
{
D d;
d.B :: _a = 1;
d.C :: _a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
}
借助内存窗口
虚拟继承解决二义性和数据冗余
代码实现：
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 Test1()
{
D d;
d.B :: _a = 1;
d.C :: _a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
}
原理：B和C各有一个指针，指向一个表。这两个指针叫做虚基表指针，这两个表叫做虚基表。虚基表村的是内存偏移量，通过内存偏移量可以找到下面的A
原理示意图：
https://blog.csdn.net/l477918269/article/details/88782850
8.继承的总结
1.C++复杂，多继承就是其中的一个体现。不建议使用多继承，一定不要设计出菱形继承
2.多继承时c++的一个缺陷，后来很对OO语言都没有
3.继承和组合的对比
·public继承是一种is - a 的关系，也就是说每个派生类都是一个基类对象。
·组合是一种has - a 的关系。假设B组合A，每个B对象里面有一个A对象。
·优先使用组合，其次使用继承
·继承允许你根据基类类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类类有很大的影响。派生类和基类间的依 赖关系很强，耦合度高。
·对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对 象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)， 因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系， 耦合度低。优先使用对象组合有助于你保持每个类被封装
·实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适 合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就 用组合。
9.常见面试题
1.菱形继承是什么？菱形继承有什么问题？
答：菱形继承是多继承的一种特殊情况，菱形继承存在二义性和冗余性，可以说是C++的一种缺陷。
2.什么是菱形虚拟继承？如何解决冗余和二义性？
答：在派生类调用基类的时候使用虚拟继承，可以解决二义性和数据冗余问题。虚拟继承靠虚基表解决冗余和二义性。
3.继承和组合的区别？什么时候用继承？什么时候用组合？
答：继承是一种is - a关系，组合是一种has - a关系，全局引用的时候用继承，部分引用的时候用组合。
4.多继承内存偏移问题：
class Base1
{
public:
int _b1;
};
class Base2
{
public:
int _b2;
};
class Derive : public Base1, public Base2
{
public:
int _b;
};
int main()
{
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
//A.p1 == p2 == p3
//B.p1 < p2 < p3
//C.p1 == p2 != p3
//D.p1 != p2 != p3
system("pause");
return 0;
}
答案，C，原因：内存偏移问题。
