C++继承
1、继承的概念和定义
现假设需要定义实现学生类和教师类，而学生类和教师类中既有相同的属性：姓名、身份证等，又有不同的属性：学生（学号、专业、宿舍号等），教师（工号、学院、职称等）。如果教师类和学生类中都声明一遍相同的属性当然是可以的，但是我们可以把他们共有的属性都定义在Person类中，然后通过继承的方式让学生类和教师类都有一份。
下面给出继承的概念和定义：
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
对于上面的例子，代码如下：
class Person
{
public:
Person(string name = "xxxx", int age = 0)
:_name(name)
, _age(age)
{}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name;
int _age;
};
class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
类的访问限定符有三种：public、protected、private，而protected和private在之前是没有区别的，但是在继承这里就不一样了。
继承方式有三种：public继承、protected继承、private继承
继承基类成员访问方式的变化：
总结：
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
2、基类和派生类间的转换
1、派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
2、基类对象不能赋值给派生类对象。
3、基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（这个我们后面再讲解，这里先了解一下）
class Person
{
public:
Person(string name = "xxxx", int age = 0)
:_name(name)
, _age(age)
{}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
//protected:
string _name;
int _age;
};
class Student : public Person
{
protected:
int _stuid; // 学号
};
int main()
{
// 赋值兼容转换(切割，切片)
Student s;
Person p = s; // 派生类对象可以赋值给基类
Person* rp = &s; // 指向子类中父类的那一部分
Person& ref = s; // ref是子类中父类那一部分的别名
rp->_name = "张三";
ref._name = "李四";
//s = p; // error, 基类对象不能赋值给派生类对象
return 0;
}
调试可以看到，rp和ref对成员变量_name的修改，s、rp、ref都会发生改变。
而且这里Peron& ref = s;并没有加const，说明没有产生临时对象。
而像上面的代码，必须是const常引用，因为产生了临时对象，如果不加const就是权限的放大。
3、继承中的作用域
1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。
来看下面这段代码：思考输出什么？
class Person
{
public:
void func()
{
cout << "Person::func()" << endl;
}
protected:
string _name = "张三";
int _num = 123;
};
class Student : public Person
{
public:
void func()
{
cout << "Student()" << endl;
}
void Print()
{
cout << "姓名:" << _name << endl;
cout << "num:" << _num << endl;
}
protected:
int _num = 456;
};
int main()
{
Student s;
s.func();
s.Print();
return 0;
}
可以看到，Student中有个func函数和Person中的func函数重名了，所以构成了隐藏/重定义。只要重名就构成隐藏/重定义。这里调用func调的是派生类中的func函数，并且Print中打印的也是派生类中_num的值。
那么如果我想调用基类中的func函数并且打印基类中的_num的值呢？
void Print()
{
cout << "姓名:" << _name << endl;
cout << "num:" << _num << endl;
cout << "Person::num:" << Person::_num << endl;
}
// 在main函数中，指定Person::域
s.Person::func();
隐藏/重定义：子类和父类有同名成员，子类的成员隐藏了父类。
下面来做一道题：
两个fun构成什么关系？ a、隐藏/重定义 b、重载 c、重写/覆盖 d、编译报错
class Person
{
public:
void func()
{
cout << "Person::func()" << endl;
}
protected:
string _name = "张三";
int _num = 123;
};
class Student : public Person
{
public:
void func(int i)
{
cout << "Student::func()" << endl;
}
void Print()
{
cout << " 姓名:" << _name << endl;
cout << _num << endl;
cout << Person::_num << endl;
}
protected:
int _num = 456;
};
int main()
{
Student s;
s.Person::func();
s.func(1);
return 0;
}
答案是a、隐藏/重定义。
对于c是后面的概念，后面会进行讲解。对于d并不会编译报错。
对于b：函数重载的概念是在同一个作用域的，因为同一作用域下如果函数同名，参数也相同的情况下，最后链接在符号表中两个函数的标识符是一样的无法区分，而如果参数列表不同，在符号表中的标识符也就不一样，可以区分。而如果在不同作用域，哪怕函数名相同，也是可以区分的，并不构成函数重载。这里的两个func函数是在不同的作用域的，一个在Student的类域中，另一个在Person的类域中，因为不在同一个作用域，所以不构成函数重载。而因为函数名相同，所以构成隐藏/重定义。
4、派生类的默认成员函数
1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
class Person
{
public:
Person(const char* name = "peter")
:_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 id = 0)
:Person(name)
,_id(id)
{}
protected:
int _id;
};
int main()
{
Student s;
return 0;
}
派生类如果不写构造函数，编译器会生成默认的构造函数，在初始化列表自动调用基类的默认构造函数，如果没有默认构造函数就会报错。如果我们写了派生类的构造函数，那么就必须在初始化列表显示调用基类的构造函数进行初始化，写法如上（不要问为什么，这是祖师爷定的）。也可以不显示调用，但是必须要有默认构造函数（你不调用就会自动调用默认构造函数，没有就报错）。
并且是先调用基类的构造函数初始化，然后才会走初始化列表去初始化派生类的成员变量。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
Student(const Student& s)
:Person(s)
, _id(s._id)
{}
派生类的拷贝构造函数我们不写编译器默认生成的，会自动去调用基类的拷贝构造函数。我们写了拷贝构造函数，就必须在初始化列表显示调用基类的拷贝构造函数完成拷贝工作。如果没有显示调用，会在初始化列表自动调用基类的构造函数，因为拷贝构造函数也是构造函数，没有默认构造函数就报错。
可以看到这里传给Person的拷贝构造函数参数是Student对象，所以这里是赋值兼容转换/切割/切片。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域。
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator=(s);
_id = s._id;
}
return *this;
}
赋值运算符重载函数我们不写编译器默认生成的，会自动调用基类的赋值运算符重载函数。我们写了，就不会自动调用，需要我们显示调用。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们多态章节会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。
~Student()
{
}
由于Student类中没有需要释放的资源，所以也可以不写。因为不论是编译器生成的，还是我们自己写的析构函数，会自动调用基类的析构函数。并且是先释放派生类资源，然后再调用基类析构函数释放基类的资源。所以我们不需要在派生类的析构函数中显示调用基类的析构函数。这样做的目的是为了保证先析构派生类，再析构基类，保证先子后父。
第七点需要注意一下，析构函数都被编译器统一处理成了destructor()，派生类和基类的析构函数构成隐藏/重定义。下一章多态会讲解。
下面是完整代码，和之前类和对象的六个默认成员函数有着异曲同工之妙，大家自行体会。
class Person
{
public:
Person(const char* name = "peter")
:_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 id = 0)
:Person(name)
,_id(id)
{}
Student(const Student& s)
:Person(s)
, _id(s._id)
{}
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator=(s);
_id = s._id;
}
return *this;
}
~Student()
{}
protected:
int _id;
};
int main()
{
Student s;
Student ss(s);
s = ss;
return 0;
}
拓展：实现一个不能被继承的类
有三种方法：
1、将基类的构造函数私有，派生类必须调用基类的构造函数，但是基类构造函数私有后，派生类就不能调用了，派生类就无法实例化出对象。——C++98方法
但是将构造函数私有后，无法创建出对象，所以需要提供一个函数CreateObj返回对象，但是要调用这个函数需要先有对象，所以要将CreateObj定义为静态成员函数。
class A
{
public:
static A CreateObj()
{
return A();
}
private:
A() {}
protected:
int _a = 1;
};
int main()
{
A a = A::CreateObj();
return 0;
}
2、将基类析构函数私有，这样就可以创建基类对象了，因为析构函数私有了，所以不能在栈上创建对象，需要在堆上开辟空间。由于delete=析构函数+operator delete。所以提供一个函数在类外调用清理资源，然后调用operator delete来释放空间。
class A
{
public:
void Destructor()
{
this->~A();
}
private:
~A() {}
protected:
int _a = 1;
};
int main()
{
A* p = new A();
p->Destructor();
operator delete(p);
return 0;
}
3、C++11新增加了一个final关键字，final修饰基类，该类就不能被继承。
class A final
{
protected:
int _a = 1;
};
5、继承与友元
友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。
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;
}
int main()
{
Person p;
Student s;
Display(p, s);
}
编译报错：无法访问 protected 成员(在“Student”类中声明)。
Display声明为Person类的友元函数，所以可以访问Person类的私有和保护成员变量，但是并不是Student类的友元函数，并不能访问Student类的私有和保护成员变量。由此可见，友元关系是不能继承的。解决方案：在Student类中声明Display为Student类的友元函数。
6、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例。
class Person
{
public:
Person() { ++_count; }
//protected:
string _name; // 姓名
public:
static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
int _stuNum; // 学号
};
int main()
{
Person p;
Student s;
Student s1;
Student s2;
cout << Person::_count << endl;
cout << &p._name << endl;
cout << &s._name << endl;
// 地址不同，s中继承的_name和父类中的_name不是同一个
// 静态成员继承的跟父类同一份
cout << &p._count << endl;
cout << &s._count << endl;
cout << &Person::_count << endl;
cout << &Student::_count << endl;
return 0;
}
运行结果如下：
静态成员变量继承后并不会拷贝一份，而是继承了使用权。静态成员变量同属于基类和派生类。
通过定义一个静态成员变量，在构造函数和拷贝构造函数中对该静态成员变量++，可以计算出该类及其派生类创建出了多少个对象。
7、多继承及其菱形继承问题
单继承：一个派生类只有一个直接基类时称这个继承关系为单继承
多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员放到最后面。
菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。
下面来看看菱形继承会存在什么问题：
class Person
{
public:
string _name;
int _age;
};
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 as;
as.Student::_age = 18;
as.Teacher::_age = 50;
//as._age = 20;
return 0;
}
调试看一下：
可以看到Student和Teacher中都有_name和_age，这样就造成了数据冗余。
将as._age = 20;代码取消注释编译后发现报错了，这里存在二义性，不知道是Teacher中的_age还是Student中的_age。
因此菱形继承会造成数据冗余和二义性。
解决办法如下：
使用虚继承，在Student类和Teacher类虚继承Person类。——菱形虚拟继承
class Person
{
public:
string _name;
int _age;
};
class Student : virtual public Person
{
protected:
int _num;
};
class Teacher : virtual public Person
{
protected:
int _id;
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
int main()
{
Assistant as;
as.Student::_age = 18;
as.Teacher::_age = 50;
as._age = 20;
return 0;
}
运行调试，可以看到对_age修改后，里面的_age都是一样，说明他们都是同一份_age。此时只有一份_age。
使用虚继承，可以解决数据冗余和二义性。
下面看一下菱形继承和菱形虚拟继承的对象模型：
首先给出菱形继承的代码
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;
};
调试后通过内存查看d对象的存储模型，再使用菱形虚拟继承继续调试查看d对象的存储模型，结果如下图：
当使用虚继承后，B和C的对象模型也会发生改变如下图：
如果用派生类的指针指向d，访问_a的话，会通过查找虚基表中的偏移量然后找到_a的存储位置。如果用基类的指针指向d，虽然指向的是基类的那一部分，但是访问_a也是通过寻找虚基表中的偏移量然后找到_a的。
下面来做两道题目：
多继承中指针偏移问题？下⾯说法正确的是()
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
return 0;
}
答案是C，先继承的就在上面，后继承的在下面，最后就是派生类的成员变量。
下面代码运行后输出什么？
class A {
public:
A(const char* s) { cout << s << endl; }
~A() {}
};
class B :virtual public A
{
public:
B(const char* sa, const char* sb) :A(sa) { cout << sb << endl; }
};
class C :virtual public A
{
public:
C(const char* sa, const char* sb) :A(sa) { cout << sb << endl; }
};
class D :public B, public C
{
public:
D(const char* sa, const char* sb, const char* sc, const char* sd)
:B(sa, sb), C(sa, sc), A(sa)
{
cout << sd << endl;
}
};
int main() {
D* p = new D("class A", "class B", "class C", "class D");
delete p;
return 0;
}
输出结果如图：
由于A类是在最上方的，所以先调用A类的构造函数，然后再调用B类的构造函数，最后调用C类的构造函数，然后走D类的构造函数体。
那么B类和C类中构造函数都有调用A类的构造函数，D类中的初始化列表还有必要显示调用A类的构造函数吗？——必须写，不写就会报错。
那么B类和C类中的构造函数初始化列表可以不显示调用A类的构造函数吗？——不可以，因为A类没有默认构造函数，所以必须显式调用初始化，不然报错。
库里面就使用菱形虚拟继承：
如图：istream继承于ios，ostream继承于ios，iostream继承于istream和ostream。
8、继承和组合
1、很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2、多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
3、继承和组合：
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
优先使用对象组合，而不是类继承 。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
扫一扫
2023
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
