文章目录
- 一、继承概念及定义
- 二、赋值转换——切片
- 三、继承的作用域——隐藏
- 四、派生类的默认成员函数
- 五、继承与友元
- 六、继承与静态成员
- 七、菱形继承及菱形虚拟继承
- 八、继承与组合
- 九、结语
一、继承概念及定义
概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类 。而以前我们接触的复用都是函数复用，继承是类设计层次的复用。
比如对于一些类的共有属性提取出来，以供复用：
通过代码观察：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "HWC";
int _age = 18;
};
// Student和Teacher复用了Person的成员
class Student : public Person
{
protected:
//Person是父类，也称作基类。Student是子类，也称作派生类。
int _stuid;
};
class Teacher : public Person
{
protected:
int _jobid;
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
可以看到，父类的成员子类都可以使用。
定义
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类
继承方式和访问限定符
都有着public\private\protected：
在类和对象中，对于private和protected访问限定符并没有太大的区别，而对于继承来讲：private成员无法被子类继承下去
一块组合就是3*3=9种继承方式：
| 类成员/继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| 父类的public成员 | 子类的public成员 | 子类的protected成员 | 子类的private成员 |
| 父类的protected成员 | 子类的protected成员 | 子类的protected成员 | 子类的private成员 |
| 父类的private成员 | 子类中不可见 | 子类中不可见 | 子类中不可见 |
1.父类private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外面都不能去访问它。 private类内可以访问类外部可以访问，不可见类内类外都不可
2.父类private成员在子类中是不能被访问，如果父类成员不想在类外直接被访问，但需要在子类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.实际上面的表格我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > private
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际中、扩展维护性不强 。
总结来说就是：父类的private成员子类继承不可见，父类成员为protected和public,子类继承能够访问，尽量使用public继承。
二、赋值转换——切片
子类对象可以赋值给 父类的对象 / 父类的指针 / 父类的引用。这里有个形象的说法叫切片或者切割。寓意把子类中父类那部分切来赋值过去。并且这个过程中没有类型转换。没有类型转换也意味着不产生临时变量！，临时变量具有常性，所以不需要加上const
下面，我们来看一看代码是怎么体现赋值过程没有类型转换的：
class Person
{
protected:
string _name;
string _sex;
public:
int _age;
};
class Student :public Person
{
public:
int _No;
};
int main()
{
Person p;
Student s;
//中间不存在类型转换
p = s;
//引用赋值
Person& rp = s;
rp._age = 1;
//指针赋值
Person* ptr = &s;
ptr->_age = 2;
return 0;
}
-
虽然是不同类型的，但是不会发生类型转换，而类型转换在中间会产生临时变量，而临时变量具有常性，必须加const，而对于父类和子类的赋值可以不加const!
-
赋值转换也称为向上转换，子类可以给父类的对象，指针、引用。而向下装换是不行的：父类对象不能赋值给子类对象，子类有的成员而父类没有，缺少的部分怎么去给
-
这里先简单了解一下：父类的指针可以通过强制类型转换赋值给子类的指针。但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。
void Test()
{
Student sobj;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj;
Person* pp = &sobj;
Person& rp = sobj;
//2。父类对象不能赋值给子类对象
//sobj = pobj;
// 3.父类的指针可以通过强制类型转换赋值给子类的指针
pp = &sobj;
Student * ps1 = (Student*)pp; // 这种情况转换时可以的。
ps1->_No = 10;
pp = &pobj;
Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
ps2->_No = 10;
}
三、继承的作用域——隐藏
- 在继承体系中基类和派生类都有独立的作用域。而如果子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）
- 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
- 注意在实际中在继承体系里面最好不要定义同名的成员。
class Person
{
protected:
string _name = "HWC";
int _num = 10086;
};
class Student : public Person
{
public:
void Print()
{
cout << " 姓名:" << _name << endl;
cout << " 身份证号:" << Person::_num << endl;
cout << " 学号:" << _num << endl;
}
protected:
int _num = 666;
};
int main()
{
Student s1;
s1.Print();
return 0;
}
_num默认访问就近原则，访问自己的，如果想访问父类的成员，就直接指定作用域Person::_num。
经典题目：
class A
{
public:
void fun()
{
cout << "A::func()" << endl;
}
};
class B :public A
{
public:
void fun(int i)
{
cout << "B::func(int i)->" << i << endl;
}
};
void Test()
{
B b;
b.fun(10);//传入参数
}
两个fun()是什么关系？重载？重写？重定义、隐藏？编译报错？？？？
看到函数名相同，参数不同，有人会认为是函数重载，但是函数重载要求要在同一作用域！所以不是重载。所以答案是隐藏。
class A
{
public:
void fun()
{
cout << "A::func()" << endl;
}
};
class B :public A
{
public:
void fun(int i)
{
cout << "B::func(int i)->" << i << endl;
}
};
void Test1()
{
B b;
b.fun();//没有传入参数
}
此时编译会报错，同时函数还是构成隐藏，隐藏了父类的fun函数，此时子类需要传参，如果想访问，要加上作用域，即b.A::fun()
对于成员函数，只要父类和子类的同名成员函数，函数名相同就构成了隐藏。
四、派生类的默认成员函数
“默认”的意思就是指我们不写，编译器会变我们自动生成一个。那么在派生类中，这几个成员函数是如何生成的呢?
对于普通类成员，默认生成的四个成员函数（构造、析构、拷贝、赋值）：
1.内置类型：构造和析构——内置类型不处理，拷贝赋值——内置类型浅拷贝/值拷贝
2.自定义类型：构造和析构——自定义类型调用对应的构造函数和析构函数，拷贝赋值——自定义类型调用对应的拷贝或者赋值
对于派生类成员，在普通类的基础之上还有一个基类：去调用基类所对应的成员函数完成初始化/清理/拷贝，其他和普通类一样
下面，一起来看一看把：
对于构造函数
class Person
{
public:
Person(const char* name="HWC")
: _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;
};
class Student : public Person
{
public:
protected:
int _num;
};
int main()
{
Student s1;
return 0;
}
通过运行结果我们可以知道：当我们没有写默认生成的子类的构造和析构时会由父类继承下来，会调用父类的默认构造和析构。而对于子类，与类和对象是一样的，内置类型进行值拷贝，自定义类型会调用自己的默认构造和析构。
而如果父类没有默认构造函数，此时我们就需要去子类提供构造函数，但是父类成员不能在子类通过初始化列表进行初始化：
注意：在初始化列表中必须得去调用父类的构造函数，这是规定死的。可以理解为父类调父类，子类调子类。
对于拷贝构造和赋值
此时我们不写默认生成的子类的拷贝构造和赋值运算符重载：父类的部分调用父类的默认拷贝构造和重载赋值，内置类型并不处理。
简单总结来说就是：父类成员调用父类本身的来处理，自己的成员跟类和对象是一样的。
-
对于默认构造函数，如果父类没有默认构造函数，就需要我们自己去写，显式调用构造
-
对于析构函数，根据具体实际的情况，如果子类有资源需要释放，那我们就需要自己手动实现析构。
-
对于拷贝构造和赋值重载，如果子类存在深拷贝的问题，这个时候就需要我们自己实现拷贝构造和赋值重载来实现深拷贝了。
父类成员调用父类对应的构造函数、拷贝构造、operator=析构函数来处理，子类的成员按照普通类来进行处理：深拷贝的进行深拷贝，浅拷贝的进行浅拷贝即可。
class Person
{
public:
Person(const char* name)
: _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;
};
//派生类中
//构造函数，父类成员调用父类的构造函数完成初始化
class Student : public Person
{
public:
Student(const char*name,int num)
:Person(name)
,_num(num)
{}
Student(const Student&s)
:Person(s)
,_num(s._num)
{}
Student& operator=(const Student& s)
{
if (this != &s)
{
//显示调用父类的赋值
Person::operator=(s);
_num = s._num;
}
return *this;
}
protected:
int _num;
};
int main()
{
Student s1("张三",18);
Student s2(s1);
Student s3("李四",20);
s1 = s3;
return 0;
}
对于析构函数
析构函数比较特殊，如果直接去调用父类的析构：
直接报错，需要加上指定作用域，这是因为子类析构函数和父类析构函数构成隐藏关系，这是由于多态的关系需求，所有析构函数都会特殊处理成destructor(),下面进行指定作用域：
结果发现父类析构居然调用了两次，这说明了析构函数自己会调用，不需要我们显示的调用父类的析构函数，并且析构顺序是在子类析构完成之后在进行调用：
子类析构之后自动调用父类的析构函数，这样保证了先析构子类成员后析构父类的成员（自己写就没办法保证这个顺序了），所以子类析构函数不需要显示调用父类析构，会自动调用父类析构。
五、继承与友元
友元关系不能继承：
正确的做法：
六、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 ，通过代码来观察一下把：
class Person
{
public:
Person()
{
++count;
}
public:
static int count;
};
int Person::count = 0;
class Student :public Person
{
protected:
int _stuNum;
};
int main()
{
Person p;
Student s;
p.count++;
s.count++;
cout << p.count << endl;
cout << s.count << endl;
cout << &p.count << endl;
cout << &s.count << endl;
return 0;
}
因为成员是在对象里面的，而静态成员是属于整个类的，属于类所有对象，同时属于所有派生类及对象。
我们在来看这一段代码的运行结果如何：
class Person
{
public:
Person()
{
++count;
}
void Print()
{
cout << "Print()" << endl;
}
public:
string _name;
static int count;
};
int Person::count = 0;
class Student :public Person
{
protected:
int _stuNum;
};
int main()
{
Person* ptr = nullptr;
//cout << ptr->_name << endl;报错
ptr->Print();
cout << ptr->count << endl;
//下面是等价的
(*ptr).Print();
cout<<(*ptr).count<<endl;
return 0;
}
七、菱形继承及菱形虚拟继承
我们前面所说的实际上都是单继承，单继承：一个子类只有一个直接父类时称这个继承关系为单继承
然而，对于C++而言，还有多继承，多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
而菱形继承是多继承比较特殊的情况：
菱形继承的问题：菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份
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;
};
int main()
{
//二义性
Assistant a;
a._name;
解决了二义性，但是代码冗余
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
return 0;
}
虚拟继承可以解决菱形继承的二义性和数据冗余的问题:如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承(也就是在中间腰部的位置)，即可解决问题。
虚拟继承解决数据冗余和二义性的原理,我们通过给出一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型 :
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;
}
下面通过内存窗口观察,对比菱形继承与菱形虚拟继承：
左边是菱形继承，我们可以清楚的看到A有两份，既代码冗余，而通过菱形虚拟继承，此时A只有一份，且在最下面的位置
这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？
这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A
为什么需要找到最下面的A：比如当下面的赋值发生时，d要去找出B/C成员中的A才能赋值
B*ptr = &d;
ptr->_a= 1;
C*ptr = &d;
ptr->_a= 2;
切片的时候就需要通过偏移量去计算位置，也就是找到最下面的A。
八、继承与组合
继承和组合都是一种复用，最大的区别是访问的方式有所不同
// Car和BMW Car构成is-a的关系
class Car{
protected:
string _colour = "黑色";
string _num = "粤A10000";
};
class BMW : public Car{
public:
void Drive() {cout << "is-a" << endl;}
};
// Tire和Car构成has-a的关系(轮胎和车)
class Tire{
protected:
string _brand = "Michelin";
size_t _size = 17;
};
class Car{
protected:
string _colour = "黑色";
string _num = "粤A10000";
Tire _t;
};
继承是白箱复用，组合是黑箱复用（黑与白是能不能看到内部），组合的耦合度低，而继承的耦合度高，而高内聚低耦合，耦合度高意味着依赖关系大，所以当继承与组合都符合的情况下，比较建议使用组合。
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装
九、结语
C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承
定义一个不能被继承的类
1.构造私有
class A
{
private:
A()
{}
};
class B:public A
{
};
int main()
{
B bb;
return 0;
}
2.类定义时加final
class A final
{
public:
A()
{}
};
class B:public A
{
};
int main()
{
B bb;
return 0;
}
