C++虚函数和多态超详细分析

时间:2023-02-03 king&南星人气:0

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显示说明当前函数是重写函数

多态三个必要性条件：

父类中存在虚函数
存在不正常指针的引用(不正常赋值关系)
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类型转换

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

#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;
}

加载全部内容