带你走入虚函数和多态的世界（c++）

1、什么是虚函数

C++类中用virtual修饰的函数叫做虚函数构造函数没有虚构造函数存在虚析构函数C++所有虚函数都是一个指针去存储的所以具有虚函数的类内存会增加一个指针大小的内存

#include<iostream>
#include<string>
using namespace std;
class MM
{
public:
	//虚函数指针是同一个所以无论该类中有多少个虚函数
	//占用的内存就只是一个指针的大小
	virtual void print()
	{
		cout << "我是第一个虚函数" << endl;
	}
	virtual void printData() 
	{
		cout << "我是第二个虚函数" << endl;
	}
protected:
};

class son:public MM
{
public:
	void print() 
	{
		//该函数也是虚函数
        //父类中同名函数是虚函数
		//所以子类该函数也是虚函数
	}
protected:
};
int main() 
{
	cout << sizeof(MM) << endl;
	cout << "...................." << endl;
	//虚函数表的理解下面带图解
	MM mm;
	long long** p = (long long**)&mm;
	using Func = void(*)();
	Func f1 = (Func)p[0][0];
	Func f2 = (Func)p[0][1];
	f1();
	f2();
	return 0;
}

2.纯虚函数

• 纯虚函数也是虚函数的一种只是没有函数体下面请看怎么表示没有函数体
• 纯虚函数——>虚函数=0
• 具有一个或者多个虚函数的类叫做抽象类
  • 抽象类不能构建对象
  • 但是可以构建函数指针

#include<iostream>
using namespace std;
class MM
{
public:
	virtual void print() = 0;
};
int main()
{
	//MM mm; //抽象类不能构建对象
	MM* pmm = nullptr;
	return 0;
}

3.c++多态

多态指的是因为指针的不同的赋值操作所导致的同一行为的不同结果。多态的这个概念东西不太重要重要的是什么样的情况调用什么样的行为

• 正常指针和正常对象调用行为就近原则
• 父类指针被子类对象初始化
• 函数有virtual看对象类型
• 函数没有virtual看指针类型
• final关键字 禁止子类重写父类方法
• override显示说明当前函数是重写函数

多态三个必要性条件

1. 父类中存在虚函数
2. 存在不正常指针的引用(不正常赋值关系)
3. public继承

#include<iostream>
using namespace std;
class MM
{
public:
	void print()
	{
		cout << "父类" << endl;
	}
	virtual void printData()
	{
		cout << "MM" << endl;
	}
};
class son :public MM 
{
public:
	void print() 
	{
		cout << "子类" << endl;
	}
	void printData() 
	{
		cout << "son" << endl;
	}
};
int main()
{
	MM* pmm = new son;
	pmm->print();
	pmm->printData();
	return 0;
}

4.纯虚函数和ADT过程

ADT:abstract data type抽象数据类型主要是通过继承抽象类中子类必须要实现父类的抽象方法子类才可以创建对象。

#include<iostream>
#include<string>
using namespace std;
class data
{
public:
	string name;
	int age;
};
class MM
{
public:
	virtual bool empty() = 0;
	virtual int size() = 0;
};
class List:public MM
{
public:
	bool empty()
	{
		return 0;
	}
	int size()
	{
		return NULL;
	}
};
int main()
{
	MM* pmm = new List;
	pmm->empty();
	pmm->size();
}

5.虚析构函数

virtual修饰的析构函数就是虚析构函数当存在子类对象初始化父类指针的时候父类析构函数就要是虚析构函数否则只会释放父类存在内存泄漏问题

#include<iostream>
using namespace std;
class MM
{
public:
	virtual ~MM()
	{
		cout << "父类" << endl;
	}
};
class son:public MM
{
public:
	~son()
	{
		cout << "子类" << endl;
	}
};

int main()
{
	MM* pmm = new son;
	delete pmm;
	return 0;
}

6.dynamic_cast类型转换

1. 上行转换 子类到父类 和staic_cast差不多
2. 下行转换 父类到子类 dynamic_cast更为安全
3. 交叉转换 多继承

#include<iostream>
using namespace std;
class MM
{
public:
	virtual void print() { cout << "MM" << endl; }
};
class son:public MM
{
public:
	void print() { cout << "son" << endl; }
};

class A
{
public:
	virtual void print(){}
};
class B
{
public:
	virtual void print() {}
};
class C:public A,public B
{
public:
	void print()
	{
		cout << "c" << endl;
	}
};

int main()
{
	MM* partent = new MM;
	son* Son = new son;
	//上行转换----->没有必要
	MM* p = static_cast<MM*>(Son);
	MM* pp = dynamic_cast<MM*>(Son);
	MM* ppp = Son;       //可以
	//下行转换
	son* x = dynamic_cast<son*>(partent); //安全父类没有virtual会报错---->多态
	if(!x)
	{
		printf("error");
	}                           //下行转换不安全不会申请成功

	A* a = new A;
	B* b = dynamic_cast<B*>(a);
	b->print();
	return 0;
}

7.成员函数指针

#include<iostream>
#include<functional>
using namespace std;
class MM
{
public:
	void print() { cout << "king" << endl; }
	static void printData() { cout << "MM" << endl; }
};
int main()
{
	void(*p)() = &MM::printData;
	p();

	//必须通过对象调用
	void(MM::*pp)() = &MM::print;
	MM mm;
	(mm.*pp)();
	 
	//函数适配器让函数调用形态可以适用于别的形态
	auto f = bind(&MM::print, &mm);
	f();
	return 0;
}