多态与友元学习（C++）大白话系列

多态

使用背景

为了提高程序的复用性，降低大量相似的程序的重复。

比如我设置了苹果，香蕉，西瓜类，现在想把这些东西都装到碗这个函数里，那么在主函数当中，声明对象是必须的，但是每一次装进碗里对于水果来说，都要用自己的指针调用一次装的功能，那为什么不把这些类抽象成一个水果类呢，直接定义一个水果类的指针一次性调用所有水果装的功能呢，这个就是利用父类指针去调用子类成员，但是这个思想受到了指针指向类型的限制，也就是说表面指针指向了子类成员，但实际上还是只能调用子类成员里的父类成员，这样的思想就变的毫无意义了，如果想要解决这个问题，只要在父类前加上virtual就可以解决了，这里就是利用虚函数实现多态的实例。

多态的概念

多态是c++的特点之一，关于多态，简而言之就是 用父类的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数，这种方法呢，可以让父类的指针具有多种形态，也就是说不需要改动很多的代码就可以让父类这一种指针，干一些很多子类指针的事情，这里是从虚函数的实现机制层面进行研究。c++中虚函数表的作用主要是实现了多态的机制。

例子：虚函数实现多态

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void point()=0;
	virtual void func()
	{
		cout << "Base!" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void func()
	{
		cout << "Derived!" << endl;
	}
	virtual void point()
	{
		cout << "X=1, Y=2" << endl;
	}
};

class Child : public Derived
{
	public:
	virtual void point()
	{
		cout << "X=3, Y=4" << endl;
	}
};

void show(Base& b)
{
	b.func();
}
Base base;   //有了纯虚函数就成了抽象类，就无法再次定义具体的对象了，无法进行实例化操作。
Derived derived;
//Child child;

int main()
{
	show(base);
	show(derived);
	base.func();
	derived.func();
	derived.point();
	//child.point();
	return 0;
}

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d619HNxJ-1641119064739)(/Users/yanghaiguang/Nutstore Files/.symlinks/坚果云/多传感器融合-深蓝/自动驾驶技术/images/duotai-1.png)]

例子：含有纯虚函数

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void point()=0;
	virtual void func()
	{
		cout << "Base!" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void func()
	{
		cout << "Derived!" << endl;
	}
	virtual void point()
	{
		cout << "X=1, Y=2" << endl;
	}
};

class Child : public Derived
{
	public:
	virtual void point()
	{
		cout << "X=3, Y=4" << endl;
	}
};

void show(Base& b)
{
	b.func();
}
//Base base;   //有了纯虚函数就成了抽象类，就无法再次定义具体的对象了，无法进行实例化操作。
Derived derived;
Child child;

int main()
{
	//show(base);
	show(derived);
	//base.func();
	derived.func();
	derived.point();
	child.point();
	return 0;
}

输出：

Derived!
Derived!
X=1, Y=2
X=3, Y=4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o4Cohxn0-1641119064740)(/Users/yanghaiguang/Nutstore Files/.symlinks/坚果云/多传感器融合-深蓝/自动驾驶技术/images/duotai-2.png)]

参考自：C++纯虚函数_xy的博客-CSDN博客_c++ 纯虚函数

多态涉及到继承，继承的分类如下：

父类的函数如何访问子类的虚函数？

该指针指向一个在堆上实例化的子类对象。基类如果存在虚函数，那么在子类对象中，除了成员函数与成员变量外，编译器会自动生成一个指向**该类的虚函数表(这里是类ClassB)**的指针，叫作虚函数表指针。通过虚函数表指针，父类指针即可调用该虚函数表中所有的虚函数。

假设有一个基类ClassA，一个继承了该基类的派生类ClassB，并且基类中有虚函数，派生类实现了基类的虚函数。
我们在代码中运用多态这个特性时，通常以两种方式起手：
(1) ClassA *a = new ClassB();
(2) ClassB b; ClassA *a = &b;
以上两种方式都是用基类指针去指向一个派生类实例，区别在于第1个用了new关键字而分配在堆上，第2个分配在栈上。

---

类的虚函数表与类实例的虚函数指针

首先不考虑继承的情况。如果一个类中有虚函数，那么该类就有一个虚函数表。
这个虚函数表是属于类的，所有该类的实例化对象中都会有一个虚函数表指针去指向该类的虚函数表。
从第一部分的图中我们也能看到，一个类的实例要么在堆上，要么在栈上。也就是说一个类可以有很多很多个实例。但是！一个类只能有一个虚函数表。在编译时，一个类的虚函数表就确定了，这也是为什么它放在了只读数据段中。

多重继承

注意：
1.子类虚函数会覆盖每一个父类的每一个同名虚函数。
2.父类中没有的虚函数而子类有，填入第一个虚函数表中，且用父类指针是不能调用。
3.父类中有的虚函数而子类没有，则不覆盖。仅子类和该父类指针能调用。

(1) ClassA *a = new ClassB();
(2) ClassB b; ClassA *a = &b;

详细解读参见：C++多态虚函数表详解(多重继承、多继承情况)

大白话总结

什么是多态？

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

多态的实现方式分析？

实现多态，有二种方式，覆盖，重载。覆盖：是指子类重新定义父类的虚函数的做法。重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

分析：

“重载”是指在同一个类中相同的返回类型和方法名，但是参数的个数和类型可以不同

“覆盖\重写”是在不同的类中。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

另一篇写的不错的帖子（C++中的多态机制）

从静态联编和动态连编等多角度阐述了多态，很值得学习。

静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数就调用，没有的话就会发出警告或者报错；如函数重载，非虚函数重写；

动态多态是在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。如虚函数重写，switch 语句和 if 语句。

这种多态行为的表现效果为：同样的调用语句在实际运行时有多种不同的表现形态。

那么在c++中，如何实现这种表现效果呢？（实现多态的条件）

1. 要有继承

2. 要有虚函数重写（被 virtual 声明的函数叫虚函数）

3. 要有父类指针（父类引用）指向子类对象

关于虚函数：

调用效率：虚函数要低于普通成员函数。

函数重载

根据上下文可以知道每种情况下，root的含义是什么，同样，C++中也通过上下文来确定同名函数的重载版本。
重载函数的关键是函数参数列表——也称函数特征标。包括：函数的参数数目和类型，以及参数的排列顺序。所以，重载函数与返回值，参数名无关。

// print()函数
void print(const char* str,int width);
void print(double i ,int width);
void print(const char* str);
// 使用print()函数时，编译器将根据所采取的用法使用有相应特征标的原型
print("abc",12);
print(2.2,55);
print("def");

以下这种方式的重载是错误的

void print(const char* str,int width);
int print(const char* str,int width);

重载时返回值可以不同，但特征标也必须不同。

函数模板

函数模板是通用的函数描述，也就是说，使用泛型来定义函数，其中泛型可用具体的类型（int 、double等）替换。通过将类型作为参数，传递给模板，可使编译器生成该类型的函数。将函数的类型作为变量，一套模板可以适配不同类型的函数，提高了重复使用率。

// 交换两个值，但是不清楚是int 还是 double，如果不使用模板，则要写两份代码
// 使用函数模板，将类型作为参数传递
template<class T>
class Swa(T a,T b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
};

动态多态

动态多态（动态绑定）：即运行时的多态，在程序执行期间(非编译期)判断所引用对象的实际类型，根据其实际类型调用相应的方法。

父类指针如何调用子类虚函数？要程序实现。

new

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void point()=0; //纯虚函数
	virtual void func()
	{
		cout << "Base!" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void func()
	{
		cout << "Derived!" << endl;
	}
	virtual void point()
	{
		cout << "X=1, Y=2" << endl;
	}
	void signal() {
		cout<<"class Derived signal"<<endl;
	}

};

class Child : public Derived
{
	public:
	virtual void func()
	{
		cout << "Child!" << endl;
	}
	virtual void point()
	{
		cout << "X=3, Y=4" << endl;
	}
	void signal() {
		cout<<"class child signal"<<endl;
	}
};

void show(Base& b)
{
	b.func();
}
//Base base;   //有了纯虚函数就成了抽象类，就无法再次定义具体的对象了，无法进行实例化操作。


int main()
{
	/*
	Derived derived;
	Child child;
//	Base base; 抽象类不能定义具体的对象
	//show(base);
	show(derived);
	//通过引用的方式调用函数
	derived.func();
	derived.point();
	child.point();
	derived.signal();
	child.signal();

	//通过指针
//	Base *b = &base;
//	b -> func();
	Derived* d = &child;
	d -> func();
	d -> point();
	Child* ch = &child;
	ch -> func();
	ch -> point();
*/
	Derived* d2 = new Derived();
	d2 -> func();
	return 0;
}

结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6cpo3iuM-1641119064741)(/Users/yanghaiguang/Nutstore Files/.symlinks/坚果云/多传感器融合-深蓝/自动驾驶技术/images/jicheng-2.png)]

通过指针和引用：

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void point()=0; //纯虚函数
	virtual void func()
	{
		cout << "Base!" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void func()
	{
		cout << "Derived!" << endl;
	}
	virtual void point()
	{
		cout << "X=1, Y=2" << endl;
	}
	void signal() {
		cout<<"class Derived signal"<<endl;
	}

};

class Child : public Derived
{
	public:
	virtual void func()
	{
		cout << "Child!" << endl;
	}
	virtual void point()
	{
		cout << "X=3, Y=4" << endl;
	}
	void signal() {
		cout<<"class child signal"<<endl;
	}
};

void show(Base& b)
{
	b.func();
}
//Base base;   //有了纯虚函数就成了抽象类，就无法再次定义具体的对象了，无法进行实例化操作。


int main()
{
	
	Derived derived;
	Child child;
//	Base base; 抽象类不能定义具体的对象
	//show(base);
	show(derived);
	//通过引用的方式调用函数
	derived.func();
	derived.point();
	child.point();
	derived.signal();
	child.signal();

	//通过指针
//	Base *b = &base;
//	b -> func();
	Derived* d = &child;
	d -> func();
	d -> point();
	Child* ch = &child;
	ch -> func();
	ch -> point();

	
	return 0;
}

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TAGsLraj-1641119064742)(/Users/yanghaiguang/Nutstore Files/.symlinks/坚果云/多传感器融合-深蓝/自动驾驶技术/images/jicheng-3.png)]

多态注意事项

虚函数的定义要遵循以下重要规则：

1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，那么即使加上了virtual关键字，也是不会进行滞后联编的。

2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。

3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。

4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义定义，但是在编译的时候系统仍然将它看做是非内联的。

5.构造函数不能是虚函数，因为构造的时候，对象还是一片位定型的空间，只有构造完成后，对象才是具体类的实例。

6.析构函数可以是虚函数,而且通常声名为虚函数。

下面的几个函数都不能定义为虚函数：

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

多态的缺点

• 降低了运行了效率（多态需要去寻找虚函数表的地址）
• 空间浪费

友元

友元分2种：

在c++继承和多态的设计中，如果类外的函数对私有成员进行访问，只能通过提供的接口（成员函数）间接的进行，虽然能带来数据隐藏的好处，但是增加了工作量。后来做了一些妥协，通过友元来提供这个功能。

友元函数

将全局函数声明为友元的写法如下：

friend 返回值类型 函数名(参数表);

将其他类的成员函数声明为友元的写法如下：

friend 返回值类型 其他类的类名::成员函数名(参数表);

但是，不能把其他类的私有成员函数声明为友元。

#include<iostream>
using namespace std;
class CCar;  //提前声明CCar类，以便后面的CDriver类使用
class CDriver
{
public:
    void ModifyCar(CCar* pCar);  //改装汽车
};
class CCar
{
private:
    int price;
    friend int MostExpensiveCar(CCar cars[], int total);  //声明友元
    friend void CDriver::ModifyCar(CCar* pCar);  //声明友元
};
void CDriver::ModifyCar(CCar* pCar)
{
    pCar->price += 1000;  //汽车改装后价值增加
}
int MostExpensiveCar(CCar cars[], int total)  //求最贵气车的价格
{
    int tmpMax = -1;
    for (int i = 0; i<total; ++i)
        if (cars[i].price > tmpMax)
            tmpMax = cars[i].price;
    return tmpMax;
}
int main()
{
    return 0;
}

友元类

class CCar
{
private:
    int price;
    friend class CDriver;  //声明 CDriver 为友元类
};
class CDriver
{
public:
    CCar myCar;
    void ModifyCar()  //改装汽车
    {
        myCar.price += 1000;  //因CDriver是CCar的友元类，故此处可以访问其私有成员
    }
};
int main()
{
    return 0;
}

注意：

友元关系在类之间不能传递，即类 A 是类 B 的友元，类 B 是类 C 的友元，并不能导出类 A 是类 C 的友元。

C++中私有变量对外部类是不能直接访问的，也是不能继承的。

使用友元类可以访问类中的私有方法、私有变量，虽然对类的封装有一定的破坏，但是有时也是很实用的。

在实际中，在修改已有代码时，为了不大改动已有代码：

(1) 对于没有继承关系的类，如果有关联，使用友元类还是比较方便的。

(2) 对于有继承关系的类，如果有关联，可以将变量访问由private改为protected。