C++学习笔记“类和对象”：继承；

最新推荐文章于 2024-07-16 10:12:41 发布

小黄酥

最新推荐文章于 2024-07-16 10:12:41 发布

阅读量653

点赞数 24

分类专栏： C++ 文章标签： c++ 学习笔记 visual studio c语言

本文链接：https://blog.csdn.net/qq_50259950/article/details/139399134

版权

C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

4.6 继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系

4.6.1 继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚公共的左侧列表，只有中心内容不同接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

#include <string>
#include <iostream>
using namespace std;

// 继承的基本语法

// 继承实现页面
// 公共页面
class BasePage {
public:
    void header() {
        cout << "首页、公开课看、登录、注册.....（公共头部）" << endl;
    }
    void footer() {
        cout << "帮助中心、交流合作、站内地图.....（公共底部）" << endl;
    }
    void left() {
        cout << "Java、Python、C++、PHP.....（公共页面左侧）" << endl;
    }
};

// 继承的好处：减少代码的冗余
// 语法：class 子类 : （继承方式）public 父类 {}
// 继承方式：public（公有继承）、protected（保护继承）、private（私有继承）
// 子类：也称为 派生类
// 父类：也称为 基类

// Java页面
class JavaPage : public BasePage {
public:
    void content() {
        cout << "Java学科视频....（Java页面主体部分）" << endl;
    }
};

// Python页面
class PythonPage : public BasePage {
public:
    void content() {
        cout << "Python学科视频....（Python页面主体部分）" << endl;
    }
};

// C++页面
class CppPage : public BasePage {
public:
    void content() {
        cout << "C++学科视频....（C++页面主体部分）" << endl;
    }
};

void test01() {
    cout << "Java下载视频页面如下：" << endl;
    JavaPage jp;
    jp.header();
    jp.footer();
    jp.left();
    jp.content();
    cout << "-------------------------------" << endl;
    cout << "Python下载视频页面如下：" << endl;
    PythonPage pp;
    pp.header();
    pp.footer();
    pp.left();
    pp.content();
    cout << "-------------------------------" << endl;
    cout << "C++下载视频页面如下：" << endl;
    CppPage cp;
    cp.header();
    cp.footer();
    cp.left();
    cp.content();
    cout << "-------------------------------" << endl;
}

int main() {
    test01();
    return 0;
}

总结:
继承的好处:可以减少重复的代码；

class A : public B;
A 类称为子类或派生类
B 类称为父类或甚类
派生类中的成员，包含两大部分

类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性

4.6.2 继承方式

语法：class 子类 : 继承方式父类

继承方式：public（公有继承）、protected（保护继承）、private（私有继承）

#include <iostream>
using namespace std;

// 继承方式

// 1. 公共继承
class Base1 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son_1 : public Base1 {
public:
    void func() {
        m_A = 10;// 父类的公共成员在子类中仍然为公共成员
        m_B = 10;// 父类的保护成员在子类中仍然为保护成员
        // m_C = 10;  // 父类的私有成员，子类不可访问
    }
};

void test_1() {
    Son_1 s1;
    s1.m_A = 100;
    //s1.m_B = 100;// 在Son_1中为保护成员，类外不可访问
}

// 2. 保护继承
class Base2 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son_2 : protected Base2 {
public:
    void func() {
        m_A = 10;// 父类的公共成员在子类中变为保护成员
        m_B = 10;// 父类的保护成员在子类中变为保护成员
        // m_C = 10;  // 父类的私有成员，子类不可访问
    }
};

void test_2() {
    Son_2 s2;
    //s2.m_A = 100;// 在Son_2中为保护成员，类外不可访问
    //s2.m_B = 100;// 在Son_2中为保护成员，类外不可访问
}

// 3. 私有继承
class Base3 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son_3 : private Base3 {
public:
    void func() {
        m_A = 10;// 父类的公共成员在子类中变为私有成员
        m_B = 10;// 父类的保护成员在子类中变为私有成员
        // m_C = 10;  // 父类的私有成员，子类不可访问
    }
};

void test_3() {
    Son_3 s3;
    //s3.m_A = 100;// 在Son_3中为私有成员，类外不可访问
    //s3.m_B = 100;// 在Son_3中为私有成员，类外不可访问
}

int main() {
    test_1();
    test_2();
    test_3();
    return 0;
}

4.6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中?

示例：

#include <iostream>
using namespace std;

// 继承中的对象模型

class Base {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son : public Base {
public:
    int m_D;
};

// 利用开发人员命令提示窗口测试，查看继承中对象模型
// 跳转盘符 D:
// cd D:\C++\C++_Primer_Plus\10_继承
// 查看命名
// >cl /d1 reportSingleClassLayout类名  文件名.cpp

void test01() {
    Son s1;
    // 父类中所有非静态成员属性都会被子类继承下去
    // 父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
    cout << "size of s1 = " << sizeof(s1) << endl;// size of s1 = 16
}

int main() {
    test01();
    return 0;
}

结论: 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

4.6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题:父类和子类的构造和析构顺序是谁先谁后?

示例:

#include <iostream>
using namespace std;

// 继承中构造和析构顺序 

class Base {
public:
    Base() {
        cout << "Base constructor = Base构造函数" << endl;
    }
    ~Base() {
        cout << "Base destructor = Base析构函数" << endl;
    }
};

class Son : public Base {
public:
    Son() {
        cout << "Son constructor = Son构造函数" << endl;
    }   
    ~Son() {
        cout << "Son destructor = Son析构函数" << endl;
    }
};

void test01() { 
    // 继承中构造和析构顺序
    // 父类构造 子类构造 子类析构 父类析构
    Son s;
}

int main() {
    test01();
    return 0;
}

总结:继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承同名成员处理方式

问题:当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢?

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例

#include <iostream>
using namespace std;

// 继承同名成员处理方式

class Base {
public:
	Base() { m_A = 100; }// 基类构造函数
	int m_A;

	void func() { cout << "Base func 调用" << endl; }
	void func(int a) { cout << "Base func(int a) 调用" << endl; }
};

class Derived : public Base {
public:
	Derived() { m_A = 200; }// 继承同名成员
	void func() { cout << "Derived func 调用" << endl; }
	int m_A;
};

// 同名成员变量处理
void test() {
	Derived d;
	cout << "Derived d.m_A = " << d.m_A << endl;// 输出 200
	// 如果通过子类对象访问父类同名成员，需要通过加上作用域限定符Base::m_A来访问
	cout << "Derived d.m_A = " << d.Base::m_A << endl;// 输出 100
}

// 同名成员函数处理
void test2() {
	Derived d;
	d.func(); // 调用 Derived 类中的 func 函数
	// 注意：如果通过子类对象调用父类同名成员函数，需要通过加上作用域限定符Base::来调用
	d.Base::func(); // 调用 Base 类中的 func 函数

	// 如果子类中定义了与父类同名的成员函数，则会覆盖父类中的同名成员函数
	// 因此，如果需要调用父类中的同名成员函数，需要通过作用域限定符 Base:: 来调用
	d.Base::func(100); // 调用 Base 类中的 func 函数
}

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

总结:
1.子类对象可以直接访问到子类中同名成员
2.子类对象加作用域可以访问到父类同名成员
3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

4.6.6 继承同名静态成员处理方式

问题:继承中同名的静态成员在子类对象上如何进行访问?

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

示例:

#include <iostream>
using namespace std;

// 继承同名静态成员处理方式


class Base {
public:
    static int m_A;

    static void func() { cout << "Base static void func()" << endl; }
};

int Base::m_A = 10;// 静态成员初始化

class Derived : public Base {
public:
    static int m_A;

    static void func() { cout << "Derived static void func()" << endl; }
};

int Derived::m_A = 20;// 静态成员初始化

// 同名静态成员属性
void test() {
    //1、通过对象访问
    cout << "通过对象访问" << endl;
    Derived d;
    cout << "d.m_A = " << d.m_A << endl; // 输出 20
    cout << "Base::m_A = " << d.Base::m_A << endl; // 输出 10

    //2、通过类名访问
    cout << "通过类名访问" << endl;
    cout << "Base::m_A = " << Base::m_A << endl; // 输出 10
    //cout << "Derived::m_A = " << Derived::m_A << endl; // 输出 20
    // 第一个Derived::通过类名访问，第二个Base::m_A访问父类的静态成员，所以输出10
    cout << "Derived::Base::m_A = " << Derived::Base::m_A << endl; // 输出 10
}

// 同名静态成员函数
void test2() {
    //1、通过对象访问
    cout << "通过对象访问" << endl;
    Derived d;
    d.func(); // 输出 Derived static void func()
    d.Base::func(); // 输出 Base static void func()

    //2、通过类名访问
    cout << "通过类名访问" << endl;
    Base::func(); // 输出 Base static void func()
    Derived::func(); // 输出 Derived static void func()
    // 第一个Derived::通过类名访问，第二个Base::m_A访问父类的静态HS函数
    Derived::Base::func(); // 输出 Base static void func()

    // 注意：如果子类和父类都有同名静态成员函数，则子类的静态成员函数会覆盖父类的静态成员函数
    // 如果访问父类同名成员，需要通过父类名加上作用域运算符来访问
}

int main() {
    test();
    test2();

    return 0;
}

总结:同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式(通过对象和通过类名)

4.6.7 多继承语法

C++允许一个类继承多个类

语法:class 子类:继承方式父类1，继承方式父类2....

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

示例

#include <iostream>
using namespace std;

// 多继承语法
class Base_1 {
public:
	Base_1() { m_base1 = 10;  }
	int m_base1;
};

class Base_2 {
public:
	Base_2() { m_base2 = 20;  }
	int m_base2;
};

class Derived : public Base_1, public Base_2 {
public:
	Derived() { m_derived = 30; }
	int m_derived;
};

void test() {
	// 当父类有相同的成员变量时，需要通过作用域解区分
	Derived d;
	cout << "Base_1::m_base1 = " << d.Base_1::m_base1 << endl;// 输出 10
	cout << "Base_2::m_base2 = " << d.Base_2::m_base2 << endl;// 输出 20
	cout << "m_derived = " << d.m_derived << endl;// 输出 30
}

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

总结:多继承中如果父类中出现了同名情况，子类使用时候要加作用域

4.6.8 菱形继承

菱形继承概念:

两个派生类继承同一个甚类

又有某个类同时继承者两个派生类

这种继承被称为姜形继承，或者钻石继承

典型的菱形继承案例

菱形继承问题:

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以

#include <iostream>
using namespace std;

// 菱形继承
// 动物类
class Animal {
public:
    int m_Age;
};
// 利用虚继承，解决菱形继承的问题
// 继承之前，加上virtual关键字，变为虚继承
// Animal类变为虚基类
// 羊类
class Sheep : virtual public Animal { };

// 驼类
class Horse : virtual public Animal { };

// 羊驼类
class SheepHorse : public Sheep, public Horse { };

// 测试
void test() {
    SheepHorse sh;
    // 访问父类成员；菱形继承，多个父类拥有相同数据，需要加作用域区分
    sh.Sheep::m_Age = 10;
    sh.Horse::m_Age = 20;
    cout << "Sheep age: " << sh.Sheep::m_Age << endl;
    cout << "Horse age: " << sh.Horse::m_Age << endl;
    cout << "Total age: " << sh.m_Age << endl;
    // 菱形继承导致数据多份，资源浪费，尽量避免
}

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