c++学习笔记-7

最新推荐文章于 2024-08-28 14:35:43 发布
最新推荐文章于 2024-08-28 14:35:43 发布
阅读量73 收藏
点赞数
文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57791493/article/details/129231363
版权
本文介绍了C++中的多态性，包括什么是多态，如何通过虚函数和纯虚函数实现多态，以及多态的作用。同时，讨论了抽象类、接口的概念，模版方法模式的应用，以及虚析构函数对于正确删除派生类对象的重要性。文中还通过动物园案例展示了多态的实际运用，并提到了函数的重载、重写和隐藏的区别。
摘要由CSDN通过智能技术生成

01.多态（重点难点）

1.什么是多态：

同一个操作作用于不同的对象，可以有不同的解释，会产生不同的效果，这就是多态

class People
{
public:
    //虚函数
    virtual void Mypro()
    {
​
    }
};
​
class xishi :public People
{
public:
    //重写父类的虚函数
    virtual void Mypro()
    {
        cout << "约西施" << endl;
    }
};
​
class wangzhaojun :public People
{
public:
    //重写父类的虚函数
    virtual void Mypro()
    {
        cout << "约王昭君" << endl;
    }
};
​
​
​
class diaochan :public People
{
public:
    //重写父类的虚函数
    virtual void Mypro()
    {
        cout << "约貂蝉" << endl;
    }
};
​
class yangguifei :public People
{
public:
    //重写父类的虚函数
    virtual void Mypro()
    {
        cout << "约杨贵妃" << endl;
    }
};
​
​
//同一个操作
void doLogin(People *pro)
{
    pro->Mypro();//产生不同的效果
}
​
void test()
{
    People *pro = NULL;
    pro = new xishi;
    doLogin(pro);//不同的对象
    delete pro;
​
    pro = new wangzhaojun;
    doLogin(pro);//不同的对象
    delete pro;
​
    pro = new diaochan;
    doLogin(pro);//不同的对象
    delete pro;
​
    pro = new yangguifei;
    doLogin(pro);//不同的对象
    delete pro;
}

2.多态有什么用

1.可以解决项目中的紧耦合问题,提供程序的可扩展性

2.应用程序不必为每一个子类的功能调用编写代码，只需要对抽象的父类进行处理

3.多态发生的三个条件

1.有继承。2.重写父类的虚函数。3.父类指针指向子类对象

02.多态的实现原理（重点难点）

class Animal
{
public:
    virtual void speak()
    {
        cout << "Anima speak()" << endl;
    }
    
};
class Dog :public Animal
{
public:
    virtual void speak()
    {
        cout << "Dog speak()" << endl;
    }
};
​
void test()
{
    cout << sizeof(Animal) << endl;
​
    Animal *animal = new Dog;
    animal->speak();
}

03.纯虚函数和抽象类(重点)

1.依赖倒转

业务层依赖抽象层，实现层依赖抽象层

//抽象层
class rule
{
public:
    virtual int getnum(int a,int b)
    {
        return 0;
    }
};
​
//实现层
class plus_rule :public rule
{
public:
    virtual int getnum(int a, int b)//重写父类的虚函数，依赖抽象层
    {
        return a+b;
    }
};
​
​
​
​
//业务层
int doLogin(rule *cal)
{
    
    int a = 10;
    int b = 20;
    
​
    int ret=cal->getnum(a, b);//依赖抽象层
​
    return ret;
​
}
​
void test()
{
    rule *r = NULL;
    r = new plus_rule;
    cout << doLogin(r) << endl;
    delete r;
​
}

2.开闭原则

对修改源代码关闭，对扩展新功能开发

//抽象层
class rule
{
public:
    virtual int getnum(int a,int b)
    {
        return 0;
    }
};
​
//实现层
class plus_rule :public rule
{
public:
    virtual int getnum(int a, int b)//重写父类的虚函数，依赖抽象层
    {
        return a+b;
    }
};
//扩展新功能
class miux_rule :public rule
{
public:
    virtual int getnum(int a, int b)
    {
        return a - b;
    }
};
​
​
//业务层
int doLogin(rule *cal)
{
    
    int a = 10;
    int b = 20;
    
​
    int ret=cal->getnum(a, b);//依赖抽象层
​
    return ret;
​
}
​
void test()
{
    rule *r = NULL;
    r = new plus_rule;
    cout << doLogin(r) << endl;
    delete r;
    //增加的代码
    r = new miux_rule;
    cout << doLogin(r) << endl;
    delete r;
​
}

3.纯虚函数

class rule
{
public:
    //纯虚函数
    virtual int getnum(int a, int b) = 0;
};

4.抽象类

1.有纯虚函数的类叫抽象类，不能实例化对象

//有纯虚函数的类叫抽象类，不能实例化对象
class rule
{
public:
    //纯虚函数
    virtual int getnum(int a, int b) = 0;
};
​
void test02()
{
    //抽象类不能实例化对象
    //rule r;
}

2.如果子类继承抽象类，子类必须实现抽象类的所有纯虚函数，不然子类也变为抽象类

class Maker
{
public:
    virtual void func1() = 0;
    virtual void func2() = 0;
};
​
class Son :public Maker
{
public:
    virtual void func1()
    {
​
    }
    virtual void func2()
    {
​
    }
};
​
void test03()
{
    Son s;
}

04.接口的定义（了解）

1.所谓的接口，即将内部实现细节封装起来，外部用户用过预留的接口可以使用接口的功能而不需要知晓内部具体细节。C++中，通过类实现面向对象的编程，而在基类中只给出纯虚函数的声明，然后在派生类中实现纯虚函数的具体定义的方式实现接口，不同派生类实现接口的方式也不尽相同

//抽象类
class Father
{
public:
    virtual void func1() = 0;//接口的声明
    virtual void func2(int a) = 0;
    virtual void func3(int a,int b) = 0;
};
​
class Son :public Father
{
public:
    virtual void func1()//接口的实现
    {
​
    }
    virtual void func2(int a)
    {
​
    }
    virtual void func3(int a, int b)
    {
​
    }
};

05.模版方法模式（重点）

1.在抽象类中确定好函数的调用顺序

class Drink
{
public:
    //煮水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //导入杯中
    virtual void PourInCup() = 0;
    //加点辅料
    virtual void addSome() = 0;
​
    //模版方法,把调用函数的顺序确定下来
    void func()
    {
        Boil();
        Brew();
        PourInCup();
        addSonm();
    }
};

06.虚析构函数和纯虚析构函数（重点）

1.虚析构函数是为了解决基类指针指向派生类对象，并用基类指针释放派生类对象

class Animal
{
public:
    Animal()
    {
        cout << "Animal的构造" << endl;
    }
​
    //虚析构函数会调用子类的析构函数
    virtual ~Animal()
    {
        cout << "Animal的析构" << endl;
    }
};
​
class Son :public Animal
{
public:
    Son()
    {
        cout << "Son的构造" << endl;
        pName = new char[64];
        memset(pName, 0, 64);
        strcpy(pName, "如花");
    }
​
    ~Son()
    {
        cout << "Son的析构" << endl;
        if (pName != NULL)
        {
            delete[] pName;
            pName = NULL;
        }
    }
​
public:
    char *pName;
};
​
void test()
{
    Animal *animal = new Son;
    delete animal;
}

2.纯虚析构函数，有纯虚析构函数的类是抽象类，不能实例化对象

注意：纯虚析构函数需要在类外实现

class Animal
{
public:
    Animal()
    {
        cout << "Animal的构造" << endl;
    }
​
    //虚析构函数会调用子类的析构函数
    /*virtual ~Animal()
    {
        cout << "Animal的析构" << endl;
    }*/
​
    //纯虚析构函数，纯虚析构函数需要在类外实现
    virtual ~Animal() = 0;
};
​
//在类外实现纯虚析构函数
Animal::~Animal()
{
    cout << "Animal的纯虚析构" << endl;
}

3.虚析构函数和纯虚析构函数的区别：

1.有纯虚析构函数的类是抽象类，不能实例化对象，而且要在类外实现

2.虚析构函数不需要在类外实现

07.多态案例_动物园（重点）

1.创建动物基类

class Animal
{
public:
    virtual void speak() = 0;
};

2.创建动物

class Dog :public Animal
{
public:
    Dog(string name)
    {
        this->name = name;
    }
    virtual void speak()
    {
        cout << "小狗" << name << "汪汪汪" << endl;
    }
private:
    string name;
};
​
class Dark :public Animal
{
public:
    Dark(string name,string type)
    {
        this->name = name;
        this->type = type;
    }
    virtual void speak()
    {
        cout <<type<<"品牌的"<< "小鸭" << name << "嘎嘎嘎" << endl;
    }
private:
    string name;
    string type;
};
​
class Tiger :public Animal
{
public:
    Tiger(string name,int age)
    {
        this->name = name;
        this->age = age;
    }
    virtual void speak()
    {
        cout << age << "岁" << "老虎" << name << "嗷嗷嗷" << endl;
    }
private:
    string name;
    int age;
​
};

3.创建动物园

class Zoo
{
public:
    Zoo()
    {
        mCapacity = 1024;
        mSize = 0;
        //申请空间，存储Animal*的空间，指针数组
        this->p = new Animal*[mCapacity];
    }
​
    //增加动物
    int AddAnimal(Animal* animal)
    {
        if (mCapacity == mSize)
        {
            return -1;
        }
        //把指针存储到指针数组
        this->p[mSize] = animal;
        mSize++;
​
        return 0;
    }
​
    void StartSpeak()
    {
        for (int i = 0; i < mSize; i++)
        {
            p[i]->speak();
        }
    }
​
    //析构函数
    ~Zoo()
    {
        //先释放指针数组中指针指向的堆区空间
        for (int i = 0; i < mSize; i++)
        {
            if (p[i] != NULL)
            {
                delete p[i];
                p[i] = NULL;
            }
        }
​
        //释放指针数组
        delete[] p;
        p = NULL;
    }
​
​
private:
    Animal* *p;
    int mCapacity;//容量
    int mSize;
​
};
​

4.使用

void test()
{
    //创建动物园
    Zoo *zoo = new Zoo;
​
    //添加动物
    zoo->AddAnimal(new Dog("晋三"));
    zoo->AddAnimal(new Dark("黑鸭", "周黑鸭"));
    zoo->AddAnimal(new Tiger("三胖", 35));
​
    zoo->StartSpeak();
​
    //烧了动物园
    delete zoo;
}

08.父类引用子类对象

class Animal
{
public:
    virtual void speak()
    {
        cout << "Animal speak()" << endl;
    }
};
​
class Dog :public Animal
{
public:
    virtual void speak()
    {
        cout << "Dog speak()" << endl;
    }
};
​
void test()
{
    Animal &animal = Dog();
    animal.speak();
​
    Animal* dog = new Dog();
    Animal* &an = dog;
    an->speak();
    delete dog;
}

09.重写，重载，重定义（隐藏）

1.重载，同一作用域的同名函数

2.重写（覆盖）:

1. 有继承

2.子类（派生类）重写父类（基类）的virtual函数

3.函数返回值，函数名字，函数参数，必须和基类中的虚函数一致

3.重定义（隐藏）

1. 有继承

2.子类（派生类）重新定义父类（基类）的同名成员（非virtual函数）

lonlybrave
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现cal命令
0day
08-14 2287
/* Jan 26 2020 14:29 */ #include <time.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> #define WEEKDAY 7 #define MONTHS 12 typedef struct _Date { int yea...
C++学习笔记 七
GAOK11的博客
10-16 296
流和文件I/O操作： 输入流：数据的流动方向是进入程序； 输出流：数据的流动方向是离开程序； 文件I/O: 将数据写入文件，或从文件中读取数据，要用到fstream库中的ofstream与ifstream; #include <iostream> #include <fstream> #include <string> using namespace std; int main() { ifstream st_1; ofstream st_2;
2013-C++第11周项目参考解答链接集
迂者-贺利坚的专栏
11-08 2984
课程首页在：http://blog.csdn.net/sxhelijian/article/details/11890759完整题目见：http://blog.csdn.net/sxhelijian/article/details/14109337【项目1-调用函数输出星号图】参考解答见：http://blog.csdn.net/sxhelijian/article/details/1454841
C++ 编程作业 请完成函数cal()。函数cal( )接受输入若干正整数，将个位为3的数的个数存入参数thr，个位为7且十位为8的数的个数存入参数sev，偶数的个数存入参数e。中间用空格隔开
2402_85068520的博客
05-30 454
28.请完成函数cal()。，函数cal( )接受输入若干正整数，将个位为3的数的个数存入参数thr，个位为7且十位为8的数的个数存入参数sev，偶数的个数存入参数e。例如，文件中有数据31、5、187、18，则thr=0，sev=1，e=1。样例输入：31 5 187 18 样例输出：0 1 1。
Linux下cal命令C/C++实现（显示日历信息）
chen1415886044的博客
01-03 2275
在Linux生态系统中，cal代表日历。cal是一个命令行实用程序，用于在Linux终端窗口上显示日历信息。它将有助于打印单月日历、多个或多个月日历以及全年。
cal在c语言里,C语言实现cal命令
weixin_32149339的博客
05-19 1605
/* Jan 26 2020 14:29 */#include #include #include #include #define WEEKDAY 7typedef struct _Date{int year; // 当前的年份int month; // 当前的月份int mday; // 当月的经过的天数int wday; // 从星期天开始经过的天数} Date;Date get_no...
C++学习笔记（七）
JIWilliams
12-05 344
时间：2018/12/5 地点：元征总部 天气：骄阳似火                                                                                                          笔记 1.basic_string和string类均提供了常规的迭代器和反向迭代器： （1）可以使用迭代器遍历string内的所...
C++学习笔记- 面向对象 .md
11-13
C++学习笔记，博主个人向。内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联...
2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法
03-12
2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-C++后端-学习笔记-操作系统、计算机网络、C++语言+算法 2024届求职-...
C++学习笔记--函数
09-08
**C++学习笔记--函数** 在C++编程中，函数是一种可重用的代码块，它执行特定的任务并可能接收参数、返回值或两者都有。本笔记将深入探讨C++中的函数，包括它们的定义、调用、参数传递以及如何在实际编程中有效地...
C++非常实用-学习-总结-笔记-.pdf
11-16
C++非常实用-学习-总结-笔记-.pdf
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 487
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 1005
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1793
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++的内存模型
qhu1600417010的博客
08-28 790
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 501
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
＜C++＞ 多态
prodigy623的博客
08-24 1201
多态的细节
C++学习笔记：类与对象概述
"C++学习笔记，面向对象程序设计，C++之父比雅尼·斯特劳斯特鲁普，课程性质，课时安排，作业考核，C++的特点与历史，行业地位，应用领域" 在深入探讨类与对象的概念之前，我们先来理解C++的基本概述。C++是由比...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值