C++ 继承

最新推荐文章于 2023-08-24 11:17:46 发布

爱吃红萝卜的小白兔

最新推荐文章于 2023-08-24 11:17:46 发布

阅读量533

点赞数

分类专栏： C++ 编程基础文章标签： c++ mfc 开发语言

本文链接：https://blog.csdn.net/cloud323/article/details/121136486

版权

C++ 编程基础专栏收录该内容

23 篇文章 3 订阅

订阅专栏

一、继承

1、继承相关概念

面向对象程序设计有4个主要特点：抽象、封装、继承和多态性。继承性是面向对象程序设计最重要的特征，面向对象技术强调软件的可重用性(software reusability)，通过继承机制可以很好的解决软件重用问题。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承类似，例如儿子继承父亲的财产。继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类 B 继承于类 A，那么 B 就拥有 A 的成员变量和成员函数。被继承的类称为父类或基类，继承的类称为子类或派生类。派生类除了拥有基类的成员，还可以定义自己的新成员，以增强类的功能。

使用继承带来的优点

面向对象编程的主要目的之一是提供可重用的代码，类继承提供了比修改源码更好的方法，不需要访问源码就可以派生出类。尤其是当项目比较庞大时，重用经过测试的代码比重新编写代码要好的多。
使用继承与多态机制，可以很方便的对系统的功能进行扩展。

2、继承方式

继承的一般语法为：

class 派生类名:［继承方式］ 基类名{
    派生类新增加的成员
};

继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。

不同的继承方式会影响基类成员在派生类中的访问权限，例如：

public继承

基类中所有 public 成员在派生类中为 public 属性
基类中所有 protected 成员在派生类中为 protected 属性
基类中所有 private 成员在派生类中不能使用

protected继承

基类中的所有 public 成员在派生类中为 protected 属性
基类中的所有 protected 成员在派生类中为 protected 属性
基类中的所有 private 成员在派生类中不能使用

private继承

基类中的所有 public 成员在派生类中均为 private 属性
基类中的所有 protected 成员在派生类中均为 private 属性
基类中的所有 private 成员在派生类中不能使用

注意：private与protected之间的区别只在派生类中才会体现出来。派生类的成员可以直接访问基类的保护成员，但不能访问基类的私有成员。

3、派生类与构造函数

基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数，类的构造函数不能被继承。构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数。

//基类People
class People{
protected:
    char *m_name;
    int m_age;
public:
    People(char*, int);
};
People::People(char *name, int age): m_name(name), m_age(age){}
//派生类Student
class Student: public People{
private:
    float m_score;
public:
    Student(char *name, int age, float score);
    void display();
};
//People(name, age)就是调用基类的构造函数
Student::Student(char *name, int age, float score): People(name, age), m_score(score){ }
void Student::display(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<"。"<<endl;
}

在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分类都有 private 属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。这种矛盾在C++继承中是普遍存在的，解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。在派生类构造函数中没有显示调用基类的构造函数，创建派生类对象时，将使用基类的默认构造函数，此时，如果基类没有默认构造函数将编译报错。因此，在创建派生类对象时先调用基类的构造函数，然后再调用派生类构造函数。

4、派生类与析构函数

和构造函数类似，析构函数也不能被继承。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需程序员干涉。另外析构函数的执行顺序和构造函数的执行顺序也刚好相反，即销毁派生类对象时，先执行派生类析构函数，再执行基类析构函数。

class A{
public:
    A(){cout<<"A constructor"<<endl;}
    ~A(){cout<<"A destructor"<<endl;}
};

class B: public A{
public:
    B(){cout<<"B constructor"<<endl;}
    ~B(){cout<<"B destructor"<<endl;}
};

int main(){
    B test;
    return 0;
}

// 输出结果
A constructor
B constructor
B destructor
A destructor

5，继承时的名字遮掩

如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名，那么就会遮蔽从基类继承过来的成员。所谓遮蔽，就是在派生类中使用该成员（包括在定义派生类时使用，也包括通过派生类对象访问该成员）时，实际上使用的是派生类新增的成员，而不是从基类继承来的。

//基类People
class People{
public:
    void show();
protected:
    char *m_name;
    int m_age;
};
void People::show(){
    cout<<"嗨，大家好，我叫"<<m_name<<"，今年"<<m_age<<"岁"<<endl;
}
//派生类Student
class Student: public People{
public:
    Student(char *name, int age, float score);
public:
    void show();  //遮蔽基类的show()
private:
    float m_score;
};
Student::Student(char *name, int age, float score){
    m_name = name;
    m_age = age;
    m_score = score;
}
void Student::show(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
int main(){
    Student stu("小明", 16, 90.5);
    //使用的是派生类新增的成员函数，而不是从基类继承的
    stu.show();
    //使用的是从基类继承来的成员函数
    stu.People::show();
    return 0;
}

6、基类成员函数和派生类成员函数不构成重载

基类成员和派生类成员的名字一样时会造成遮蔽，这句话对于成员变量很好理解，对于成员函数要引起注意，不管函数的参数如何，只要名字一样就会造成遮蔽。换句话说，基类成员函数和派生类成员函数不会构成重载，如果派生类有同名函数，那么就会遮蔽基类中的所有同名函数，不管它们的参数是否一样。下面的例子很好的说明了这一点：

#include<iostream>
using namespace std;
//基类Base
class Base{
public:
    void func();
    void func(int);
};
void Base::func(){ cout<<"Base::func()"<<endl; }
void Base::func(int a){ cout<<"Base::func(int)"<<endl; }
//派生类Derived
class Derived: public Base{
public:
    void func(char *);
    void func(bool);
};
void Derived::func(char *str){ cout<<"Derived::func(char *)"<<endl; }
void Derived::func(bool is){ cout<<"Derived::func(bool)"<<endl; }
int main(){
    Derived d;
    d.func("c.biancheng.net");
    d.func(true);
    d.func();  //compile error
    d.func(10);  //compile error
    d.Base::func();
    d.Base::func(100);
    return 0;
}

7、基类与派生类之间的关系

派生类对象包含一个基类对象实例
派生类对象可以使用基类的公有的方法
基类指针或引用在不进行显示转换的情况下指向派生类对象，但基类指针或引用只能调用基类方法
派生类对象是一个特殊的基类对象，任何使用基类对象的地方都可使用派生类对象替换

8、static成员变量与成员函数是否被派生类继承？

父类的static变量和函数在派生类中依然可用，但是受访问性控制（比如，父类的private域中的就不可访问），而且对static变量来说，派生类和父类中的static变量是共用空间的，通过下面的例子可以很好的证明。
static函数没有“虚函数”一说。因为static函数实际上是“加上了访问控制的全局函数”，全局函数哪来的什么虚函数？

#include<iostream>
using namespace std;
class A
{
public:
	static int num;
};
int A::num=100;

class B:public A
{
public:
	int i;
	B(int m):i(m)
	{}
};

//int B::num=200;
int main()
{
	A::num ++;
	B::num ++;

	cout << "A::num = " << A::num << endl;   // A::num = 102
	cout << "B::num = " << B::num << endl;   // B::num = 102

	return 0;
}

9、多继承

9.1、什么是多继承？

多继承场景一个派生类有多个基类，例如：

class Worker{
private:
    int age;
public:
    void show();
};

class Singer : public Worker{
private:
    int voice;
public:
    void show();
};

class Waiter : public Worker{
private:
    int panache;
public:
    void show();
};

class SingingWaiter : public Singer, public Waiter{
public:
    void show();
};

int main()
{
    cout << "Worker size = " << sizeof(Worker) << endl;
    cout << "Singer size = " << sizeof(Singer) << endl;
    cout << "Waiter size = " << sizeof(Waiter) << endl;
    cout << "SingingWaiter size =" << sizeof(SingingWaiter) << endl;

	return 0;
}

输出结果

Worker size = 4
Singer size = 8
Waiter size = 8
SingingWaiter size =16

Process returned 0 (0x0)   execution time : 0.045 s
Press any key to continue.

9.2、多继承带来的问题

多继承带来的两个主要问题是：一、从两个或更多基类那里继承同一个类的多个实例；二、从两个不同的基类继承同名方法。为了解决这些问题，需要使用一些新规则和不同的方法。

问题一：从两个或更多基类那里继承同一个类的多个实例

class SingingWaiter : public Singer, public Waiter

因为Singer与Waiter都继承了一个Worker组件，因此SingingWaiter将包含两个worker组件。此时，如果将派生类对象的地址赋给基类指针，将出现二义性

SingingWaiter obj;
Worker *p = &obj;

上面的这种赋值将把指针设置为派生类对象中的基类对象的地址，但obj对象中包含两个Worker对象，有两个地址可供选择，所以应使用类型转换来指定对象

SingingWaiter obj;
Worker *p1 = (Singer *)&obj;
Worker *p2 = (Waiter *)&obj;

问题二：从两个不同的基类继承同名方法

当不同的基类拥有同名方法时，可能导致函数调用的多义性。解决同名方法的二义性，常用两种方法：一、使用作用域解析运算符指明要调用的方法；二、重写派生类中的同名方法，并指明要调用的基类方法。

/* 重写派生类中的同名方法，并指明要调用的基类方法 */
class SingingWaiter : public Singer, public Waiter{
public:
    void show(){
        Singer::show();
        Waiter::show();
        cout << "I am SingingWaiter" << endl;
    }
};

/* 通过作用域解析运算符指明要调用的方法 */
SingingWaiter obj;
obj.Waiter::show();

9.3、虚基类

虚基类使得从多个类（它们的基类相同）派生出的对象只继承一个基类对象。例如：通过在类声明中使用关键字virtual、可以使Worker被用作Singer和Waiter的虚基类（virtual与public的次序无关紧要）

class Worker{
private:
    int age;
public:
    void show() {}
};

class Singer : virtual public Worker{
private:
    int voice;
public:
    void show() {}
};

class Waiter : virtual public Worker{
private:
    int panache;
public:
    void show() {}
};

class SingingWaiter : public Singer, public Waiter{
public:
    void show(){}
};

int main()
{
    cout << "Worker size = " << sizeof(Worker) << endl;
    cout << "Singer size = " << sizeof(Singer) << endl;
    cout << "Waiter size = " << sizeof(Waiter) << endl;
    cout << "SingingWaiter size =" << sizeof(SingingWaiter) << endl;

	return 0;
}

输出结果

Worker size = 4
Singer size = 12
Waiter size = 12
SingingWaiter size =20

Process returned 0 (0x0)   execution time : 0.013 s
Press any key to continue.

分析前面的输出结果

sizeof(Worker) = 4；Worker只有一个int类型的数据成员，占用四个字节
sizeof(Singer) = 12；Singer包含一个int类型数据成员，以及从Worker继承过来的一个int类型的成员，还有一个vptr指针（这个与虚函数里面的实现一样）
sizeof(Waiter) = 12；Waiter包含一个int类型数据成员，以及从Worker继承过来的一个int类型的成员，还有一个vptr指针（这个与虚函数里面的实现一样）
sizeof(SingingWaiter) = 20；SingingWaiter包含Worker、Singer、Waiter对象对应的int成员，以及从Singer与Waiter继承过来的两个vptr.