C++技能进阶指南——多态语法剖析

        前言：多态是面向对象的三大特性之一。顾名思义， 多态就是多种状态。 那么是什么的多种状态呢？ 这里的可能有很多。比如我们去买火车票， 有普通票， 学生票； 又比如我们去旅游， 有儿童票， 有成人票等等。 这些都是多态的例子。 具体转化为我们的编程思想就是：让不同类型的对象去完成相同的事， 这就是多态。

        本篇内容主要讲述多态， 多为语法方面的知识点。 适合已经学完继承的友友们观看。

        

目录

一、多态的相关概念

1.1虚函数

1.2虚函数的重写

1.3虚函数重写的两个例外

 1.4override 和 final 的使用

二、重载、重写、隐藏（重定义）的区别

三、如何构成多态

四、抽象类

五、普通继承和接口继承

六、静态绑定和动态绑定

---

具体什么是多态在前言中已经提到， 正文部分不做赘述。

一、多态的相关概念

1.1虚函数

        被virtual关键字修饰的成员函数叫做虚函数。 例如：

//A位基类
class A 
{
public:
 
	virtual void func()    //定义一个虚函数
	{
		cout << "Afunc()" << endl;
	}
};

         需要注意的是， 对于构造函数和析构函数来说。 析构函数可以是虚函数， 但是构造函数不可以是虚函数。 

具体原因如下：（建议看完整篇文章和总结虚函数表机制——c++多态底层原理-CSDN博客​​​​​​ 之后再来看下面这段解释）：

        首先：通过之前的学习， 我们知道了， 虚函数的地址是存在虚函数表里面的。 想要调用对应的虚函数， 我们需要先去虚函数表中寻找对应虚函数的地址。 但是虚函数表是在构造函数的初始化列表初始化的。如果构造函数是虚函数， 那么调用构造函数的时候就找不到。 所以构造函数没办法是虚函数。

1.2虚函数的重写

        虚函数的重写就是： 在派生类当中， 有一个和基类中某一个虚函数函数头的虚函数（函数头就是：函数的返回值， 函数名， 函数的参数列表）。 这个时候就会构成虚函数的重写, 即 子类重写了基类的虚函数。

//A位基类
class A 
{
public:
 
	virtual void func() 
	{
		cout << "Afunc()" << endl;
	}
};
 
//B类继承A类
class B : public A
{
public:
	
	//重写A类的func函数
	virtual void func()  //注意， 这里的virtual可以不写， 因为编译器默认这里是加了virtual的
	{
		cout << "Bfunc()" << endl;
	}
};

        需要注意的是， 上图中派生类的func可以不加virtual， 因为基类的func是虚函数， 编译器会默认派生类中和他函数头相同的函数也是虚函数。 

1.3虚函数重写的两个例外

        协变:派生类在重写基类的虚函数的时候， 与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用， 派生类虚函数返回派生类对象的指针或者引用的时候， 成为协变。

 
//A位基类
class A
{
public:
 
	virtual A* func()
	{
		cout << "Afunc()" << endl;
	}
};
 
//B类继承A类
class B : public A
{
public:
 
	//重写A类的func函数
	virtual B* func()
	{
		cout << "Bfunc()" << endl;
	}
};
 
//C类继承A类
class C : public A
{
	virtual C* func()
	{
		cout << "Cfunc" << endl;
	}
};

    

        析构函数的重写: 基类析构函数如果加了virtual， 那么说明基类的析构函数为虚函数。 这个时候如果派生类的析构函数也就变成了虚函数。 那么成不成为虚函数对于析构函数来说有什么不同呢？

        首先我们需要知道的是， 在一个普通的类之中， 编译器其实将析构函数统一处理成为了destructor。

        然后， 对于一个派生类来说， 如果它的析构函数不是虚函数。 当我们使用父类的指针构成多态时， 只会析构派生类的一部分:

//A位基类
class A
{
public:
 
	virtual A* func()
	{
		cout << "Afunc()" << endl;
	}
 
    //其他动态内存分配的空间
    //int* ...
    //double* ...
};
 
//B类继承A类
class B : public A
{
public:
 
	//重写A类的func函数
	virtual B* func()
	{
		cout << "Bfunc()" << endl;
	}
 
    //其他动态内存分配的空间
    //int* ...
    //double* ...
};
 
 
void test_func(A* p)
{
	p->func();
}
 
 
int main() 
{
	C c;
 
	A* p = nullptr;
	p = &c;
 
	delete p;
	return 0;
}

         如上图， 假如delete p， 那么就只能释放属于C类自己的那一部分。那么属于A类的那一部分将得不到释放。 

        但是， 如果我们对A类的析构函数使用虚函数。 那么派生类的析构函数也变成了虚函数， 这个时候如果再形成多态。delete p就能将A类和C类都释放掉。

 
//A位基类
class A
{
public:
 
	virtual A* func()
	{
		cout << "Afunc()" << endl;
	}
 
	virtual ~A() 
	{}
};
 
//B类继承A类
class B : public A
{
public:
	//重写A类的func函数
	virtual B* func()
	{
		cout << "Bfunc()" << endl;
	}
 
	virtual ~B()
	{}
};

 1.4override 和 final 的使用

先谈override， override是用来检验某个虚函数是否构成了重写。如果没有构成重写， 那么编译器就会报错。

        如下为构成重写:

//A位基类
class A
{
public:
 
	virtual void func()
	{
		cout << "Afunc()" << endl;
	}
 
};
//B类继承A类
class B : public A
{
public:
	//重写A类的func函数
	virtual void func() override
	{
		cout << "Bfunc()" << endl;
	}
 
};

如下为没有构成重写：

 
//A位基类
class A
{
public:
 
	void func()
	{
		cout << "Afunc()" << endl;
	}
};
//B类继承A类
class B : public A
{
public:
	//重写A类的func函数
	virtual void func() override
	{
		cout << "Bfunc()" << endl;
	}
 
};

二、重载、重写、隐藏（重定义）的区别

• 重载： 函数处于相同作用域内， 并且函数的函数名相同， 参数不同。
• 重写： 函数分别处于基类和派生类中，并且都是虚函数， 并且有相同的函数头
• 隐藏： 继承体系中函数分别处在基类和派生类的作用与之中， 不是虚函数，并且都具有相同的函数头

三、如何构成多态

        要形成多态有两个条件：

• 一、虚函数的重写。
• 二、父类的指针指向子类,或者父类的引用引用子类对象。

        如下为一个多态的实例：

//A位基类
class A 
{
public:
 
	virtual void func() 
	{
		cout << "Afunc()" << endl;
	}
};
 
//B类继承A类
class B : public A
{
public:
	
	virtual void func() 
	{
		cout << "Bfunc()" << endl;
	}
};
 
//C类继承A类
class C : public A
{
	virtual void func() 
	{
		cout << "Cfunc" << endl;
	}
};
 
int main() 
{
	C c;
	B b;
	A* p = nullptr;
	p = &c;
	p->func();
	p = &b;
	p->func();
	return 0;
}

         在这串代码中， B类和C类都是A类的派生类。 他们都有对A类中的虚函数func进行重写， 满足条件一。 

        然后基类的指针p先是指向了C类的对象。 又指向了B类的对象。 构成了父类的指针指向子类， 满足条件二。

        所以， 这就是一个多态。

其实， 多态的应用场景多为这样：

 
//A位基类
class A 
{
public:
 
	virtual void func() 
	{
		cout << "Afunc()" << endl;
	}
};
 
//B类继承A类
class B : public A
{
public:
	
	virtual void func() 
	{
		cout << "Bfunc()" << endl;
	}
};
 
//C类继承A类
class C : public A
{
	virtual void func() 
	{
		cout << "Cfunc" << endl;
	}
};
 
 
void test_func(A* p) 
{
	p->func();
}
 
 
int main() 
{
	C c;
	B b;
	test_func(&b);
	test_func(&c);
	return 0;
}

        这样， 通过传送不同类型的对象给test_func函数， 就能构成多态。

四、抽象类

        如果一个虚函数后面加上 =0， 那么这个虚函数就是纯虚函数， 并且包含这个纯虚函数的类叫做抽象类。

        抽象类不能实例化对象。

 
//A位基类
class A
{
public:
 
	virtual void func() = 0;
};
 
 
 
int main() 
{
	A a;
 
	return 0;
}

但是A的派生类如果重写了纯虚函数， 那么就可以这个派生类就可以实例化处对象。

但是如果A的派生类没有重写纯虚函数， 那么这个派生类同样不能实例化处对象。

 
//A位基类
class A
{
public:
	virtual void func() = 0;
};
 
//B类继承A类
class B : public A
{
public:
	//重写A类的func函数
};
 
int main() 
{
	B b;
	return 0;
}

五、普通继承和接口继承

        普通继承：在继承体系中， 派生类继承了基类的函数， 能够直接使用的是普通继承， 这类继承继承的是基类函数的实现。 

        接口继承：如果继承了基类的虚函数， 并且重写实现了多态。 那么就是一种接口继承， 多态的体系是一种接口的继承， 具体的函数实现是由派生类自己实现的。

六、静态绑定和动态绑定

        静态绑定： 静态绑定又被成为前期绑定,  当程序在编译的时候确定的要调用的函数， 确定了程序要执行的行为， 这个过程成为静态多态。 比如我们使用的函数重载就是静态的多态。

        动态绑定： 动态绑定又被成为后期绑定， 当程序在编译之后也就是运行期间根据不同的对象调用不同的函数。 这个过程叫做动态多态， 也就是多态。

------------------------------------------------------

ps： 本篇内容没有讲解多态的原理， 因为多态的原理其实就是虚函数表。 而虚函数表的详细讲解博主之前已经写过一篇： 总结虚函数表机制——c++多态底层原理-CSDN博客 。

        在这篇文章中， 博主用自己的理解讲解的虚函数表的机制与实现。 写的不甚严谨， 但是里面的结论却是博主通过调试一步一步验证的来的。感兴趣的友友们可以看一下。

后续补带有虚函数的类的内存大小的计算（暂时有点模糊， 先不写， 而且最近考试比较多。可能要等暑假才能补上这一板块）。