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 
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 = □
    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;
}