C++进阶——继承

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name, int age):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}
protected:string _name;int _age;
};// 派生类  :   继承方式   基类
// class A :  访问限定符 B { }          A继承自B
class Student : public Person 
{
public:Student(string name, int age, string school): Person(name, age), _school(school){}void printInfo() {Person::printInfo();cout << "学校：" << _school << endl;}
private:string _school;
};class Teacher : public Person 
{
public:Teacher(string name, int age, string subject): Person(name, age), _subject(subject){}void printInfo() {Person::printInfo();cout << "科目：" << _subject << endl;}
private:string _subject;
};

比如这份代码，Person类具有姓名和年龄的对象，而Student和Teacher都具有Person的特征，又具有其它另外的特性，所以我们可以让Student和Teacher继承Person，也就继承了Person的所有成员变量和成员函数，并且在原有的基础上扩展，形成了Student和Teacher类。

这样，Student和Teacher类就可以复用Person的成员，就不需要重复定义了，大大简化了我们的代码。

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name, int age):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}
protected:string _name;int _age;
};// 派生类  :   继承方式   基类
// class A :  访问限定符 B { }          A继承自B
class Student : public Person 
{
public:Student(string name, int age, string school): Person(name, age), _school(school){}void printInfo() {Person::printInfo();cout << "学校：" << _school << endl;// 如果Person类中_name为私有，编译就会报错，因为私有成员只能在类内部访问，不能在派生类中访问// 如果想在派生类中访问私有成员，可以用protected关键字修饰//cout << Person::_name << endl;}
private:string _school;
};class Teacher : public Person 
{
public:Teacher(string name, int age, string subject): Person(name, age), _subject(subject){}void printInfo() {Person::printInfo();cout << "科目：" << _subject << endl;}
private:string _subject;
};

结合新增的注释可以再重新理解一下之前的代码。

另外还需要注意的是：使用class关键字默认的继承方式为private继承，struct则为public继承，不过还是最好显示写出继承方式。

三、继承类模板

举个实现栈的例子，自然秒懂！

#include <iostream>
#include <vector>
#include <list>
using namespace std;#define CONTAINER vectornamespace muss
{template<typename T>class stack : public CONTAINER<T>{public:void push(const T& x){// 基类是类模板时，需要指定⼀下类域，// 否则编译报错:error C3861: “push_back”: 找不到标识符// 因为stack<int>实例化时，也实例化vector<int>了// 但是模版是按需实例化，在需要调用stack的push时，才会实例化出push// 但是push中的所用容器的 push_back 却没有实例化，所以编译报错CONTAINER<T>::push_back(x);//push_back(x);}void pop(){CONTAINER<T>::pop_back();}const T& top(){return CONTAINER<T>::back();}bool empty(){return CONTAINER<T>::empty();}};
}int main()
{muss::stack<int> st;st.push(1);st.push(2);st.push(3);while (!st.empty()){cout << st.top() << " ";st.pop();}return 0;
}

四、隐藏

1. 在继承体系中基类和派生类都有独立的作用域。

2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。

（在派生类成员函数中，可以使用基类::基类成员显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

看之前的代码来理解：

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name, int age):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}
protected:string _name;int _age;
};class Student : public Person
{
public:Student(string name, int age, string school): Person(name, age), _school(school), _name(name)     // 初始化Student的_name变量，与Person类中的_name构成隐藏// 当然这里的举例不是很清楚，因为传参导致了两个_name变量内容相同{}// 同名函数，与Person类中的printInfo()构成隐藏// 在Student对象中调用时，编译器会优先调用Student的printInfo()函数void printInfo(){Person::printInfo();cout << "学校：" << _school << endl;}
private:// 同名变量，与Person类中的_name构成隐藏// 在Student对象中调用时，编译器会优先调用Student的_name变量string _name;string _school;
};class Teacher : public Person
{
public:Teacher(string name, int age, string subject): Person(name, age), _subject(subject){}void printInfo(){Person::printInfo();cout << "科目：" << _subject << endl;}
private:string _subject;
};int main()
{Person p("张三", 20);p.printInfo();Student s("muss", 19, "西南石油大学");// 这里为什么会调用Student的printInfo()函数而不是Person的printInfo()函数// 原因就是Student和Person都有printInfo()函数，在Student对象中调用时，编译器会优先调用Student的printInfo()函数// 如果想调用Person的printInfo()函数，就需要指定作用域，比如Person::printInfo()s.printInfo();s.Person::printInfo();Teacher t("t老师", 30, "C++");t.printInfo();return 0;
}

五、派生类的默认成员函数

派生类继承自基类，那么派生类的构造函数都需要做哪些事情呢？

其实，我们可以把基类当成自定义类型，而派生类种就有一个此种自定义类型。

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name, int age):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}
protected:string _name;int _age;
};// 其实，这里的拷贝构造，赋值运算符重载，析构函数
// 因为Person类这个”自定义类型“中没有资源需要释放，编译器默认生成的就够用
// 如果有需要显示释放的资源，就需要自己写
// 不过为了演示还是写了出来
class Student : public Person
{
public:// 构造函数Student(string name = "muss", int age = 19, string school = "西南石油大学")// 处理基类这个“自定义类型”的方式：在初始化列表显示调用基类的构造函数：基类名（参数...）// 其实这个形式类似于匿名对象的创建，大家可以这么记忆: Person(name, age), _school(school){}// 拷贝构造函数Student(const Student& s)// 跟自定义类型一样，在初始化列表显示调用基类的拷贝构造: Person(s._name, s._age), _school(s._school){}// 赋值运算符重载Student& operator=(const Student& s){if (this != &s){// 两个赋值运算符重载构成隐藏，所以需要显示调用基类的赋值运算符// 这里必须调用基类的赋值运算符，否则如果有自定义类型很容易造成浅拷贝，养成习惯Person::operator =(s);_school = s._school;}return *this;}// 析构函数~Student(){// 没有资源需要释放，所以不用写什么// 这里不需要显示调用基类的析构函数，编译器会在Student的析构函数结束后自动调用Person的析构函数}void printInfo(){Person::printInfo();cout << "学校：" << _school << endl;}
private:string _school;
};class Teacher : public Person
{
public:Teacher(string name, int age, string subject): Person(name, age), _subject(subject){}void printInfo(){Person::printInfo();cout << "科目：" << _subject << endl;}
private:string _subject;
};int main()
{Student s("muss", 19, "西南石油大学");s.printInfo();Student s2(s);s2.printInfo();Student s3;s3 = s;s3.printInfo();return 0;
}

有一些需要注意的点：

1. 派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显示调用。

2. 派⽣类的拷贝构造函数必须调⽤基类的拷贝构造完成基类的拷贝初始化。

3. 派⽣类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派⽣类的operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域

4. 派⽣类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。

5. 派⽣类对象初始化先调⽤基类构造再调派⽣类构造。

6. 派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。

六、切片——基类和派生类的转换

• public继承的派生类对象可以赋值给基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切

割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派⽣类中切出来的基类那部分。

• 基类对象不能赋值给派⽣类对象。

代码演示：

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name, int age):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}void setName(string name){_name = name;}protected:string _name;int _age;
};class Student : public Person 
{
public:Student(string name = "muss", int age = 19, string school = "西南石油大学"): Person(name, age), _school(school){}void printInfo() {Person::printInfo();cout << "学校：" << _school << endl;}
private:string _school;
};int main() 
{Student sobj;// 1.派⽣类对象可以赋值给基类的指针/引⽤Person* pp = &sobj;Person& rp = sobj;// 派生类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的Person pobj = sobj;//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错//sobj = pobj;sobj.printInfo();pp->printInfo();rp.printInfo();pobj.printInfo();// rp由于是引用，所以rp的修改也会修改sobjrp.setName("李四");sobj.printInfo();rp.printInfo();return 0;
}

七、实现一个不能被继承的类

方法有二：

1.基类构造函数私有：这样派生类就不能调用基类的构造函数来构造派生类对象了，但其实这种方法也可以继承，只是在派生类实例化的时候才会报错。

2.final关键字：C++11新增了final关键字，final修饰的基类不能被派生类继承，如果继承了，在编译阶段就会报错，所以这种方式会更常用一点。

#include <iostream>
using namespace std;// C++11的⽅法
class Base final
{
protected:int a = 1;
private:// C++98的⽅法：私有构造函数/*Base(){}*/
};// 继承了final修饰的基类在编译阶段就会报错
class Derive :public Base
{
protected:int b = 2;
};
int main()
{Base b;Derive d;return 0;
}

#include <iostream>
using namespace std;// 定义一个Person类，再定义一个Student类和Teacher类，继承自Person类
class Person
{
public:Person(string name = "lisi", int age = 30):_name(name), _age(age){}void printInfo(){cout << "姓名：" << _name << endl;cout << "年龄：" << _age << endl;}string _name;int _age;static int _count;
};int Person::_count = 0;class Student : public Person 
{
public:Student(string name = "muss", int age = 19, string school = "西南石油大学"): Person(name, age), _school(school){}void printInfo() {Person::printInfo();cout << "学校：" << _school << endl;}
private:string _school;
};int main()
{Person p;Student s;// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份cout << &p._name << endl;cout << &s._name << endl;// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的// 说明派⽣类和基类共⽤同⼀份静态成员cout << &p._count << endl;cout << &s._count << endl;// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员// 当然通常情况下，静态成员我们通过类名来访问，而不是通过对象来访问cout << Person::_count << endl;cout << Student::_count << endl;return 0;}