继承及其使用

最新推荐文章于 2025-12-01 13:12:33 发布

原创最新推荐文章于 2025-12-01 13:12:33 发布 · 673 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#c++

一、继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。

举例说明：

class Person //基类
{
public:
    void Print()
    {
        cout << "Print()" << endl;
    }
protected:
    string _name; 
    int _age; 
};
 
class Student : public Person //派生类
{
protected:
    int _stuid; 
};
 
class Teacher : public Person //派生类
{
protected:
    int _jobid; //工号
};

1.1意义

我们把公共的成员都放到Person类中，Student和teacher都继承Person，就可以复用Person成员，不需要重复定义了。

1.2定义

Person是基类，也称作父类。Student是派生类，也称作子类。

1.3继承方式

public、protected、private。

类成员/继承方式	public继承	protected继承	private继承
基类public成员	变为派生类public成员	派生类protected成员	派生类private成员
基类protected成员	派生类protected成员	派生类protected成员	派生类private成员
基类private成员	在派生类存在但不可见	在派生类存在但不可见	在派生类存在但不可见

表格总结：基类的私有成员在派生类都是不可见。基类的其他成员在派生类的访问方式==Min(成员在基类的访问限定符，继承方式)public>protected> private。

1. 基类private成员在派⽣类中无论以怎么继承都是不可见的。基类的私有成员被继承到了派生类对象中，但是语法上限制派生类对象不管在类里还是类外都不能去访问它。如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

2. 使用关键字class时默认的继承放式是private，使⽤struct时默认的继承放式是public，不过最好显式的写出继承方式。

3. 在实际运用中⼀般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

二、继承类模板的使用

#include<iostream>
#include<vector>
using namespace std;
namespace bit
{
	template<class T>
	class stack : public std::vector<T>
	{
	public:
		void push(const T& x)
		{
            //基类是类模板时，需要指定⼀下类域
			vector<T>::push_back(x);
		}
		//...
	};
}
int main()
{
	bit::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	return 0;
}

2.1注意

基类是类模板时，需要指定⼀下类域，否则入上例会编译报错:error C3861: “push_back”: 找不到标识符等，因为stack<int>实例化时，也实例化vector<int>了，但是模版是按需实例化，push_back等成员函数未实例化，所以找不到。

三、基类和派生类间的转换

3.1切片/切割

public继承的派生类可以通过切片（或者叫切割）赋值给基类的指针/引用。基类的指针/引用指向的是从派生类切割出来的基类部分。

//切片方式如图

3.2 拷贝构造赋值

派生类对象可以赋值给基类的对象，通过调用基类的拷贝构造完成

3.3强制类型转换

指向派生类类型对象的基类类型的指针/引用可以通强制类型转换赋值给派生类的指针/引用。

#include<iostream> 
using namespace std;
class Person
{
protected:
	string _name; 
	string _sex;
	int _age; 
};
class Student : public Person
{
public:
	int _No;
};
int main()
{
	Student sobj;
	// 1.派⽣类对象可以赋值给基类的指针/引⽤ 
	Person* pp = &sobj;
	Person& rp = sobj;
	

	//2.派⽣类对象可以赋值给基类的对象，通过调⽤基类的拷⻉构造完成
	Person pobj = sobj;

	//3.指向派生类类型对象的基类类型的指针/引用可以通强制类型转换赋值给派生类的指针/引用
	Student* ps = (Student*)pp;
	//不显式强制类型转换会报错
	//Student* ps = pp;

	return 0;
}

四、隐藏

基类和派生类都有独立的作用域。派生类和基类若有同名成员（同名函数即函数名相同），派生类讲屏蔽基类的同名成员，如要访问基类的同名成员，需要加类域即基类名。所以在实际应用中最好不要在继承体系中定义同名成员。

#include<iostream>
using namespace std;
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << i << endl;
	}
};
int main()
{
	B b;
	b.fun(10);
	//函数名相同构成隐藏，未指明作用域会编译报错
	//b.fun();
	b.A::fun();

	return 0;
};

五、派生类的成员函数

派生类的构造函数、拷贝构造函数、赋值重载函数、和析构函数都需要调用基类的相对应的成员函数，其中：

5.1派生类调用基类的成员函数方式

1.如果基类有默认构造函数则派生类的构造函数不需要显式调用（也可以显示调用）基类的默认构造函数，相反没有默认构造函数则必须显式调用构造函数。拷贝构造函数、赋值重载函数同理。

#include<iostream>
using namespace std;
class Base {
public:
    Base() { // 默认构造函数
        cout << "Base()" << endl;
    }
    // 其他成员函数和构造函数...
};

class Derived : public Base {
public:
    Derived() // 可以不显式调用Base的默认构造函数
    {
        // 编译器会自动调用Base的默认构造函数
        cout << "Derived()" << endl;
    }

    // 或者，为了清晰性，可以显式调用：
    Derived(int a) : Base() {
        cout << "Derived(int a) : Base()" << endl;
    }
    // 其他成员函数和构造函数...
};
int main() {
    Base b;
    Derived d;
    Derived d2(2);
}

2.当派生类赋值重载函数operator=（）需要显式调用基类的赋值重载函数时，注意两个函数因函数名相同导致隐藏基类的赋值重载函数，所以显式调用时需要写类域。

3.派生类的析构函数是自动调用基类的析构函数。

5.2派生类构造析构对象调用函数顺序

基类构造函数->派生类构造函数->派生类析构函数->基类析构函数

六、不能被继承的类

6.1私有化基类构造函数

基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。

6.2 c++11新增final关键字

final修饰基类，派生类就不能继承基类。写法如下：

class Base final{
    //...
};

七、继承与

7.1友元

友元关系不能继承。基类友元不能访问派生类私有和保护成员，除非基类友元也能成为派生类友元。

#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
    friend void Display(const Person& p, const Student& s); 
protected:
    string _name; 
};

class Student : public Person
{
public:
    //friend void Display(const Person& p, const Student& s); 
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;
    
    p._name = "John Doe"; // 仅为了示例，实际应用中应避免直接访问受保护成员
    s._stuNum = 12345;    // 仅为了示例
    // 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员 
    // 解决⽅案：Display也变成Student 的友元即可 
    Display(p, s);

    return 0;
}

7.2静态成员

继承体系内的static静态成员只有一个成员实例。

#include<iostream>
//#include<vector> 
using namespace std;
class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};
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;
}

八、多继承

8.1定义

单继承：⼀个派生类只有⼀个直接基类时称这个继承关系为单继承

多继承：⼀个派生类有两个或以上直接基类时称这个继承关系为多继承

菱形继承：结构如下图所示。菱形继承是多继承的一种特殊情况。由下例代码可见其有数据冗余和二义性的问题。指定类域可以解决二义性问题，但是无法解决数据冗余，不是长久之道。使用虚继承可以解决数据冗余和二义性。

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()
{
 // 编译报错：error C2385: 对“_name”的访问不明确 
 Assistant a;
 //a._name = "peter";
 // 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决 
 a.Student::_name = "xxx";
 a.Teacher::_name = "yyy";
 return 0;
}

8.2虚继承

虚继承在仅保留一份重复的实例数据副本的情况下，通过虚基类表（vbtable）来访问共享的实例数据

关于虚基类表的具体解释可以参考C++虚继承原理与类布局分析 - 千松 - 博客园，随便找的一个。

#include<iostream>
using namespace std;
class Person
{
public:
	string _name;
};
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 a;
	a._name = "peter";
	return 0;
}

九、继承和组合

继承适用于is-a的场景

class Animal {
public:
    void eat() {
        std::cout << "Animal is eating." << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog is barking." << std::endl;
    }
};

int main() {
    Dog dog;
    dog.eat(); // 输出 "Animal is eating."
    dog.bark(); // 输出 "Dog is barking."
    return 0;
}

组合适用于has-a的场景

class Engine {
public:
    void start() {
        std::cout << "Engine is starting." << std::endl;
    }
};

class Car {
private:
    Engine engine;
public:
    void start() {
        engine.start();
        std::cout << "Car is starting." << std::endl;
    }
};

int main() {
    Car car;
    car.start(); // 输出 "Engine is starting." 和 "Car is starting."
    return 0;
}

在is-a和has-a场景都适用时尽量使用组合。因为继承的耦合度高。在继承中，基类的内部细节对派生类可见。继承⼀定程度破坏了基类的封装基类的改变会对派生类照成影响。而对象组合的内部细节是不可见的，组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装。