【C++实战二】继承和多态初体验

最新推荐文章于 2024-07-12 10:45:15 发布
最新推荐文章于 2024-07-12 10:45:15 发布
阅读量453 收藏
点赞数
文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45603919/article/details/121134209
版权

文章目录

【C++实战二】继承和多态初体验

1. 继承访问权限测试

继承的作用：当我们创建一个类时，不一定需要重新定义新的成员函数或变量，可以指定新建的类继承已有类的成员。这种模式使得创建和维护程序变得容易，且提高编码效率。（这里的已有类称为基类，继承类称为派生类）

C++的三种继承方式：public，protected，private

接下来我们就通过代码验证不同继承下的访问权限。

1.1 public继承

#include<iostream>
using namespace std;

// 创建一个基类
class One
{
// 基类的私有变量
private:
    void test1()
    {
        cout << "My name is One's Praivate." << endl;
    }
// 基类的保护变量
protected:
    void test2()
    {
        cout << "My name is One's Protected." << endl;
    }
// 基类的公共变量
public:
    void test3()
    {
        cout << "My name is One's Public." << endl;
    }
};

// 基类的派生类（公共继承）
class Two:public One
{
public:
    void two_func()
    {
        test2();
        test3();
    }
};

// 基类的派生类的派生类（公共继承）
class Three:public Two
{
public:
    void three_func()
    {
        test2();
        test3();
    }
};

int main()
{
    One one;
    one.test3();
    cout << "------------" << endl;

    Two two;
    //two.test1(); // ERROR: public继承下，派生类对象不可以访问基类的private成员
    //two.test2(); // ERROR: public继承下，派生类对象不可以访问基类的protected成员
    two.test3(); // public继承下，派生类对象可以访问基类的public成员
    two.two_func();
    cout << "------------" << endl;

    Three three;
    //three.test1(); // ERROR: public继承下，派生类对象不可以访问基类的private成员
    //three.test2(); // ERROR: public继承下，派生类对象不可以访问基类的protected成员
    three.test3(); // public继承下，派生类对象可以访问基类的public成员
    three.three_func();

    return 0;
}

运行结果：
My name is One's Public.
------------
My name is One's Public.
My name is One's Protected.
My name is One's Public.
------------
My name is One's Public.
My name is One's Protected.
My name is One's Public.

结果分析：
1. public继承下，派生类以及基类派生类的派生类的成员可以访问基类具有public和protected权限的成员。
2. public继承下，派生类对象可以访问基类的public成员。

总结：基类的public和protected成员被继承后，保持原来的状态

1.2 protected继承

#include<iostream>
using namespace std;

// 创建一个基类
class One
{
// 基类的私有变量
private:
    void test1()
    {
        cout << "My name is One's Praivate." << endl;
    }
// 基类的保护变量
protected:
    void test2()
    {
        cout << "My name is One's Protected." << endl;
    }
// 基类的公共变量
public:
    void test3()
    {
        cout << "My name is One's Public." << endl;
    }
};

// 基类的派生类（保护继承）
class Two:protected One
{
public:
    void two_func()
    {
        test2();
        test3();
    }
};

// 基类的派生类的派生类（保护继承）
class Three:protected Two
{
public:
    void three_func()
    {
        test2();
        test3();
    }
};

int main()
{
    Two two;
    //two.test1(); // ERROR: protected继承下，派生类对象不可以访问基类的private成员
    //two.test2(); // ERROR: protected继承下，派生类对象不可以访问基类的protected成员
    //two.test3(); // ERROR: protected继承下，派生类对象不可以访问基类的public成员
    two.two_func();
    cout << "------------" << endl;

    Three three;
    //three.test1(); // ERROR: protected继承下，派生类对象不可以访问基类的private成员
    //three.test2(); // ERROR: protected继承下，派生类对象不可以访问基类的protected成员
    //three.test3(); // ERROR: protected继承下，派生类对象不可以访问基类的public成员
    three.three_func();

    return 0;
}

运行结果：
My name is One's Protected.
My name is One's Public.
------------
My name is One's Protected.
My name is One's Public.

结果分析：在protected继承下，派生类的成员可以访问基类的public和protected成员。但是派生类对象访问基类的变量均会报错。

总结：protected继承将基类的public和protected成员权限转换为protected。

为了探索protected在一次继承后是否对基类的成员权限产生本质上的变化，将经过protected的派生类再通过public继承，观察其结果。

// 基类的派生类（保护继承）
class Two:protected One
{
public:
    void two_func()
    {
        test2();
        test3();
    }
};

// 经过保护继承后的派生类再经过公共继承
class Three:public Two
{
public:
    void three_func()
    {
        test2();
        test3();
    }
};

int main()
{
    Three three;
    three.test3();

    return 0;
}

运行结果：
error: 'void One::test3()' is inaccessible

总结：当出现一次protected继承后，派生类对象便不可以访问基类的任何成员，并且一直按照这个性质向下继承。

1.3 private继承

#include<iostream>
using namespace std;

// 创建一个基类
class One
{
// 基类的私有变量
private:
    void test1()
    {
        cout << "My name is One's Praivate." << endl;
    }
// 基类的保护变量
protected:
    void test2()
    {
        cout << "My name is One's Protected." << endl;
    }
// 基类的公共变量
public:
    void test3()
    {
        cout << "My name is One's Public." << endl;
    }
};

// 基类的派生类（私有继承）
class Two:private One
{
public:
    void two_func()
    {
        test2();
        test3();
    }
};

// 基类的派生类的派生类（私有继承）
class Three:private Two
{
public:
    void three_func()
    {
//        test2();
//        test3();
    }
};

int main()
{
    Two two;
    // two.test1(); // ERROR: private继承下，派生类对象不可以访问基类的private成员
    // two.test2(); // ERROR: private继承下，派生类对象不可以访问基类的protected成员
    // two.test3(); // ERROR: private继承下，派生类对象不可以访问基类的public成员
    two.two_func();
    cout << "------------" << endl;

    //Three three;
    //three.three_func(); //ERROR: private继承下，进一步继承的成员也无法访问基类的任何成员

    return 0;
}

运行结果：
My name is One's Protected.
My name is One's Public.
------------

结果分析：
1. private继承的派生类对象无法访问基类成员，但是派生类成员可以访问基类中的public权限和protected权限的成员。
2. private的进一步继承的派生类（基类的孙子）不管是对象还是成员都无法访问基类成员。

总结：private继承将基类的public和protected成员权限转换为private。
基类private属性的成员永远无法访问。

1.4 使用using提升权限

当我们对基类protected成员有需求时，常适用using将将基类成员的protected提升为public，追求程序的多样性。

class Two:public One
{
public:
	// 使用using将基类中的protected权限提升至public权限
    using One::test2;
    void two_func()
    {
        test2();
        test3();
    }
};

class Three:public Two
{
public:
    void three_func()
    {
        test2();
        test3();
    }
};

int main()
{
    Two two;
    // two.test1(); //using函数不适用private成员
    two.test2();

    Three three;
    // three.test1();  //using函数不适用private成员
    three.test2();

    return 0;
}

2. 友元类继承测试

类A将类B声明为自己的友元类，则类B 的所有成员可以访问类A 的私有对象

友元类声明：friend class 类名

#include<iostream>
using namespace std;

// 设计类A含有私有变量a，在类A中友元给类C
class A
{
private:
    void test_a()
    {
        cout << "A: You can look me!" << endl;
    }

friend class C;
};

// 设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b
class B:public A
{
private:
    void test_b()
    {
        cout << "B: You can look me!" << endl;
    }
};

class C
{
public:
    void test_c()
    {
        B b1;
        b1.test_a();    // 因为C是A的友元类，因此C可以访问A的private成员
        //b1.test_b();  // C无法访问B的private成员
    }
};

int main()
{
    C c;
    c.test_c();
    return 0;
}

运行结果：
A: You can look me!

结果分析：友元类可以访问声明类的私有变量，否则私有变量不被访问。

设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。代码如下：

class D:public C
{
public:
     void test_d()
     {
         A a1;
         //a1.test_a();
         B b1;
         //b1.test_a();
         //b1.test_b();
     }
};

运行结果：D继承C后，D的成员函数无法访问类A或类B的私有变量。
结果分析：父亲的朋友不是儿子的朋友

3. C++的多态性

多态性可以理解为不同对象收到相同的消息，产生不同的行为。在C++中，多态性可以通过同一个名字定义不同的函数，这些函数执行不同的行为，实现“一个接口，多种方法”。

3.1 一般多态性

#include<iostream>
using namespace std;

// 定义基类作为父类
class Father
{
public:
    void test()
    {
    cout << "I am Father" << endl;
    }
};

// 定义Son1公共继承基类
class Son1:public Father
{
public:
    void test()
    {
        cout << "I am Son1" << endl;
    }
};

// 定义Son2公共继承基类
class Son2:public Father
{
public:
    void test()
    {
        cout << "I am Son2" << endl;
    }
};

void num(int a)
{
    cout << "Exiet one number" << endl;
}

void num(int a,int b)
{
    cout << "Exiet two number" << endl;
}

int main()
{
    // 测试不同对象调用同一函数的多样性
    Father f;
    Son1 s1;
    Son2 s2;
    f.test();
    s1.test();
    s2.test();

    cout << "---------" << endl;
    
    // 测试函数重载
    int a=1;
    int b=2;
    num(a);
    num(a,b);
}

运行结果：
I am Father
I am Son1
I am Son2
---------
Exiet one number
Exiet two number

结果分析：不同对象调用同一函数可以实现不同操作，函数重载也可以。所以说这两种方式都体现了多态性。

3.2 虚函数

当依照上述的类，我们实现以下main函数。

int main()
{
    Father *f;
    f = new Son1;
    f -> test();
}

运行结果：
I am Father

结果分析：虽然f申请了新的Son1对象，但是调用函数时，执行的是父亲的test()函数

解决方法：将基类的函数改为虚函数，既在函数定义前加上virtual

总结：虚函数是实现c++多态的一个重要途径：在基类中将被重写的成员函数设置为虚函数，其含义是：当通过基类的指针或者引用调用该成员函数时，将根据指针指向的对象类型确定调用的函数，而非指针的类型。

// 定义基类作为父类
class Father
{
public:
    virtual void test()
    {
    cout << "I am Father" << endl;
    }
};

3.3 特殊多态性

在程序构建过程中，实现函数传参过程的多样性是至关重要的。

// 定义一个全局函数，希望该函数能保留派生类的多态方法
void identify(Father a)
{
    a.test();
}

int main()
{
    Father f;
    Son1 s1;
    Son2 s2;

    identify(f);
    identify(s1);
    identify(s2);

    return 0;
}

运行结果：
I am Father
I am Father
I am Father

结果分析：该结果并没有体现传参的多样性，并不是我们预想的

解决方法一：将传入的参数改为基类的指针

void identify(Father *a)
{
    a->test();
}

int main()
{
    Father f;
    Son1 s1;
    Son2 s2;

    identify(&f);
    identify(&s1);
    identify(&s2);

    return 0;
}

解决方法二：将传入的参数改为基类的引用

void identify(Father &a)
{
    a.test();
}

int main()
{
    Father f;
    Son1 s1;
    Son2 s2;

    identify(f);
    identify(s1);
    identify(s2);

    return 0;
}

3.4 析构函数的多态性

// 定义基类作为父类
class Father
{
public:
    virtual void test()
    {
    cout << "I am Father" << endl;
    }
	// 析构虚函数
    virtual ~Father()
    {
        cout << "destory1" << endl;
    }
};

// 定义Son1公共继承基类
class Son1:public Father
{
public:
    void test()
    {
        cout << "I am Son1" << endl;
    }
	// 析构函数
    ~Son1()
    {
        cout << "destory2" << endl;
    }
};

int main()
{
    Father *f = new Son1;
    f->test();
    delete f;

    return 0;
}

运行结果：
I am Son1
destory2
destory1

结果分析：基类的析构函数添加virtual属性后，delete子类时先执行子类的析构函数再执行父类的析构函数。

3.5 虚继承和多继承

当A作为基类，B和C是A的子类，D是B和C的子类，这样会导致D继承了2次A。这种多继承的情况下应该采取虚继承。

#include<iostream>
using namespace std;

class A{
public:
    int a = 100;
};
class B:public A{

};
class C:public A{

};
class D:public B,public C{
public:
    void test(){
        // ERROR: 无法判断A来自B还是C
        int i = a;
        cout << i << endl;
    }
};

int main()
{
    D d;
    d.test();
    return 0;
}

//解决方法（虚继承）：
class B:virtual public A{
};
class C:virtual public A{
};

4. 总结

​ 通过本次实验对继承访问权限，友元类以及多态性有了基础性的摸底。

​ 继承访问权限中通过对于不同对象的权限设置以及不同方式的继承有利于丰富程序的多样性。

​ 友元类是我们对于类中的私有成员的开小灶权力，体现了C++语言的灵活性，方便我们对于一些特定要求进行代码编。

​ 多态性是对于编码者及其友好的性质，通过一个接口，多种调用的方式，使得程序功能变得完善且极大程度上降低了编码时间成本。

JMU-HZH
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java基础知识 17】Java继承和多态
学Java，找哪吒
11-18 7002
关键字extends表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)，新类称为子类（subclass)。超类和子类是 Java 程序员最常用的两个术语。在设计类的时候，应该将通用的方法放在超类中， 而将具有特殊用途的方法放在子类中。
C++实战-基于多态的企业职工管理系统
03-22
综上所述，"C++实战-基于多态的企业职工管理系统"涵盖了C++的面向对象编程、多态性、继承、模板、STL容器、文件I/O、以及用户界面等多个核心知识点。通过这个项目，开发者可以深入理解C++语言的特性，并将其应用于...
C++面试用题(一)
weixin_42111061的博客
07-22 105
堆和栈的区别： （注意不是数据结构里的堆和栈） 栈(stack)由编译器自动分配释放，存放函数的参数值，局部变量的值。 堆(heap)由程序员分配释放，如果不释放，最后程序结束时会被操作系统回收。 全局区（静态区static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在同一区域，未初始化的全局变量和未初始化的静态变量在相邻的另一区域。 int a;//系统在栈中为b开辟空间 int* a=new int;//程序员在堆中申请空间存放a a=(int*)malloc(sizeof(i
对象（深入C++对象模型）
youbingchen的博客
05-26 840
Matrix identity //Matrix 是一个类main() { //identity必须放在此处初始化 Matrix m1= identify; ... return 0; }Ｃ＋＋　保证，一定会在main函数中第一次用到identity之前，把identity构造出来，而在main函数结束之前把identity结束掉，像identity这样所谓的全局对象，如果有构造函数和析构函
【C++项目实战】继承和多态
积流成河
06-15 319
1 知识点 类定义（class默认private，struct默认public，完成定义要加;） 类传值（构造函数参数，通过派生类传值） 指向类对象的指针（this指代当前对象地址，指针访问成员用->） 构造函数和析构函数（构造函数是类同名函数，析构函数前加~） 访问修饰符（public可类外访问，protected派生访问，private类外不可访问） 类继承（derive class : 访问修饰符 base class，多重继承逗号隔开 ） 虚函数、多态、虚析构函数（virtual） 内联函数
225-C++继承多态笔试题实战
Edward_LF的博客
05-16 516
第1题 #include <iostream> using namespace std; class Animal { public: Animal(string name) :_name(name) {} //纯虚函数 virtual void bark() = 0; protected: string _name; }; //以下是动物实体类 class Cat : public Animal { public: Cat(string name) :Animal(name) {}
【黑马程序员】C++继承和多态
double_happiness的博客
02-20 914
虚基类指针跟踪虚基类的位置，而虚基类表存储了虚基类的偏移量和其他信息，用于访问虚基类的成员。这个指针指向派生类对象中的虚基类子对象。多态中，通常父类中的虚函数实现是毫无意义的，主要都是调用子类重写的内容，一次可以将虚函数直接改成纯虚函数。实现方式：将公共的方法写到父类中，不同的页面在子类中去继承父类公共页面的功能，然后在实现自己特有的功能。多态就是使用父类的指针或者引用在运行时，判断传入的是子类的对象还是父类的对象来实现不同的指向。子类中的成员包括两部分，一部分是从父类中继承过来的，一部分是子类特有的。
C++面试实战问题之多态
qq_57106289的博客
01-17 413
虚继承用于解决多重继承中的菱形继承问题，当一个派生类从多个基类继承，并且这些基类之间存在共同的基类时，就会出现菱形继承的情况。但是，如果基类的析构函数不是虚函数，而我们通过基类指针或引用来删除一个派生类对象，那么只会调用基类的析构函数，而不会调用派生类的析构函数。使用：虚函数可以通过基类指针或引用来调用，实际执行的是派生类中的版本，这是多态的一种体现。派生类可以选择是否重写基类的虚函数，但如果派生类重写了基类的虚函数，那么该函数在派生类中将被自动视为虚函数。通过传递不同的参数，可以创建不同初始状态的对象。
C++继承与多态，最通俗易懂的讲解
astupidchiken的博客
09-24 919
最通俗易懂的C++继承与多态C++继承与多态的讲解（爸爸与儿子关系）总的流程继承！爸爸与儿子的关系（虚）函数的多态（定义了一个Shape基类，及笼统的表示图形）如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 C++继承与多态的讲解（爸爸与儿子关系） 小菜鸡也是一个普普通通
538-C++继承多态笔试题实战
LINZEYU666的博客
09-10 310
第一题 class Animal { public: Animal(string name) :_name(name) {} //纯虚函数 virtual void bark() = 0; protected: string _name; }; //以下是动物实体类 class Cat : public Animal { public: Cat(string name) :Animal(name) {} void bark() { cout << _name << " b
Visual C++ 开发实战
04-08
在C++语言基础部分，书中会详细介绍C++语法，包括变量、数据类型、运算符、流程控制语句（如if-else，for，while等）、函数的使用以及面向对象编程的基础概念，如类、对象、封装、继承和多态。这些基础知识是理解和...
C++第二阶段实战任务书1
08-08
在本篇文章中，我们将对 C++ 第二阶段实战任务书进行详细的解读和分析，从面向对象设计的角度出发，设计并编写一个自动格斗类游戏的代码。 面向对象设计 面向对象设计是 C++ 编程的核心概念之一，它基于三个基本...
黑马程序员匠心之作 C++教程_第4阶段实战-基于多态的企业职工系统讲义.rar
03-19
在C++中，多态（Polymorphism）是面向对象编程的三大特性之一，另外两个是封装和继承。多态性允许我们使用一个接口来表示多种类型的对象，它提供了一种灵活的方式来设计和实现代码，使程序更具可扩展性和可维护性。...
c++实战项目包含数据库和小项目测试.zip
12-26
- 结构化编程：理解并应用C++的基础语法，如类、对象、继承、多态、模板等。 - 异常处理：在编写数据库操作时，确保使用异常处理来捕获和处理可能的错误。 - 文件I/O：对于保存和读取数据库连接信息、配置文件等...
函数模板与类模板
最新发布
程序员_小兵
07-12 1540
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
C++ 多态
wxk2227814847的博客
07-10 778
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++初探究（2）
Frenemy__的博客
07-09 1494
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C语言操作符详解
z317920的博客
07-11 621
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
c++继承、多态和虚函数
07-28
C++中的继承、多态和虚函数是面向对象编程的重要概念。 继承是指一个类可以从另一个类继承属性和方法。子类可以继承父类的公有成员和保护成员，但不能继承私有成员。通过继承，子类可以重用父类的代码，并且可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值