C++多态的使用

1. 多态

多种形态或多种实现方法，C++中的多态是指一种接口（指的是父类接口），多种实现方法（指的是每个子类所实现的方法），即通过父类接口实现调用子类的多种方法

1.1 构成多态性的条件：

1）具有继承关系的两个类

2）父类指针或引用指向子类

3）多种实现方法需要声明为虚函数

1.2 静态绑定

静态绑定（Static Binding），也称为早期绑定（Early Binding）或编译时绑定（Compile-time Binding），是指在程序的编译阶段确定方法、函数或操作的调用目标。在静态绑定中，编译器能够准确地确定调用哪个函数，因为调用关系在编译时已经被决定了。

静态绑定的优势在于效率高，因为编译器在编译时就能够确定调用关系，不需要在运行时进行查找。然而，静态绑定的缺点是缺乏灵活性，因为调用的目标在编译时就已经固定，无法根据运行时的条件进行动态调整。

与之相对的是动态绑定（Dynamic Binding），它是在运行时根据对象的实际类型来确定调用的方法。动态绑定通常与虚函数（virtual function）相关联，使得在运行时能够调用到对象实际类型的方法。

静态绑定（静态联编）

是指函数或表达式的地址，在编译时就已经确定

根据对象的类型确定成员的调用地址

普通函数调用：对于全局函数或类的静态成员函数，编译器在编译时就能够确定调用的函数。

void myFunction() {// some code
}int main() {myFunction(); // 静态绑定return 0;
}

非虚函数调用：对于非虚函数，编译器也能够在编译时确定调用的函数。

class Base {
public:void nonVirtualFunction() {// some code}
};int main() {Base obj;obj.nonVirtualFunction(); // 静态绑定return 0;
}

1.3 动态绑定

动态绑定（动态联编）

是指函数或表达式的地址，在运行时才确定

例子：

多态

根据指向的地址的对象的类型来确定成员的调用地址

C++中的多态性（polymorphism）通过虚函数（virtual functions）和动态绑定（dynamic binding）来实现。多态性允许在运行时根据对象的实际类型调用相应的函数，而不是根据变量或指针的静态类型。

在C++中，要实现多态性，你需要使用虚函数。虚函数是在基类中声明并在派生类中重写的函数。在基类中，你使用virtual关键字声明这个函数

duotai2.cpp

#include <iostream>
using namespace std;//多态的动态绑定
class Shape {
public:// 基类中的虚函数//virtual void draw() = 0;virtual void draw(){cout << "父类画一个形状" << endl;}
};class Circle : public Shape {
public:// 派生类中重写基类的虚函数void draw(){cout << "子类1画圆" << endl;}
};class Square : public Shape {
public:// 派生类中重写基类的虚函数void draw(){cout << "子类2画方" << endl;}
};int main() {Circle circle;Square square;// 使用基类指针指向派生类对象Shape* shapePtr = &circle;shapePtr->draw(); // 动态绑定，将调用 Circle 类的 draw 函数Shape* shapePtr2 = &square;shapePtr2->draw(); // 动态绑定，将调用 Square 类的 draw 函数return 0;
}

2. 虚析构函数

为什么要提出虚析构函数？解决资源（子类）得不到释放的问题

析构函数用vritual关键字来进行修饰

前提：

父类的指针或引用指向子类时

格式：virtual   ~类名（）{}
例如：virtual  ~People（）//虚析构函数{}

2.1 面试题:

如果父类的析构函数不是虚函数，会带来(引起) 什么问题?

问题演示

xvgou.cpp

//虚析构函数
class People {
public:~People() { cout << "父类的虚构函数" << endl;}
};//class People {
//public:
//	virtual ~People() { //把父类声明为虚析构函数
//		cout << "父类的虚构函数" << endl;
//	}
//};class Son :public People{
public:~Son() {cout << "子类的虚构函数" << endl;}
};int main()
{//写法一，因为在堆上开辟的son,所以需要手动delete释放People* people = new Son;delete people;//写法二，因为在栈上开辟的son,不需要手动释放，程序会自动释放/*Son son;People* people = &son;*/return 0;
}

可以看到子类并未释放

带来的问题:资源(子类)得不到释放的问题

如果基类的析构函数不是虚函数，而你通过基类指针删除派生类对象，将只会调用基类的析构函数，而不是派生类的析构函数，这可能导致资源泄漏。

解决:将父类的析构函数声明为虚析构函数

xvgou.cpp

//虚析构函数
//class People {
//public:
//	~People() { 
//		cout << "父类的虚构函数" << endl;
//	}
//};class People {
public:virtual ~People() { //把父类声明为虚析构函数cout << "父类的虚构函数" << endl;}
};class Son :public People{
public:~Son() {cout << "子类的虚构函数" << endl;}
};int main()
{//写法一，因为在堆上开辟的son,所以需要手动delete释放People* people = new Son;delete people;//写法二，因为在栈上开辟的son,不需要手动释放，程序会自动释放/*Son son;People* people = &son;*/return 0;
}

3. 限制构造函数

限制对象的生成（创建）

将构造函数放置在protected或private修饰符下，用于限制对象的生成

3.1 举例

xvgou.cpp

//限制构造函数(将类的构造函数放在private下，限制类的实例化)
class Person {private:Person() {cout << "person的构造函数" << endl;}
};int main()
{//Person person;return 0;
}

3.2 当限制构造函数时，通过友元构造对象可行？

可以

xvgou.cpp

//限制构造函数(将类的构造函数放在private下，限制类的实例化)
class Person {
public:friend void create();//声明友元函数
private:Person() {cout << "person的构造函数" << endl;}
};//设置友元函数，看看可不可以实例化对象
void create() {Person person;
}int main()
{//Person person;//通过友元实例化对象create();return 0;
}