目录
- 一、继承的概念和定义
- 1.1 继承的概念
- 1.2 继承定义
- 1.2.1定义格式
- 1.2.2 继承方式和访问限定符
- 1.2.3 继承基类成员访问方式的变化
- 二、父类和子类对象赋值转换
- 三、继承中的作用域
- 四、派生类的默认成员函数
- 五、继承和友元
- 六、继承与静态成员
- 七、复杂的菱形继承及菱形虚拟继承
- 八、继承的总结和反思
- 九、解答三个问题
一、继承的概念和定义
1.1 继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生的新的类，称派生类或子类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
class Person
{
public:
void func()
{
cout << "func" << endl;
}
public:
string _name = "张三";
};
class Student : public Person
{
public:
//继承后父类的Person的成员（成员函数+成员变量）都会变成子类Student的一部分。
//即子类现在也拥有成员变量_name和成员函数func，可以通过子类对象直接访问
int age=20;
};
int main()
{
Person p;
Student stu;
cout << stu._name << endl;
return 0;
}
1.2 继承定义
1.2.1定义格式
1.2.2 继承方式和访问限定符
继承方式：public继承，protected继承，private继承。
访问限定符：public访问，protected访问，private访问。
1.2.3 继承基类成员访问方式的变化
总共有九种继承和访问限定符的组合方式。
总结一下就是两点：
一、子类无论用什么继承方式继承父类的私有成员都是不可见的。
二、其它的情况就是取访问限定符和继承方式权限小的作为子类从父类继承过来的成员变量的访问权限。
另外还有几个补充点：
1、基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2、基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就可以定义为protected。所以保护成员限定符是因继承才出现的。
3、使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好还是显示的写出继承方式。
4、在实际运用中一般使用都是public继承，因为private继承和protected继承只能在子类内部使用，扩展维护性不大。
二、父类和子类对象赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这种赋值我们叫做切片或者切割。意思是把子类中父类那部分切来赋值过去。
父类对象不能赋值给子类对象，原因是子类自己的成员变在父类是没有的，所以无法赋值。
class Person
{
public:
void func()
{
cout << "func" << endl;
}
public:
string _name;
int _id;
int _age;
};
class Student : public Person
{
public:
int _No;
};
int main()
{
Person p;
Student stu;
//子类对象可以直接赋值给父类对象/指针/引用
p = stu;
Person* pp = &stu;
Person& rp = stu;
return 0;
}
三、继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显式访问）
- 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
- 注意在实际中在继承体系里面最好不要定义同名的成员。
- 隐藏和以前的函数重载是不一样的，函数重载要求在同一作用域，并且重载的函数的参数类型或者数目是不同的，但是隐藏只需要函数名相同就行了。
class A
{
public:
int _num = 10;
};
class B :public A
{
public:
int _num = 20;
};
int main()
{
//A中的_num和B中的_num构成隐藏(重定义),
B b;
//就近原则访问B类自己的_num成员，
cout << b._num << endl;
//如果想访问A中的_num，需要指定类域
cout << b.A::_num << endl;
//A中的func和B中的func构成隐藏
b.func();
//要想用b对象调用A中的func函数，需要指定类域
b.A::func();
return 0;
}
四、派生类的默认成员函数
6个默认成员函数，一般只研究4个，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
- 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
- 派生类对象初始化先调用基类构造再调派生类构造。
- 派生类对象析构清理先调用派生类析构再调基类的析构。
- 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
class A
{
public:
//构造函数
A(int num)
:_num(num)
{
cout << "A(int num)" << endl;
}
//拷贝构造
A(const A& a)
:_num(a._num)
{
cout << "A(const A& a)" << endl;
}
//赋值重载
A& operator=(const A& a)
{
if (this != &a)
{
_num = a._num;
cout << "operator=(const A& a)" << endl;
}
return *this;
}
//析构函数
~A()
{
cout << "~A()" << endl;
}
void func()
{
cout << "funcA" << endl;
}
public:
int _num = 10;
};
class B :public A
{
public:
//构造函数
B(int num)
//调用父类的构造函数
:A(num)
,_num(num)
{
cout << "B(int num)" << endl;
}
//拷贝构造
B(const B& b)
//调用父类的拷贝构造函数
:A(b)
,_num(b._num)
{
cout << "B(const B& b)" << endl;
}
//赋值重载函数
B& operator=(const B& b)
{
if (this != &b)
{
//调用父类的赋值重载函数，参数b不用处理，因为子类对象可以直接赋
//值给父类对象/引用/指针
A::operator=(b);
_num = b._num;
cout << "operator=(const B& b)" << endl;
}
return *this;
}
//析构函数
~B()
{
//编译器自动先调用子类的析构函数析构子类对象自己的成员，
// 再自动调用父类的析构函数析构从父类继承过来的那部分成员
cout << "~B()" << endl;
}
void func()
{
cout << "funcB" << endl;
}
public:
int _num = 20;
};
int main()
{
B b(10);
B bb(b);
b = bb;
return 0;
}
五、继承和友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。
六、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。
可以利用这一特性计算派生类一共定义了多少个对象。
class A
{
public:
A()
{
count++;
}
static int countkid()
{
return count;
}
public:
static int count;
};
int A::count = 0;
class B :public A
{};
int main()
{
int i = 0;
for (int i = 0; i < 10; i++)
{
//定义子类B的对象时一定会调用父类A的构造函数，
//故可以在A的构造函数里统计定义了多少个子类对象
B b;
}
cout << A::countkid() << endl;
return 0;
}
七、复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。
菱形继承：菱形继承是多继承的一种特殊情况。
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在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;
}
虚拟继承对象存储模型：
//虚拟继承
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;
}
单继承的虚拟继承也运用了同样的存储模型，也是通过虚基表指针的存放偏移量的方式处理虚继承的对象模型的。如下：
八、继承的总结和反思
1、都说C++的语法很复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2、多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
3、继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。如每个学生都是一个人。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。如头和鼻子，每个头都有一个鼻子。
优先使用对象组合，而不是类继承 。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，也可以用组合，就用组合。
九、解答三个问题
1、什么是菱形继承？菱形继承的问题是什么？
菱形继承就是一个子类有多个父类，并且父类又有共同的父类，此时就构成菱形继承。菱形继承存在数据冗余和二义性问题。
2、什么是菱形虚拟继承？如何解决数据冗余和二义性的？
在多继承的“腰部”的继承时加上关键字virtual，形成虚拟继承，虚拟继承是把继承的成员放到一个公共的位置，有相同的成员只放一份；同时在对象中存放一个虚基表指针，在访问继承的成员时通过虚基表指针找到该成员相对该虚基表指针的偏移量，从而找到需要访问的成员。
3、继承和组合的区别？什么时候用继承？什么时候用组合？
继承：每个派生类对象都是一个基类对象，组合：每个B对象中都有一个A对象。
只符合继承的特点的时候用继承，多态必须用继承；只符合组合的时候用组合；既能用继承，又能用组合时用组合。因为组合拥有高内聚，低耦合的特点。
以上就是今天想要跟大家分享的全部内容啦，你学会了吗？如果感觉到有所帮助，那么点点赞，点点关注呗，后期还会持续更新C++相关知识哦，我们下期见啦！！！！！！！
