首页 > 编程语言 >每天学点C++之多态

每天学点C++之多态

时间:2024-10-08 12:21:26浏览次数:9  
标签:函数 每天 多态 C++ public Animal using include class

一 多态的语法

多态的基本含义是,函数参数父为类型,传入该类不同的子类,所表现的行为会根据子类的具体情况而不同,大家请看代码:

#include<iostream>
using namespace std;
class Animal {
public:
    void eat() {
        cout << "Animal eat" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
}
int main() {
    Cat c;
    Test(c);
    return 0;
}

我们在传入Cat类的对象c时会隐式转换为父类Animal类型,上述代码运行结果如下:

并不符合预期,那我们要怎么做才能实现多态呢?

很简单,在父类同名函数前加上一个关键字 virtual 其中原理马上就讲:

 

#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() {
        cout << "Animal eat" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
}
int main() {
    Cat c;
    Test(c);
    return 0;
}

运行结果如下:

 二 虚函数

先请大家对比两端代码:

#include<iostream>
using namespace std;
class Animal {
public:
    void eat() {
        cout << "Animal eat" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
}
int main() {
    cout << sizeof(Animal) << endl;
    return 0;
}
#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() {
        cout << "Animal eat" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
}
int main() {
    cout << sizeof(Animal) << endl;
    return 0;
}

第一段代码运行结果如下:

说明成员函数并不存储于类内部,而为了避免我们因此无限制的定义类所以将其内存长度设置为1

 第二段代码运行结果如下:

大家应该知道,在C++中long long ,double, 指针三种类型的变量其内存长度为8,在这里只可能是指针变量,大家可以明白了,类内存储的本质是一个函数指针,更准确地来说是虚函数指针数组,数组中每一个元素都是一个指向虚函数的指针,如果子类与父类有同名函数且父类中声明该函数为虚函数,则会用子类函数覆盖掉父类中虚函数指针的相应位置的元素 。

大家再看两段代码感受一下:

#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() {
        cout << "Animal eat" << endl;
    }
    void sleep() {
        cout << "Animal sleep" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
    void sleep() {
        cout << "Cat sleep" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
    a.sleep();
}
int main() {
    Cat c;
    Test(c);
    return 0;
}
#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() {
        cout << "Animal eat" << endl;
    }
    virtual void sleep() {
        cout << "Animal sleep" << endl;
    }
};
class Cat:public Animal{
public :
    void eat() {
        cout << "Cat eat" << endl;
    }
    void sleep() {
        cout << "Cat sleep" << endl;
    }
};
void Test(Animal &a) {
    a.eat();
    a.sleep();
}
int main() {
    Cat c;
    Test(c);
    return 0;
}

第一段代码运行结果如下:

第二段代码运行结果如下:

 

三 纯虚函数和抽象类

如果一个虚函数没有实现则就是纯虚函数

如果父类里有纯虚函数则就是抽象类

抽象类无法实例化对象,抽象类就是为了被继承,在子类中实现虚函数。

#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() = 0;
};
int main() {
    return 0;
}

像这样,eat()就是一个纯虚函数,Animal就是一个纯虚类。

举一个具体的例子:

#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() = 0;
};
class Cat {
public:
    void eat() {
        cout << "Cat eat" << endl;
    }
};
int main() {
    Cat c;
    c.eat();
    return 0;
}

稍微变一下:

#include<iostream>
using namespace std;
class Animal {
public:
    virtual void eat() = 0;
};
class Cat {
public:
    virtual void eat() {
        cout << "Cat eat" << endl;
    }
};
class BossCat {
public:
    void eat() {
        cout << "BossCat eat" << endl;
    }
};
int main() {
    BossCat c;
    c.eat();
    return 0;
}

Cat中也定义了虚函数,Cat中的虚函数本身实现了父类Animal中的纯虚函数,同时又让Cat的子类能够重写它的这个虚函数。

四 虚析构和纯虚析构

父类类型的指针指向子类对象,如果父类中的析构函数没有加上virtual那么在销毁时就不会调用子类的析构函数就会发生内存泄漏。

请看代码:

#include<iostream>
using namespace std;
class Base {
public:
    Base() {}
    ~Base() {
        cout << "Base 析构" << endl;
    }
};
class Son:public Base{
public:
    int* m_data;
    Son(): m_data(NULL){
        m_data = new int(10);
    }
    ~Son() {
        delete m_data;
        cout << "Son析构" << endl;
    }

};
int main() {
    Base* base  = new Son();
    delete base;
    return 0;
}

运行结果如下:

对比一下:

#include<iostream>
using namespace std;
class Base {
public:
    Base() {}
    virtual ~Base() {
        cout << "Base 析构" << endl;
    }
};
class Son:public Base{
public:
    int* m_data;
    Son(): m_data(NULL){
        m_data = new int(10);
    }
    ~Son() {
        delete m_data;
        cout << "Son析构" << endl;
    }

};
int main() {
    Base* base  = new Son();
    delete base;
    return 0;
}

 运行结果如下:

上述是虚析构,下面我们来看看纯虚析构:

#include<iostream>
using namespace std;
class Base {
public:
    Base() {}
    virtual ~Base() = 0;
};
Base::~Base() {
    cout << "Base 析构" << endl;
}
class Son:public Base{
public:
    int* m_data;
    Son(): m_data(NULL){
        m_data = new int(10);
    }
    ~Son() {
        delete m_data;
        cout << "Son析构" << endl;
    }

};
int main() {
    Base* base  = new Son();
    delete base;
    return 0;
}

 大家要注意,纯虚析构要在类外部实现,还有定义为纯虚析构则该类就是抽象类不能实例化对象,这里使用指针并不违背。运行结果与虚析构函数相同。

本文就讲到这里,还望大家多多支持与指正!

标签:函数,每天,多态,C++,public,Animal,using,include,class
From: https://blog.csdn.net/2301_79024503/article/details/142755111

相关文章

  • 【C++】速通涉及 “vector” 的经典OJ编程题
    【C++】速通涉及“vector”的经典OJ编程题一.杨辉三角解题思路:代码实现:二.删除有序数组中的重复项解题思路:代码实现:【C/C++】按位运算符使用规制三.只出现一次的数字解题思路:代码实现:四.只出现一次的数字III解题思路:代码实现:一.杨辉三角本题LeetCode链......
  • c++条件变量
    条件变量是用于线程间同步的一种机制,它允许一个或多个线程在某个条件满足之前等待,并在条件满足时通知等待的线程继续执行。以下是条件变量的基本使用方法,包括notify_one和notify_all的作用。使用条件变量的基本步骤创建条件变量和互斥量:首先需要创建一个std::condition_v......
  • Java基础第八章(多态)
    多态1.方法体现多态方法重载体现多态对象通过传入不同数量的参数,会调用不同的sun方法,体现出多态方法重写体现多态A类和B类是继承关系,通过不同对象调用对应类中重写的方法体现2.对象体现多态编译是javac,运行是java(1)一个对象的编译类型和运行类型可以不一致将父......
  • c++指针传递与引用传递
    c不支持引用传递的!在C++中,指针传递和引用传递是两种常用的参数传递方式,它们各自有不同的特点和适用场景。下面是两者之间的主要区别:1.语法和使用指针传递定义和调用:函数参数是一个指针类型,调用时需要传递变量的地址。解引用:在函数内部需要使用解引用操作符*来访问指针......
  • c++可变模板参数
    在C++中的可变模板参数使用省略号...来表示一个参数包(ParameterPack),其具体位置决定了这个包是模板参数包还是函数参数包,以及如何进行参数展开。1.模板参数包:c...Args省略号放在类型名称的右边,用来表示模板参数包,即可以接受任意数量的模板类型参数。template<typename...A......
  • java_day8_多态、抽象类、接口
    一、多态多态的好处:1、提高了程序的维护性(由继承保证)2、提高了程序的扩展性(由多态保证)代码案例(多态的拓展性)classAnimal{publicvoideat(){System.out.println("吃");}publicvoidsleep(){System.out.println("睡");}}clas......
  • C++ 对象模型
    对象的内存布局非虚函数类对象对于不包含虚函数的类,对象的内存布局相对简单,其成员变量按照声明的顺序依次存储。例如:classSimpleClass{private:intnum;doubled;public:SimpleClass(intn,doubledd):num(n),d(dd){}};在SimpleClass对象的内存......
  • 总结C/C++中内存区域划分
    目录1.C/C++程序内存分配主要的几个区域:2.内存分布图1.C/C++程序内存分配主要的几个区域:1、栈区2、堆区3、数据段(静态区)4.代码段2.内存分布图 如图:static修饰静态变量成员——放在静态区intglobalVar是全局变量——放在静态区全局变量&&静态变量 放在......
  • C++ 算法学习——1.8 悬线法
    1.问题引入:对于一个矩形图,图中放置着不少障碍,要求出最大的不含障碍的矩形。2.分析:显然一个极大矩形是左右上下都被障碍挡住,无法再扩大的矩形,此时障碍也包括边界。3.方法:悬线法考虑以当前点所在行为下界,以往上能达到的最大距离为高度,正上方所有点的往左最大距离的最小值和往右......
  • c++中的读写锁
    读写锁是一种特殊的锁机制,允许多个线程同时读取共享数据,但在写入共享数据时,只有一个线程可以进行写操作,其他线程必须等待。这种机制对于读多写少的场景非常有效,可以提高并发性能。以下是通过shared_lock、unique_lock、shared_mutex和mutex的解释来说明读写锁的实现和应用。......