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

多肽的分类：

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

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

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

二、虚函数

什么事虚函数？

虚函数：被 virtual 关键字修饰的成员函数，就是虚函数。

什么事纯虚函数？

虚函数是在类的申明中加上=0，如

#if 1  

class AA  //只要含有虚函数这个类就不是抽象类
{
public:
    virtual  void  Func1()
    {

    }
    void Func2()
    {

    }

};


 class A  //只要含有纯虚函数这个类就是抽象类
{
public  :
    virtual  void  Func1()
    {

    }
    void Func2()
    {

    }
    virtual  void  Func3() = 0;  // 纯虚函数  

    virtual  void  Func4() = 0;  // 纯虚函数  
};

 class B : public A  // 不能new
 {
 public:
     virtual  void  Func3()
     {
         cout << "B : public A  Func3Func3 " << endl;
     }
 };

 class C : public A  // 实现A中的全部的纯虚函数之后才能new   
 {
 public:
     virtual  void  Func3()
     {
         cout << "B : public A  Func3Func3 " << endl;
     }


     virtual  void  Func4()
     {
         cout << "B : public A  Func3Func3 " << endl;
     }
 };

int  main()
{
    AA* pm = new AA();// 只有虚函数的类不是抽象类，是可以new 的

    A* p = new A();   // 报错，抽象类是不能new 的

    A* p2 = new B();  //  报错  

    A* p3 = new C();


    return 0;
}
#endif // 0

• 含有纯虚函数的类称为抽象类（只要含有纯虚函数这个类就是抽象类），类中只有接口，没有具体的实现方法；
• 继承纯虚函数的派生类，如果没有完全实现基类纯虚函数，依然是抽象类，不能实例化对象

 虚函数和纯虚函数的区别？

• 含有纯虚函数的类称为抽象基类，只有虚函数
• 使用方式不同：虚函数可以直接使用，纯虚函数必须在派生类中实现后才能使用；
• 定义形式不同：虚函数在定义时在普通函数的基础上加上 virtual 关键字，纯虚函数定义时除了加上virtual 关键字还需要加上 =0;
• 虚函数必须实现，否则编译器会报错；
• 对于实现纯虚函数的派生类，该纯虚函数在派生类中被称为虚函数，虚函数和纯虚函数都可以在派生类中重写；
• 析构函数最好定义为虚函数，特别是对于含有继承关系的类；析构函数可以定义为纯虚函数，此时，其所在的类为抽象基类，不能创建实例化对象。

动态多肽---

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()

Leetcode——C++突击面试_leetcode c++ 面试突破-CSDN博客

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

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

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;

 

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void B_fun1() { cout << "Base::B_fun1()" << endl; }
    virtual void B_fun2() { cout << "Base::B_fun2()" << endl; }
    virtual void B_fun3() { cout << "Base::B_fun3()" << endl; }
};

class Derive : public Base
{
public:
    virtual void D_fun1() { cout << "Derive::D_fun1()" << endl; }
    virtual void D_fun2() { cout << "Derive::D_fun2()" << endl; }
    virtual void D_fun3() { cout << "Derive::D_fun3()" << endl; }
};
int main()
{
    Base *p = new Derive();
    p->B_fun1(); // Base::B_fun1()
    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

 

 

 

 

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void fun1() { cout << "Base::fun1()" << endl; }
    virtual void B_fun2() { cout << "Base::B_fun2()" << endl; }
    virtual void B_fun3() { cout << "Base::B_fun3()" << endl; }
};

class Derive : public Base
{
public:
    virtual void fun1() { cout << "Derive::fun1()" << endl; }
    virtual void D_fun2() { cout << "Derive::D_fun2()" << endl; }
    virtual void D_fun3() { cout << "Derive::D_fun3()" << endl; }
};
int main()
{
    Base *p = new Derive();
    p->fun1(); // Derive::fun1()
    return 0;
}

 

 结论：

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

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

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

#include <iostream>
using namespace std;

class Base1
{
public:
    virtual void B1_fun1() { cout << "Base1::B1_fun1()" << endl; }
    virtual void B1_fun2() { cout << "Base1::B1_fun2()" << endl; }
    virtual void B1_fun3() { cout << "Base1::B1_fun3()" << endl; }
};
class Base2
{
public:
    virtual void B2_fun1() { cout << "Base2::B2_fun1()" << endl; }
    virtual void B2_fun2() { cout << "Base2::B2_fun2()" << endl; }
    virtual void B2_fun3() { cout << "Base2::B2_fun3()" << endl; }
};
class Base3
{
public:
    virtual void B3_fun1() { cout << "Base3::B3_fun1()" << endl; }
    virtual void B3_fun2() { cout << "Base3::B3_fun2()" << endl; }
    virtual void B3_fun3() { cout << "Base3::B3_fun3()" << endl; }
};

class Derive : public Base1, public Base2, public Base3
{
public:
    virtual void D_fun1() { cout << "Derive::D_fun1()" << endl; }
    virtual void D_fun2() { cout << "Derive::D_fun2()" << endl; }
    virtual void D_fun3() { cout << "Derive::D_fun3()" << endl; }
};

int main(){
    Base1 *p = new Derive();
    p->B1_fun1(); // Base1::B1_fun1()
    return 0;
}

 

 结论：

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

#include <iostream>
using namespace std;

class Base1
{
public:
    virtual void fun1() { cout << "Base1::fun1()" << endl; }
    virtual void B1_fun2() { cout << "Base1::B1_fun2()" << endl; }
    virtual void B1_fun3() { cout << "Base1::B1_fun3()" << endl; }
};
class Base2
{
public:
    virtual void fun1() { cout << "Base2::fun1()" << endl; }
    virtual void B2_fun2() { cout << "Base2::B2_fun2()" << endl; }
    virtual void B2_fun3() { cout << "Base2::B2_fun3()" << endl; }
};
class Base3
{
public:
    virtual void fun1() { cout << "Base3::fun1()" << endl; }
    virtual void B3_fun2() { cout << "Base3::B3_fun2()" << endl; }
    virtual void B3_fun3() { cout << "Base3::B3_fun3()" << endl; }
};

class Derive : public Base1, public Base2, public Base3
{
public:
    virtual void fun1() { cout << "Derive::fun1()" << endl; }
    virtual void D_fun2() { cout << "Derive::D_fun2()" << endl; }
    virtual void D_fun3() { cout << "Derive::D_fun3()" << endl; }
};

int main(){
    Base1 *p1 = new Derive();
    Base2 *p2 = new Derive();
    Base3 *p3 = new Derive();
    p1->fun1(); // Derive::fun1()
    p2->fun1(); // Derive::fun1()
    p3->fun1(); // Derive::fun1()
    return 0;
}

 

 

三、多肽中的析构

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

​​​​​​​

为啥构造函数不能为虚函数

虚函数的调用是用虚函数指针来调用的，在构造之前还没有将这个指针放到对象中，如果将构造函数变成虚函数，那么就是在对象还没有创建空间哪来的指针

为啥析构函数一定是虚函数，不然会有什么后果？？ 

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

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

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

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

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

多态中存在的问题

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

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

    vertual在函数的使用限制

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

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

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

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

面试题：

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

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