C++ 多肽、虚函数总结

一、简介

多肽：就是A类中有func1()方法，B继承自A，并将A的func1()方法重写，但是我们在调用的时候 分别调用A  a  和B  b的对象去调用func1() .而出现的情况不同。

多肽就是用父类的指针调用子类的成员函数，这种技术可以让父类的指针有“多重形态”，就是一种泛型技术。就是用不变的代码来实现可变的算法

#if 1 
class  A
{
public :
	virtual  void func1()
	{
		cout << "A -func1   "<<endl;
	}

};

class B :public A
{
public:
	virtual  void func1()
	{
		cout << "B -func1  " << endl;
	}

};

void  func(A &a) 
{
	a.func1();
}
int main()
{
	A a;
	B b;
	func(a);
	cout << "--------------------" << endl;
	func(b);

	system("pause");
	return 0;
}
#endif

多肽的实现手段： 

 从上面的代码可以看出，多肽是通过虚函数（virtual）来实现的，所以在两个类之前都要写virtual

多肽的分类：

多肽分为     静态多肽和动态多肽

   静态多肽：函数重载和泛型编程，在编译的时候已经确定，在编译的时候可以确定函数的地址。

   动态多肽：就是通过继承重写基类的虚函数实现的多态，因为实在运行时决议确定，所以称为动态多态。运行时在虚函数表中寻找调用函数的地址。

二、虚函数

动态多肽----------------------------------------

C++ 虚函数表解析_c++虚函数表解析_haoel的博客-CSDN博客

C++多态的实现原理_程序猿王老铁的博客-CSDN博客

上面已经说到了虚函数主要是为了实现多肽而生的。那么我们就是首先要认识几个概念

虚函数表：

#if 1
class  Persion
{
public :
	virtual void  Buy()
	{
		cout << "Persion   -virtual  " << endl;
	}
protected:
	string  name;
};
class  Me:public Persion
{
public :
	virtual void  Buy()
	{
		cout << "Me   -virtual  " << endl;
	}

	virtual void  Buy2()
	{
		cout << "Me   -virtual  " << endl;
	}
protected:
	int   id; //
};

void  Func(Persion  &p)
{
	p.Buy();
}
int   main()
{
	Persion  p;
	Me  me;

	Func(p);
	Func(me);
system("pause");
return 0;
 }
#endif

虚函数表

虚函数是通过一个虚函数表（virtual table ）来实现的，在这个表中主要是一个类的虚函数的地址，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数

#if 1

class  Base
{
public :
	virtual void f() { cout << "Base::f" << endl; }

	virtual void g() { cout << "Base::g" << endl; }

	virtual void h() { cout << "Base::h" << endl; }
 };

typedef void(*Fun)(void);
int main() 
{
	Base  b;
	Fun  pFun = NULL;
	cout << "函数表的地址   "<<(int *)(&b)<< endl;
	cout << "函数表一 第一个函数的地址   "<< (int*)*(int*)(&b) <<endl;
	cout << "函数表一 第二个函数的地址   " << ((int*)*(int*)(&b) + 1) << endl;
	cout << "函数表一 第三个函数的地址   " << ((int*)*(int*)(&b) + 2) << endl;
	system("pause");
	return 0;
 }
#endif



(Fun)*((int*)*(int*)(&b)+0);  // Base::f()

(Fun)*((int*)*(int*)(&b)+1);  // Base::g()

 (Fun)*((int*)*(int*)(&b)+2);  // Base::h()

一般的继承（无虚函数的覆盖）

子类没有重写父类的虚函数

class  Base
{
public :
	virtual void f() { cout << "Base::f" << endl; }

	virtual void g() { cout << "Base::g" << endl; }

	virtual void h() { cout << "Base::h" << endl; }
 };

typedef void(*Fun)(void);


class  SingleNovirtual :public Base
{
public:
	void func1() { cout << "SingleNovirtual::func1" << endl; }
	void func2() { cout << "SingleNovirtual::func2" << endl; }
};
int main() 
{
	Base  b;
	Fun  pFun = NULL;
	cout << "函数表的地址   "<<(int *)(&b)<< endl;
	cout << "函数表一 第一个函数的地址   "<< (int*)*(int*)(&b) <<endl;
	cout << "函数表一 第二个函数的地址   " << ((int*)*(int*)(&b) + 1) << endl;
	cout << "函数表一 第三个函数的地址   " << ((int*)*(int*)(&b) + 2) << endl;


	cout << "====================================" << endl;
	SingleNovirtual  nov;
	cout << "SingleNovirtual 函数表的地址   " << (int*)(&nov) << endl;   // 函数表的位置
	cout << "SingleNovirtual 函数表一 第一个函数的地址   " << (int*)*(int*)(&nov) << endl; //base f()
	cout << "SingleNovirtual 函数表一 第二个函数的地址   " << ((int*)*(int*)(&nov) + 1) << endl;//base f()
	cout << "SingleNovirtual 函数表一 第三个函数的地址   " << ((int*)*(int*)(&nov) + 2) << endl; //base h()
	cout << "SingleNovirtual 函数表一 第四个函数的地址   " << ((int*)*(int*)(&nov) + 3) << endl;  //func1
	cout << "SingleNovirtual 函数表一 第五个函数的地址   " << ((int*)*(int*)(&nov) + 4) << endl;   //func2
	system("pause");
	return 0;

 

 结论：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

一般的继承（有虚函数的覆盖）

#if 1  // 单继承
class Base
{
public:
	virtual void func1()
	{
		cout << "Base::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base::func2" << endl;
	}
private:
	int a;
};

class Derive :public Base
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}
	virtual void func4()
	{
		cout << "Derive::func4" << endl;
	}
private:
	int b;
};

typedef void (*FUNC) ();
void PrintVTable(int* VTable)
{
	cout << " 虚表地址>" << VTable << endl;

	for (int i = 0; VTable[i] != 0; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
		FUNC f = (FUNC)VTable[i];
		f();
	}
	cout << endl;
	cout << endl;
	cout << endl;
	cout << endl;
}

void Test1()
{
	Base b1;
	Derive d1;
	int* VTable1 = (int*)(*(int*)&b1);
	int* VTable2 = (int*)(*(int*)&d1);
	PrintVTable(VTable1);
	PrintVTable(VTable2);
}

int  main()
{
	Test1();
	system("pause");
    return 0;
}
#endif

 

 

 

 

 结论：

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

多重继承（无虚函数的覆盖）

 结论：

1）每个父类都有自己的虚表。

2）  子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的

多重继承（有虚函数的覆盖）

 

#if 1  // 多继承
class Base1
{
public:
	virtual void func1()
	{
		cout << "Base1::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base1::func2" << endl;
	}
private:
	int b1;
};
class Base2
{
public:
	virtual void func1()
	{
		cout << "Base2::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::func2" << endl;
	}
private:
	int b2;
};
class Derive : public Base1, public Base2
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}
private:
	int d1;
};

typedef void (*FUNC) ();
void PrintVTable(int* VTable)
{
	cout << " 虚表地址>" << VTable << endl;

	for (int i = 0; VTable[i] != 0; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, VTable[i]);
		cout << endl;
		FUNC f = (FUNC)VTable[i];
		//f();
	}

	cout << endl;
	cout << endl;
	cout << endl;
}

void Test1()
{
	Derive d1;
	int* VTable = (int*)(*(int*)&d1);
	PrintVTable(VTable);
	// Base2虚函数表在对象Base1后面    
	VTable = (int*)(*((int*)&d1 + sizeof(Base1) / 4));
	PrintVTable(VTable);
}

int  main()
{
	Test1();
	system("pause");
	return 0;
}
#endif

三、多肽中的析构

C++杂谈 为什么需要虚析构函数_Mo先生的博客-CSDN博客

为什么要把基类的析构函数定义为虚函数？

在用基类操作派生类时，为了防止执行基类的析构函数，不执行派生类的析构函数。因为这样的删除只能够删除基类对象, 而不能删除子类对象, 形成了删除一半形象, 会造成内存泄漏.如下代码：

#if 1
#include<iostream>  
using namespace std;

class Base
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	Base() {};
	~Base()
	{
		cout << "delete Base" << endl;
	};
};

class Base2
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	Base2() {};
	virtual  ~Base2()
	{
		cout << "delete _Base2" << endl;
	};
};

class Derived : public Base
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	Derived() {};
	~Derived()
	{
		cout << "delete Derived" << endl;

	};
};

class Derived2 : public Base2
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	Derived2() {};
	~Derived2()
	{
		cout << "delete Derived" << endl;

	};
};
int main()
{
	//操作1  
	Base* p1 = new Derived;
	delete p1;
	//因为这里子类的析构函数重写了父类的析构函数，虽然子类和父类的析构函数名不一样，  
	//但是编译器对析构函数做了特殊的处理，在内部子类和父类的析构函数名是一样的。  
	//所以如果不把父类的析构函数定义成虚函数，就不构成多态，由于父类的析构函数隐藏了子类  
	//的析构函数，所以只能调到父类的析构函数。  
	//但是若把父类的析构函数定义成虚函数，那么调用时就会直接调用子类的析构函数，  
	//由于子类析构先要去析构父类，在析构子类，这样就把子类和继承的父类都析构了  
	cout << "=====================" << endl;

	Base2* p2 = new Derived2;
	delete p2;
	system("pause");
	return 0;
}
#endif

C++ 多态的定义及实现_Gerald Kwok的博客-CSDN博客

基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，这也说明的基类的析构函数最好写成虚函数。

将析构函数定义为虚函数的原因：

因为基类指针可能指向派生类，当delete的时候，如果不定为虚函数，系统会直接调用基类的析构函数，这个时候派生类就有一部分没有被释放，就会造成可怕的内存泄漏问题。

若定义为虚函数构成多态，那么就会先调用派生类的析构函数然后派生类的析构函数会自动调用基类的析构函数，这个结果满足我们的本意。

所以！在继承的时候，尽量把基类的析构函数定义为虚函数，这样继承下去的派生类的析构函数也会被变成虚函数构成多态。

抽象类：

在虚函数的后面写上 =0 ，则这个函数就变成纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

这个纯虚函数的作用就是强迫我们重写虚函数，构成多态。这样更加体现出了接口继承。

#include <iostream>

class Person
{
public:
    virtual void Strength() = 0;
};

class Adult : public Person
{
public:
    virtual void Strength()
    {   
        std::cout << "Adult have big Strength!" << std::endl;
    }   
};

class Child : public Person
{
public:
    virtual void Strength()
    {   
        std::cout << "Child have Small Strength!" << std::endl;                                                                                   
    }   
};

总结：

C++虚函数分析_51CTO博客_c++虚函数

1.虚函数(impure virtual)

　　c++虚函数主要是提供“运行时多态”，父类提供虚函数的默认实现，子类可以虚函数进行重写。

2.纯虚函数(pure virtual)

      c++纯虚函数也是“运行时多态”，父类不能提供函数的实现，子类提供函数的实现。包含纯虚函数的类，称为“”抽象类“”，无法用new

实现对象，只能实现了虚函数的子类才可以new。

3.普通函数(no-virtual)

     普通函数是静态编译的，是父类给子类提供的强制实现。

4,多态概念

   相同对象收到不同消息或不同对象收到相同消息产生不同动作

    1）静态多态  编译的时候根据参数个数调用哪个函数，这种情况叫做静态编译。

     2）动态多态 运行的时候，根据调用的函数决定调用的是哪个函数。

5，多态中存在的问题

    内存泄露，当用delete父类的对象时，只会调用父类的析构函数。如果子类new了一些对象，在析构函数里面释放，就会导致内存泄露。

          用virtual修饰析构函数，这样父类指针指向的是那个对象，那个对象的析构函数就会先执行，再执行父类的析构函数。

    vertual在函数的使用限制

        1）全局函数不能是虚函数，否则会导致编译错误；

        2）static函数不属于任何对象，也不能是虚函数，否则会导致编译错误

        3）如果内联函数被virtual修饰，计算机就会忽略inline编程，编程纯粹的虚函数。

　　 4）构造函数不是是虚函数，否则会报编译错误。

6，接口类

      如果在抽象类中仅含虚函数而不含其它任何东西，我们称为接口类

       1，没有任何数据成员；

       2，仅有函数成员；

       3，函数成员都是纯虚函数。

面试题：

那些函数不能定义为虚函数？

1）友元函数，它不是类的成员函数
2）全局函数
3）静态成员函数，它没有this指针
3）构造函数，拷贝构造函数，以及赋值运算符重载（可以但是一般不建议作为虚函数）