🏠专栏介绍：浅尝C++专栏是用于记录C++语法基础、STL及内存剖析等。
🎯每日格言：每日努力一点点，技术变化看得见。
文章目录
- 继承的概念及定义
- 继承的概念
- 继承的定义
- 定义格式
- 继承关系与访问限定符
- 基类和派生类对象赋值转换
- 继承中的作用域
- 派生类的默认成员函数
- 继承与友元
- 继承与静态成员
- 复杂的菱形继承及菱形虚拟继承
继承的概念及定义
继承的概念
我们生活中也有继承的例子，例如：小明继承了孙老师傅做拉面的手艺。继承就是一种延续、复用的方式。C++为了提高代码的可复用性，引入了继承机制，概念如下↓↓↓
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
继承的定义
定义格式
下图演示的继承的格式，其中Person是父类，也称作基类；Student是子类，也称作派生类。
下面给出代码示例（下面代码中，Student类继承父类Person）↓↓↓
#include <iostream>
using namespace std;
class Person
{
public:
void Show()
{
cout << _name << " " << _age << endl;
}
protected:
string _name = "jammingpro"; //姓名
int _age = 18; //年龄
};
class Student : public Person
{
private:
int _stuId;
};
int main()
{
Person p;
Student s;
p.Show();
s.Show();
return 0;
}
上面代码中，Student继承父类Person的成员（成员函数+成员变量）后，这些成员都变成了子类的一部分。这里的Student复用了Person的成员。通过监视窗口可以看到，Student中也有自己的_name、_age成员变量。
继承关系与访问限定符
在C++的继承机制中，包含3种继承方式及3种类访问限定符（如下图所示），下面将分别介绍它们。
我们在学习类和对象时，就已经接触过访问限定符。其中public成员可以在类外访问，而protected与private成员不能在类外访问。但这里的protected和private在继承时是有区别的：
●如果父类愿意让自己的成员被外界访问并愿意让子类继承，则定义为public的；
●如果父类希望自己的成员不被外界访问而愿意让子类继承，则需要定义为protected；
●如果父类不希望自己的成员被外界访问、被继承，则需要定义为private的。
父类中的访问限定符表示父类愿不愿意让子类继承，而继承方式则可以让子类缩小父类成员的访问权限，但不能放大父类成员的访问权限。
| 父类成员/子类继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| 父类的public成员 | 变为子类的public成员 | 变为子类protected成员 | 变为子类的private成员 |
| 父类的protected成员 | 变为子类的protected成员 | 变为子类的protected成员 | 变为子类的private成员 |
| 父类的private成员 | 子类不可见 | 子类不可见 | 子类不可见 |
总结
-
基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
都不能去访问它。 -
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
-
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式等于
Min{成员在基类的访问限定符，继承方式}，其中，public>protected>private。 -
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
-
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
针对于总结中的第一点，父类private成员实际上还是被子类继承了，只是子类无法访问，下面使用代码验证↓↓↓
#include <iostream>
using namespace std;
class Base
{
private:
int _base;
};
class Son : public Base
{}
int main()
{
Son s;
return 0;
}
基类和派生类对象赋值转换
●派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
下面给出代码示例↓↓↓
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{}
Person(const string& name, const char& sex, const int& age)
:_name(name)
,_sex(sex)
,_age(age)
{}
protected:
string _name;
char _sex;
int _age;
};
class Student : public Person
{
public:
Student(const string& name, const char& sex, const int& age, const int& stuId)
:Person(name, sex, age)
,_stuId(stuId)
{}
private:
int _stuId;
};
int main()
{
Student s("Jammingpro", 'M', 18, 123456);
Person p;
p=s;
return 0;
}
从监视窗口可以看到，Person对象保存了Student对象的父类成员部分，而舍弃了子类自有成员，这就是切片。
●基类对象不能赋值给派生类对象。（基类对象无法用于构造派生类对象，也无法使用派生类对象的拷贝赋值函数；但可以显示提供派生类赋值给基类的operator=实现）
★ps：由于派生类中的成员函数、成员对象一般情况下都会多于基类，如果基类直接赋值给派生类会导致部分成员数值不确定。因此，C++默认不提供基类赋值给派生类。
●基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针指向派生类对象时才是安全的。
下面代码演示了基类赋值给派生类指针，派生类赋值给基类指针↓↓↓
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{}
Person(const string& name, const char& sex, const int& age)
:_name(name)
, _sex(sex)
, _age(age)
{}
string _name;
char _sex;
int _age;
};
class Student : public Person
{
public:
Student(const string& name, const char& sex, const int& age, const int& stuId)
:Person(name, sex, age)
, _stuId(stuId)
{}
int _stuId;
};
int main()
{
Student s("Jammingpro", 'M', 18, 123456);
Person p("xiaoming", 'M', 20);
Person* p_s = &s;//安全
Student* s_p = (Student*) & p;//不安全
cout << s_p->_stuId << endl;
return 0;
}
为什么说，Student* s_p = (Student*) & p;是不安全的呢？由于Person对象中没有申请_stuId的空间，但在Student*类型看来，它认为它指向的对象有_stuId成员。如果用户访问了s_p->_stuId可能会因为内存非法访问而报错。
继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
- 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏（而不需要返回值相同，或是参数列表相同）。
- 注意在实际中在继承体系里面最好不要定义同名的成员。
下面给出派生类成员变量与基类成员变量同名的例子↓↓↓
下面代码中，由于Son类中的成员变量与Base类中的成员变量重名，构成了隐藏。如果使用Son s; cout << s._name << endl;，则只能访问到Son对象中的成员变量，而无法访问到父类中的_name成员变量。若需要访问父类的_name成员变量，则可以使用类型+类作用域符号::来访问，即s.Base::_name。
#include <iostream>
using namespace std;
class Base
{
public:
string _name = "Jammingpro";
};
class Son : public Base
{
public:
string _name = "xiaoming";
};
int main()
{
Son s;
cout << s._name << endl;
cout << s.Base::_name << endl;
return 0;
}
下面给出派生类成员函数与基类成员函数同名的例子↓↓↓这里与成员变量同名的情况相同，同名成员函数也会构成隐藏关系，如果需要访问父类的同名成员函数，需要使用类名+类作用域运算符::。
#include <iostream>
using namespace std;
class Base
{
public:
void Show()
{
cout << "I am _Base" << endl;
}
};
class Son : public Base
{
public:
void Show()
{
cout << "I am _Son" << endl;
}
};
int main()
{
Son s;
s.Show();
s.Base::Show();
return 0;
}
★( ఠൠఠ )ﾉtest：下面的两个同名函数（函数名相同，参数列表不同）分别属于基类和派生类，它们构成的关系是隐藏还是函数重载呢？
#include <iostream>
using namespace std;
class Base
{
public:
void print(char ch)
{
cout << "Base->" << ch << endl;
}
};
class Son : public Base
{
public:
void print(int num)
{
cout << "Son->" << num << endl;
}
};
int main()
{
Son s;
s.print('A');
return 0;
}
Base中的成员函数比Son中的成员函数更匹配（不需要隐式类型转换），而这里还是调用Son中的成员函数，说明两者构成的关系是隐藏，而不是函数重载。这里要注意：在继承关系中，派生类与基类只要存在同名函数（不管参数列表、返回值是否相同），都是隐藏关系。
派生类的默认成员函数
6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
基类提供默认构造函数的情况
派生类在构造时，会自动调用基类的构造函数↓↓↓
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "Base() is called" << endl;
}
};
class Son : public Base
{
public:
Son()
{
cout << "Son() is called" << endl;
}
};
int main()
{
Son s;
return 0;
}
基类没有提供默认构造函数的情况
基类没有提供默认构造时，子类必须在初始化参数列表中显示调用基类的构造函数，否则会报错。
#include <iostream>
using namespace std;
class Base
{
public:
Base(int b)
:_b(b)
{
cout << "Base(int b) is called" << endl;
}
private:
int _b
};
class Son : public Base
{
public:
Son(int b)
:Base(b)
{
cout << "Son() is called" << endl;
}
};
int main()
{
Son s(5);
return 0;
}
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
#include <iostream>
using namespace std;
class Base
{
public:
Base(int b)
:_b(b)
{}
Base(const Base& b)
{
_b = b._b;
cout << "Base(const Base& b) is called" << endl;
}
private:
int _b;
};
class Son : public Base
{
public:
Son(int s, int b)
:_s(s)
,Base(b)
{}
Son(const Son& s)
:Base(s)
{
_s = s._s;
cout << "Son(const Son& s) is called" << endl;
}
private:
int _s;
};
int main()
{
Son s(55, 66);
Son s2(s);
return 0;
}
如果我们将上面代码中显示调用基类构造函数的代码去掉，则会出现如下报错↓↓↓
★ps：对于上面的报错，虽然可以通过给基类提供默认构造函数解决，但却无法完成子类中的基类成员的拷贝操作。
- 派生类的operator=可以调用基类的operator=完成基类的复制，这样可以避免代码冗余（这里派生类调用基类的operator=不是必须的，只是因为基类已经实现了该操作，派生类不必再重复编写相同内容）。
下面代码演示了派生类调用基类operator=函数带来的代码简化↓↓↓
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class Person
{
public:
Person(const string& name, const int& age, const char& gender)
:_name(name)
,_age(age)
,_gender(gender)
{}
Person& operator=(const Person& p)
{
_name = p._name;
_age = p._age;
_gender = p._gender;
return *this;
}
void Show()
{
cout << "My name is " << _name << ", I am " << _age << " years old, I am a "
<< (_gender == 'M' ? " boy " : "girl") << endl;
}
private:
string _name;
int _age;
char _gender;
};
class Student : public Person
{
public:
Student(const string& name, const int& age, const char& gender, const char* detail)
:Person(name, age, gender)
{
_detail = new char[strlen(detail) + 1];
strcpy(_detail, detail);
}
Student& operator=(const Student& s)
{
Person::operator=(s);
char* detail = new char[strlen(s._detail)];
return *this;
}
void Show()
{
Person::Show();
cout << "My detail infomation is " << _detail << endl;
}
~Student()
{
delete[] _detail;
}
private:
char* _detail;
};
int main()
{
Student s("Jammingpro", 18, 'M', "He is good at coding");
Student copy = s;
s.Show();
}
-
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
-
派生类对象初始化先调用基类构造再调派生类构造。
下面代码演示了基类与派生类的构造与析构顺序↓↓↓
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "Base() is called" << endl;
}
~Base()
{
cout << "~Base() is deleted obj" << endl;
}
};
class Son : public Base
{
public:
Son()
{
cout << "Son is called" << endl;
}
~Son()
{
cout << "~Son() is deleted obj" << endl;
}
};
int main()
{
Son s;
return 0;
}
- 编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
★ps：关于virtual关键字将于多态中讲解
继承与友元
友元关系不能不继承，也就是说：基类的友元不能访问派生类的私有和保护成员。
下面代码演示了友元关系无法继承↓↓↓
#include <iostream>
using namespace std;
class Base
{
friend void print();
private:
int _base = 88;
};
class Son : Base
{
private:
int _son = 66;
};
void print()
{
Base b;
cout << b._base << endl;
Son s;
cout << s._son << endl;
}
int main()
{
print();
return 0;
}
继承与静态成员
基类定义了static静态成员，则整个继承体系中只能有一个这样的成员。无论派生出多少多少个子类，都只有一个static成员实例。
#include <iostream>
using namespace std;
class Base
{
public:
static int val;
};
//静态非const成员变量需要在类外初始化
int Base::val = 66;
class Son : public Base
{
};
class GrandSon : Son
{
};
int main()
{
cout << &Base::val << endl;
cout << &Son::val << endl;
cout << &GrandSon::val << endl;
return 0;
}
复杂的菱形继承及菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
下面是一份单继承的代码↓↓↓
#include <iostream>
using namespace std;
class Base
{
public:
void base_func()
{}
int _base;
};
class Son : public Base
{
public:
void son_func()
{}
int _son;
};
class GrandSon : public Son
{
public:
void gs_func()
{}
int _gs;
};
int main()
{
GrandSon gs;
cout << &gs << endl;
gs._base = 1;
cout << &gs._base << endl;
gs._son = 2;
cout << &gs._son << endl;
gs._gs = 3;
cout << &gs._gs << endl;
cout << "===================================" << endl;
Son s;
cout << &s << endl;
s._base = 1;
cout << &s._base << endl;
s._son = 2;
cout << &s._son << endl;
return 0;
}
上述代码调试时，通过监视窗口查看结果如下图所示。我们可以发现，GrandSon对象保存了其祖先类Son、Base的成员变量。Son对象保存了其基类成员变量。
下图为GrandSon对象的存储情况↓↓↓
通过分析上面的执行结果，可以得出如下结论：再单继承中，某个类的成员变量放置于类空间最后，该成员变量前放置的是直接父类，再往上是爷爷类，以此类推。类对象的地址，与最顶层的祖先的成员变量地址相同。
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
下面给出多继承的演示代码↓↓↓
#include <iostream>
using namespace std;
class Base1
{
public:
void base1_func()
{}
int _base1;
};
class Base2
{
public:
void base2_func()
{}
int _base2;
};
class Son : public Base1, public Base2
{
public:
void son_func()
{}
int _son;
};
int main()
{
Son s;
cout << &s << endl;
s._base1 = 1;
cout << &s._base1 << endl;
s._base2 = 2;
cout << &s._base2 << endl;
s._son = 3;
cout << &s._son << endl;
return 0;
}
如果Son先继承Base1再继承Base2，则会将Base1的成员变量放在前面，后继承的Base2的成员变量放在后面。
如果将Son先继承Base2，再继承Base1呢？
由上面的执行结果可知，先继承的基类的成员变量放置于类对象的前面位置，后即成的基类的成员变量放置于类对象的后面位置，类自身的成员变量放置于最后。
菱形继承：菱形继承是多继承的一种特殊情况
下面给出多继承的演示代码↓↓↓
#include <iostream>
using namespace std;
class Share
{
public:
void share_func()
{}
int _share;
};
class Base1 : Share
{
public:
void base1_func()
{}
int _base1;
};
class Base2 : Share
{
public:
void base2_func()
{}
int _base2;
};
class Son : public Base1, public Base2
{
public:
void son_func()
{}
int _son;
};
int main()
{
Son s;
s._base1 = 1;
s._base2 = 2;
s._son = 3;
return 0;
}
在上述代码的监视窗口可以看出菱形继承有数据冗余和二义性的问题。s中继承了两份Share类的成员变量_share。
C++中为了避免菱形继承导致的数据冗余和二义性，它引入了虚拟继承。虚拟继承可以解决菱形继承的二义性和数据冗余的问题。下面给出修改后的代码（引入虚拟继承的代码）↓↓↓
#include <iostream>
using namespace std;
class Share
{
public:
void share_func()
{}
int _share;
};
class Base1 : virtual public Share
{
public:
void base1_func()
{}
int _base1;
};
class Base2 : virtual public Share
{
public:
void base2_func()
{}
int _base2;
};
class Son : public Base1, public Base2
{
public:
void son_func()
{}
int _son;
};
int main()
{
Son s;
cout << &s << endl;
s._share = 0;
cout << &s._share << endl;
s._base1 = 1;
cout << &s._base1 << endl;
s._base2 = 2;
cout << &s._base2 << endl;
s._son = 3;
cout << &s._son << endl;
return 0;
}
这里是通过了两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的Share。
🎈欢迎进入浅尝C++专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d
