【C++】多态（上）

在这里插入图片描述
个人主页~

多态

一、多态的概念
二、多态的定义以及实现
- 1、多态的构成条件
- 2、虚函数
- 3、虚函数的重写
- - 虚函数重写的两个特殊情况
  - - ①协变
    - ② 析构函数的重写
- 4、C++11的override和final
- - （1）final
  - （2）override
- 5、重载、重写、隐藏的对比
三、抽象类
- 1、概念
- 2、接口继承和实现继承
四、多态的原理
- 1、虚函数表

一、多态的概念

用大白话讲就是完成某个行为，不同对象去完成会产生不同状态，C++多态就是在不同继承关系的类对象，去调用同一函数，产生了不同的行为

二、多态的定义以及实现

1、多态的构成条件

必须通过基类的指针或者引用调用虚函数

被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2、虚函数

被virtual修饰的类成员函数被称为虚函数

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

B函数是一个虚函数，这里的virtual与虚拟继承的virtual没有关系，只是它们表示相同的意思，关键字用在不同的对象上有不同的效果

3、虚函数的重写

派生类中有一个跟基类相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

class A 
{
public:
	virtual void C()
	{
		cout << "A : virtual void C()" << endl;
	}
};

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

void test(A& a)
{
	a.C();
}

int main()
{
	A a;
	B b;
	test(a);
	test(b);

	return 0;
}

在这里插入图片描述

虚函数重写的两个特殊情况

①协变

所谓协变就是基类与派生类虚函数返回值类型不同

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

class A 
{};
class B : public A 
{};

class C 
{
public:
	virtual A* f() 
	{
		return new A; 
	}
};
class D : public C 
{
public:
	virtual B* f() 
	{
		return new B; 
	}
};

② 析构函数的重写

析构函数的重写的特征是基类与派生类析构函数的名字不同

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor()

class A 
{
public:
	virtual ~A() 
	{
	 cout << "~A()" << endl; 
	}
};
class B : public A 
{
public:
	virtual ~B() 
	{
	 cout << "~B()" << endl; 
	}
};

int main()
{
	A* pa = new A;
	B* pb = new B;

	delete pa;
	cout << endl;
	delete pb;
	return 0;
}

在这里插入图片描述
这样的设计巧妙的将父子类的析构函数关系在一起，当然这其实是一个设计失误，这个多态或者说继承的概念是在析构函数的概念之后产生的，所以作为第一个面向对象的语言，就只能通过打补丁，也就是编译器将两个析构函数转化为destructor()保证它们同名

4、C++11的override和final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写

（1）final

final用来修饰虚函数，表示该虚函数不能再被重写
在这里插入图片描述

在这里插入图片描述

（2）override

override用来检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
在这里插入图片描述

在这里插入图片描述

5、重载、重写、隐藏的对比

重写也叫覆盖，隐藏也叫重定义

在这里插入图片描述

三、抽象类

1、概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数，包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象，派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象，纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

class A
{
public:
	virtual void D() = 0;
};
class B :public A
{
public:
	virtual void D()
	{
		cout << "BBBBBBBBBB" << endl;
	}
};
class C :public A
{
public:
	virtual void D()
	{
		cout << "CCCCCCCCCC" << endl;
	}
};
void Test()
{
	A* pb = new B;
	A* pc = new C;
	pb->D();
	pc->D();
}

在这里插入图片描述

2、接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现，虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口，所以如果不实现多态，不要把函数定义成虚函数

派生类继承基类虚函数接口的一个实例

class A
{
public:
    virtual void func(int val = 1) 
    {
        cout << "A->" << val << endl; 
    }
    virtual void test() 
    {
        func(); 
    }
};

class B : public A
{
public:
    void func(int val = 0) 
    {
        cout << "B->" << val << endl; 
    }
};

int main(int argc, char* argv[])
{
    B* p = new B;
    p->test();
    return 0;
}

在这里插入图片描述
这里就是因为派生类继承基类接口，重写函数，但是接口还是基类的，函数是被重写的，所以这里给的缺省值应该取基类A类func函数中的

四、多态的原理

1、虚函数表

class A
{
public:
	virtual void func1()
	{
		cout << "virtual void func1()" << endl;
	}
private:
	int _a;
};

int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

在这里插入图片描述
我们发现A类的大小为8bytes，除了私有成员_a以外还有一个_vtfptr的指针，我们把它叫做虚函数表指针，一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表简称虚表
在这里插入图片描述

class A
{
public:
	virtual void Func1()
	{
		cout << "A::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "A::Func2()" << endl;
	}
	void Func3()
	{
		cout << "A::Func3()" << endl;
	}
private:
	int _a = 1;
};

class B : public A
{
public:
	virtual void Func1()
	{
		cout << "B::Func1()" << endl;
	}
private:
	int _b = 2;
};

int main()
{
	A a;
	B b;
	return 0;
}