c++的静态多态和动态多态

1.多态的概念

概念：同一个接口，同一个同名的函数。能实现多种不同的功能。

静态多态：在编译的时候能确定具体调用的是哪个函数的多态就是静态多态，包括有函数重载和模板函数(泛型编程)

动态多态:在运行时才能确定具体调用的是哪个函数，这种情况就是动态多态，主要是在类的继承中使用虚函数来实现。

2.函数的重载

比如我定义两个同名函数，只有返回值类型不同，会直接给我们报错。提示我们无法重载仅靠返回值来区分的函数。

示例代码：

#include <iostream>


int Printnum(int a)
{
	std::cout << a << std::endl;
	return 0;
}

int Printnum(int a,double b)
{
	std::cout << a << std::endl;
	std::cout << a << std::endl;
	return 0;
}

int Printnum(double a, int b)
{
	std::cout << a << std::endl;
	std::cout << a << std::endl;
	return 0;
}



int main(int argc, char* argv[])
{
	Printnum(1);
	Printnum(2,3.0);
	Printnum(6.0, 2);
}

输出结果

可以看到通过示例代码，能和函数重载满足的条件一一对应，函数重载只和，参数的类型，参数的顺序，参数的数量有关。

3.模板函数，泛型编程

在编译期间就能确定具体是调用了哪个函数

示例代码

#include <iostream>


// 函数模板（泛型编程）
template <typename T>
void add(T a, T b)
{
	std::cout << a + b << std::endl;
}




int main(int argc, char* argv[])
{
	add(1, 2);
	add(3.0, 4.5);

}

4.虚函数

在基类声明重写的函数，使用virtual声明成虚函数。在派生类里面对该函数进行重写。

在定义实例化对象的时候，就能通过基类指针，调用基类的函数，或者调用派生类的函数。具体看基类指针的实例化对象是哪个。

#include <iostream>

using namespace std;
class Base
{
public:
	Base() {
		cout << "Base construct" << endl;
	}

	virtual ~Base()
	{
		cout << "Base destruct" << endl;
	}

public:
    void fun1(){};
    
	virtual void show()
	{
		cout << "Base show" << endl;
	}
};


class Drived :public Base {
public:
	void show()
	{
		cout << "Drived show" << endl;
	}
};


int main(int argc, char* argv[])
{
	Base* ptr = new Drived();
	ptr->show();
	delete ptr;
	ptr = nullptr;
	ptr = new Base();
	ptr->show();
	delete ptr;
	return 0;
}

输出结果

能达到这样的效果，还有一个重要的原因是使用了虚函数表，虚函数表里面实际存储的是哪个函数，当前的基类指针就会调用哪个函数。