C++进阶 —— 继承

原创已于 2025-11-27 19:30:41 修改 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++

于 2021-12-04 22:11:05 首次发布

编程语言同时被 2 个专栏收录

71 篇文章

订阅专栏

C++

38 篇文章

订阅专栏

本文深入探讨了C++中的继承机制，包括继承的概念、定义格式、成员访问权限、基类与派生类对象赋值转换、作用域规则、默认成员函数、继承与友元、静态成员以及复杂的菱形继承和虚拟继承。强调了继承在代码复用和层次结构中的重要性，同时也提到了继承可能带来的问题，如数据冗余和二义性，并建议在设计时优先考虑对象组合。

一，继承概念及定义

继承机制是面向对象程序设计是代码复用的最重要手段，呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程；
以前接触的复用都是函数复用，继承是类设计层次的复用，是类与类之间的关系；
被继承的类称为父类或基类，继承的类称为子类或派生类；
派生类是在保持原有类特性的基础上进行扩展，增加功能，产生的新类，可获取父类的成员变量和成员函数；

class Person
{
protected:
	string _name = "peter";
	int _age = 20;
};

class Teacher :public Person
{
public:
	void print()
	{
		cout << "child teacher class" << endl;
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
		cout << "jobid:" << _jobid << endl;
	}
private:
	int _jobid = 123;
};

class Stu :public Person
{
public:
	void print()
	{
		cout << "child stu class" << endl;
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
		cout << "jobid:" << _stuid << endl;
	}
private:
	int _stuid = 456;
};

int main()
{
	Teacher teacher;
	teacher.print();

	Stu stu;
	stu.print();
	return 0;
}

定义格式

//继承方式：public、private、protected，不写默认为private;
class 派生名：[继承方式] 基类名 
{
    派生类新增加成员;
}

基类成员继承后的访问方式

基类的private成员，无论什么继承方式派生类中均不可见；不可见是指基类的private成员还是继承到派生类中，只是限制派生类对象访问(不管是类内还是类外访问)；
private成员在派生类中是不可被访问的，如基类成员不想在类外被直接访问，但想在派生类中被访问，可将成员定义为protected，可看出protected成员限定符是因继承才出现的；
基类成员在派生类中的访问方式 = min(基类访问限定符，继承方式)，public>protected>private；
关键字class默认的继承方式为private，关键字struct默认的继承方式为public，建议最好显示的写出继承方式；
实际应用中，一般使用public继承，很少使用protected、private继承，也不提倡使用；因为protected、private继承下来的成员都只能在派生类的类里面使用，扩展维护性不强；

二，基类和派生类对象赋值转换

派生类对象可赋值给基类对象/基类指针/基类引用；形象的称为切片或切割，即把派生类中父类那部分切来赋值过去；
基类对象不可赋值给派生类对象；
基类指针可通过强制类型转换赋值给派生类指针；但必须是基类的指针是指向派生类对象时才是安全的；如基类是多态类型，可使用RTTI(Run-Time Type Information)的dynamic_cast来进行识别后进行安全转换；

//子类切片
基类对象 = 子类对象;
基类指针 = 子类指针;
基类引用 = 子类引用;

//基类对象不可赋值给子类对象
子类对象 = 基类对象; //报错

//dynamic_cast进行安全转换检查，基类需有虚函数
Teacher* pt = dynamic_cast<Teacher*>(&person); //转换失败，返回nullptr
Teacher& rt = dynamic_cast<Teacher&>(person); //转换失败，抛std::bad_cast异常

class Person
{
protected:
	string _name = "peter";
	int _age = 20;
};

class Teacher :public Person
{
public:
	Teacher(){
		_name = "zhansan";
		_age = 18;
	}
public:
	int _jobid = 123;
};

int main()
{
	Teacher teacher;
	//派生类可赋值给基类对象、指针、引用
	Person person = teacher;
	Person* pperson = &teacher;
	Person& rperson = teacher;

	//基类对象不可赋值给派生类
	//teacher = person;
	
	//基类的指针可通过强制类型转换赋值给派生类指针
	Teacher* pteacher = (Teacher*)pperson; //pperson指向的是派生类对象
	pteacher->_jobid = 100;

	Person person1;
	Teacher* pteacher1 = (Teacher*)&person1; //存在越界访问
	//pteacher1->_jobid = 100; //报错
	return 0;
}

class Animal {
public:  
    virtual string type() const { return "Animal"; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    string type() const override { return "Dog"; }
    void bark() { cout << "汪汪！" << endl; }
};

class Cat : public Animal {
public:
    string type() const override { return "Cat"; }
    void meow() { cout << "喵喵！" << endl; }
};

//用于不确定类型的探索性转换
void processAnimal(Animal* animal) {
    cout << "动物类型: " << animal->type() << endl;
    if (Dog* dog = dynamic_cast<Dog*>(animal)) {
        cout << "这是一只狗: ";
        dog->bark();
    }
    else if (Cat* cat = dynamic_cast<Cat*>(animal)) {
        cout << "这是一只猫: ";
        cat->meow();
    }
    else {
        cout << "未知动物类型" << endl;
    }
    cout << endl;
}

//用于确定类型的强制性转换
void processAnimal(Animal& animal) {
    cout << "动物类型: " << animal.type() << endl;
    try{
        Dog& dog = dynamic_cast<Dog&>(animal);
        cout << "这是一只狗: ";
        dog.bark();
    }
    catch(const std::bad_cast&){
        cout << "这不是一只狗;" << endl;
    }

    try {
        Cat& cat = dynamic_cast<Cat&>(animal);
        cout << "这是一只猫: ";
        cat.meow();
    }
    catch (const std::bad_cast&) {
        cout << "这不是一只猫;" << endl;
    }
    cout << endl;
}

int main(){
    Animal ani;
    Dog dog;
    Cat cat;

    processAnimal(&ani);
    processAnimal(&dog);
    processAnimal(&cat);

    processAnimal(ani);
    processAnimal(dog);
    processAnimal(cat);    
	return 0;
}

三，继承中的作用域

在继承体系中，基类和派生类都有独立的作用域；
有同名成员时，子类成员将屏蔽父类对同名成员的直接访问，即隐藏，也叫重定义；在子类成员函数中，可使用显式访问(基类::基类成员)；
注意如成员函数，只要函数同名就构成隐藏，可使用显示调用(基类::基类成员函数)；
在实际中继承体系里最好不要定义同名成员；

//子类成员_name构成隐藏
class Person
{
protected:
	string _name = "peter";
	int _age = 20;
};

class Teacher :public Person
{
public:
	void print(){cout << Person::_name << endl;} //显式访问基类成员
public:
	string _name = "zhansan"; //与基类成员同名，基类成员被屏蔽
	int _jobid = 123;
};

//father中的fun和child中的fun不构成重载，因为不在一个作用域
//father中的fun和child中的fun构成隐藏，成员函数满足函数名相同就构成隐藏
class father
{
public:
	void fun(){cout << "fun()" << endl;}
protected:
	int _a = 1;
};

class child :public father
{
public:
    //与父类同名函数构成隐藏
	void fun(int i = 0){cout << "fun(i)" << endl;}
public:
	int _b = 10;
};