C++语法——详细剖析多态与虚函数

目录

一.虚函数与多态的概念与基本使用

（一）.概念

（二）.基本使用

二.虚函数的底层

三.特殊的虚函数（协变）

四.多态在多继承、菱形继承与菱形虚拟继承中的使用。

（一）.多继承

（二）.菱形继承、菱形虚拟继承

五.析构函数和不能声明为虚函数的函数

六.override与回避虚函数

（一）.override

（二）.回避虚函数

---

一.虚函数与多态的概念与基本使用

（一）.概念

所谓虚函数就是当通过指针或引用调用该函数时，编译器不会在编译时确定该函数地址，而是在运行时通过指针或引用的具体对象类型进行动态绑定。

正因为虚函数的这种特性，可以说它“天生”就是为多态准备的。

多态是OOP的核心思想，含义是“多种形式”。当我们通过父类的指针或引用调用父类定义的虚函数时，并不会在编译时就清楚它的地址，只有当运行时确定了具体的对象类型，才会根据该对象类型调用该类型重写的该函数。

多态又分为动态绑定与静态绑定。静态绑定即编译时确定调用的具体函数，比如函数重载和子类函数重定义（隐藏）。动态绑定即运行时确定调用的具体函数，比如虚函数的重写。而我们重点讨论动态绑定的多态。

换一种说法，假设人是一种父类，其中皮肤是虚函数，派生出了黑人、白人、黄种人三个子类，各自重写了皮肤函数为黑色、白色、黄色。当我们用“人”指针指向子类，调用皮肤函数时，在不清楚指针指向时并不知道其具体肤色，只有知道指向后才能根据子类调用正确肤色。这就是动态绑定的多态，即运行时多态。

用图来理解就是这样：

用代码演示一下：

class human//人
{
public:
	virtual void skin()
	{
		cout << "~" << endl;
	}
};
class Black : public human//黑人
{
public:
	void skin()//虚函数重写
	{
		cout << "black" << endl;
	}
};
class White : public human//白人
{
public:
	void skin()//虚函数重写
	{
		cout << "white" << endl;
	}
};
class Yellow : public human//黄种人
{
public:
	void skin()//虚函数重写
	{
		cout << "yellow" << endl;
	}
};
void GetSkinColor(human* p)
{
    cout << "My shin color is :";
	p->skin();//通过父类指针或引用进行多态调用
}
int main()
{
	human h;
	Black b;
	White w;
	Yellow y;
	human* hptr = &h, *bptr = &b, *wptr = &w, *yptr = &y;
	GetSkinColor(hptr);
	GetSkinColor(bptr);
	GetSkinColor(wptr);
	GetSkinColor(yptr);
	return 0;
}
 

（二）.基本使用

如果想进行多态调用，必须满足三点条件：虚函数、重写、父类指针或引用调用该函数。

虚函数注意事项：如果父类中该函数未声明为虚函数，即便子类进行声明也不是虚函数。

即虚函数必须是由父类进行声明。

重写的含义：子类该函数的函数名、返回值、参数（个数、种类、位置）与父类相同。

满足以上三种条件的才会构成多态。

同时一定注意的是，重写的虚函数即便有缺省参数（默认形参），那也会使用父类的缺省。因为重写只是改变函数内部的实现，对于函数参数列表则还是使用父类的。

二.虚函数的底层

在使用虚函数时，编译器会为该类型创建一个虚函数表（简称虚表）。虚表中装有该类型虚函数地址。重写的装自己重写的地址，未重写的装父类虚函数地址。

虚函数表在编译时就会生成，存放在常量区。

虚表指针在构造对象时才会生成。

在派生的子类中，虚表指针在父类区域中，指针指向对应的虚表。

当进行多态调用时，如果是虚函数，那么编译器就会从该类型的虚表中找对应函数的地址完成调用。正因为继承关系的类的虚表中存有的函数地址并不相同，因此当通过父类指针指向某一对象进行虚函数调用时会根据对象的真实类型完成不同函数的调用。

当然，虚表内存有虚函数地址也只是理论上，实际不同的编译器有不同的处理方法。

比如vs环境下，虚表内装的是中转地址，当通过虚表寻找具体虚函数时，会先找到这个中转地址，

再通过中转地址jump到真正的虚函数。

百闻不如一见，我们看底层：

小编这里依旧使用之前的例子做解释，这里我们选择黑人类的对象b：

三.特殊的虚函数（协变）

当然，虚函数的定义中存在特例：

1.子类可以不写virtual，只需要父类定义该函数时声明为virtual，之后当子类重写时可以不加上virtual，其依旧是虚函数。

2.协变，当函数返回值是类本身的指针或引用时，也构成虚函数的重写。这主要应用于虚拷贝。

比如实现一个虚函数用于返回当前对象类型的拷贝，就需要用到协变。因为假如返回值相同，那么即便指针指向子类对象，其返回值也是父类类型，这显然不是我们希望看见的。

下面是错误代码：

代码本意是希望当创建子类指针时能通过子类内部Copy函数拷贝一份。

class A
{
public:
	A(int _i)
		:i(_i)
	{}
 
	virtual A* Copy()
	{
		return new A(*this);
	}
 
	int i = 0;
};
class B : public A
{
public:
	B(int _i)
		:A(_i)
	{}
	A* Copy()
	{
		return new B(*this);
	}
 
};
int main()
{
	B b(2);
	B* c = b.Copy();
	return 0;
}

 因为返回值是父类指针，子类指针无法接收，进而导致我们无法实现相关操作。

所以，协变应运而生：

class B : public A
{
public:
	B(int _i)
		:A(_i)
	{}
	B* Copy()//协变+虚函数重写
	{
		return new B(*this);
	}
 
};

四.多态在多继承、菱形继承与菱形虚拟继承中的使用。

（一）.多继承

普通多继承时，对象中每个父类的区域都会有一个虚表指针指向对应的虚表。

class A
{
public:
	virtual void func()
	{
		cout << "A";
	}
 
};
class B 
{
public:
	virtual void func()
	{
		cout << "B";
	}
 
};
class C : public A, public B
{
public:
	void func()
	{
		cout << "c";
	}
};
int main()
{
	C c;
 
	return 0;
}

 虽然c对象中两个虚表中存放的值不同，但都是指向c类型重写的func函数。虚表中的值是跳转地址，因此不同。

此外，B类区域的跳转地址并不是直接转到真正函数地址，而是通过改变ebp寄存器位置到A类区域，再通过A类的虚表找到真正函数地址。

同时，需要注意，如果子类自己声明了一个虚函数，会入首先继承的父类区域虚表中，只是vs环境下调试无法在虚表中看到。 

（二）.菱形继承、菱形虚拟继承

在实际开发中，我们并不推荐使用菱形和菱形虚拟继承，这往往会使问题复杂化。

比如我们看如下代码：

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

如果D单纯继承自B和C，那么编译会报错，因为这会引发二义性。我们仔细想想，B和C是虚继承自A类，那么当实例化D对象时，其内部只会有一个A类区域。由于func函数是A类声明的，那么对应的虚表指针就在A区域中。当B和C类重写func函数时，指针就不清楚是该指向B对应的函数还是C对应的函数，从而引发二义性。

因此，需要在D类中重写func函数，从而避免二义性。

在调试窗口 可以看到，只有一个虚表指针：

但是当我们往B和C类中声明自己的虚函数时，又会发生不一样的现象：

class A
{
public:
	virtual void func()
	{
		cout << "A";
	}
 
};
class B : public virtual A
{
public:
	void func()
	{
		cout << "B";
	}
	virtual void test()
	{
		cout << "testB";
	}
 
};
class C : public virtual A
{
public:
	void func()
	{
		cout << "c";
	}
	virtual void test()
	{
		cout << "testC";
	}
 
};
class D : public B,public  C
{
public:
	void func()
	{
		cout << "D";
	}
};

 这是，由于B和C都有了自己声明的虚函数test，因此势必要创建一个虚表指向自己的test函数，同时各自又会创建一个虚表指针。

当使用D对象调用test函数时，还需要注意二义性的问题，因为此时D对象中有两个test函数，分别位于B和C的区域。

经过调试可以更清楚一些：

五.析构函数和不能声明为虚函数的函数

static函数不能声明为虚函数，这是因为static函数是静态绑定，即编译时就确定，而虚函数在运行时才能确定，属于动态绑定。

构造、拷贝构造函数不能声明为虚函数，这是因为在调用构造函数时，虚表指针尚未创建，更无从谈起虚函数。

析构函数建议是虚函数，因为即便是使用父类指针或引用调用子类对象，在析构时也是会希望析构子类。

内联函数inline虽然可以和虚函数同时使用，但是并无实际意义。同时虚函数要求运行时确定，而内联则在编译时确定，但内联只是一种建议，因此编译时并不会选择内联展开。

六.override与回避虚函数

（一）.override

override是C++11新规定的说明符，用于检查子类的虚函数是否完成了重写。

class A
{
    public:
        vitrtual void func1();
        vitrtual void func2();
        void func3();
}
class B : A
{
    public:
        void func1() override;//正确，完成重写
        void func2(int) override;//错误，未完成重写
        void func3() override;//错误，不是虚函数
        void func4() overide;//错误，父类没有该虚函数
}

（参考代码：《C++ Primer》p538） 

（二）.回避虚函数

有时，我们希望调用虚函数其他版本，而不是动态绑定，这时就需要使用回避函数。具体情况就是子类的虚函数需要调用父类该虚函数共同完成任务时。

这时需要使用作用域运算符完成任务。

class B : A
{
    public:
        virtual void func()
        {
            A::func();//强制调用父类虚函数
        }
}

如果函数内部在调用时没有加上父类的作用域，那么函数会一直递归调用本函数，造成死循环。

就算它工作不正常也别担心。如果一切正常，你早该失业了——Mosher

---

如有错误，敬请斧正