【C++】多态

目录

1. 什么是多态

2. 多态的定义

2.1. 多态构成条件

2.2. 虚函数

2.3. 虚函数的重写

2.4. 多态的使用

2.5. 虚函数重写的两个例外

2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)

2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)

2.6. 子类继承父类虚函数会继承虚函数的属性

2.7. final 和 override(C++11)

2.7.1 final

2.7.2 override

2.8. 重载、重定义(隐藏)、重写(重定义)对比

3.抽象类

3.1. 什么是抽象类

3.2. 接口继承和实现继承

4. 多态原理(★)

4.1虚函数表

4.2. 多态的实现原理

4.3. 多态的静态与动态

5. 单继承和多继承的虚函数表

5.1. 单继承的虚函数表

5.2. 多继承的虚函数表(了解)


1. 什么是多态

我的理解是:不同的对象完成某个相同的行为,会产生不同的状态。

多态分为编译时多态和运行时多态。

编译时多态(静态):例如函数重载,看起来是调用同一个函数,却有不同的行为

运行时多态(动态):父类的指针或引用去调用函数,传递不同的对象,会调用不同的函数

例如:

去商场购物,有些商场根据以往消费情况将会员分为普通会员、黄金会员、钻石会员...不同的会员在消费时可以使用不同的折扣对商品打折。

2. 多态的定义

2.1. 多态构成条件

在继承中要构成多态的两个条件

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

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

2.2. 虚函数

 虚函数:即被virtual修饰的类成员函数称为虚函数(只能是类的非静态成员函数) 。

class ordinary_member
{
public:
	virtual void discount() // 虚函数
	{
		cout << "不打折" << endl;
	}
};

2.3. 虚函数的重写

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

例如:

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member:public ordinary_member
{
public:
	virtual void discount() // 虚函数重写:函数名、返回值、参数列表完全相同(三同)
	{                     
		cout << "打八折" << endl;
	}
};

注意:这里子类中的discount函数不是重定义(隐藏),而是重写。

2.4. 多态的使用

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member:public ordinary_member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}
};

//构成多态,传的哪个类型的对象,就调用这个对象的虚函数(跟对象有关)
void test(ordinary_member& member)
{
	member.discount(); // 多态
}

// 不构成多态,只会调用member类型的函数(跟类型有关)
//void test(ordinary_member member) // 如果用父类的对象接受,不构成多态
//{                                 // 换言之,在这个函数中,只要不构成多态,discount函数只会调用父类的
//	member.discount();
//}

int main()
{
	ordinary_member o;
	gold_member g;

	test(o);f
	test(g); // test函数用父类对象的引用或指针接收,传子类对象会切片
	return 0;
}

【C++】多态_第1张图片

2.5. 虚函数重写的两个例外

2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)

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

class A
{
public:
	virtual A* fun()
	{
		return new A;
	}
};
class B:public A
{
public:
	virtual B* fun()
	{
		return new B;
	}
};

2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的析构函数构成重写。

虽然函数名不相同,看起来违背了重写的规则,其实不是,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor

比如:vector的析构函数

 思考:为什么析构函数需要多态?

如果用将一个动态申请子类对象赋值给一个父类指针,那么调用析构函数时,应该调用谁的析构函数?

如果调用父类的析构函数,那么子类的成员不能被析构,所以这里析构函数应该存在多态,去调用子类的析构。

(普通对象会正确调用)

若析构函数不构成多态:

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}

	~ordinary_member()
	{
		cout << "~ordinary_member" << endl;
	}
};

class gold_member :public ordinary_member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}

	~gold_member()
	{
		cout << "~gold_member" << endl;
	}
};

int main()
{
	
	ordinary_member* o1 = new ordinary_member;
	ordinary_member* o2 = new gold_member;
	delete o1;
	delete o2; // 调用父类析构函数
	return 0;
}

那么这里都会调用父类的析构函数,子类自己成员不会被析构!

【C++】多态_第2张图片

如析构函数构成多态:

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

class gold_member:public ordinary_member
{
public:
	virtual ~gold_member()
	{
		cout << "~gold_member" << endl;
	}
};

int main()
{
	ordinary_member* o1 = new ordinary_member;
	ordinary_member* o2 = new gold_member;
    // 析构 + operator delete()
	delete o1; // o1->destructor()
	delete o2; // o2->destructor() 析构时会调用子类的析构函数
	return 0;
}

o1指针指向父类,调用父类的析构函数;o2指针指向子类,调用子类的析构函数!

【C++】多态_第3张图片

 所以动态申请的子类对象赋值父类指针管理,需要析构函数是虚函数。

2.6. 子类继承父类虚函数会继承虚函数的属性

虚函数的重写允许父子类两个都是虚函数,或者父类是虚函数,满足重写就构成多态(建议都写)

也就是说子类在继承父类虚函数时会将虚函数的属性也继承下来,包括virtual、访问限定符

(子类重写的虚函数可以不加virtual本质是因为析构函数,防止项目中忘记加virtual导致内存泄漏;而因为析构函数本身特性,只要父类析构函数前加了virtual,就和子类析构函数构成重写)

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member :public ordinary_member
{
private:// 子类访问限定符为私有,但这个虚函数构成多态,也能被外界访问(这里的private不能限制这个虚函数)
	void discount() // 不写virtual 也构成多态
	{
		cout << "打八折" << endl;
	}
};

void test(ordinary_member& member)
{
	member.discount(); // 子类私有成员构成多态时,可以在外面用多态调用该函数
}

int main()
{
	ordinary_member o;
	gold_member g;
	test(o);
	test(g);
	return 0;
}

【C++】多态_第4张图片

2.7. final 和 override(C++11)

2.7.1 final

  • 被final修饰的类,不能被继承
class A
{
private:
	A()    // 将父类的构造函数设为私有,子类无法调用父类的构造函数,就可以使父类不能被继承(间接限制)
		:_a(0)
	{}
protected:
	int _a;
};

class B :public A{};

class C final {}; // 类后面加了final,表示这个类不能被继承(直接限制)
class D:public C {};
int main()
{
	B b; // 编译报错
	return 0;
}
  • 被final修饰的虚函数,不能被重写

class A
{
public:
	virtual void Print() final // final修饰虚函数,该虚函数不能被重写
	{
		cout << "A::Print()" << endl;
	}
};

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

【C++】多态_第5张图片

2.7.2 override

检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错 。(放在子类重写虚函数的后面)

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

class B:public A
{
public:
	virtual void Print() override // 虚函数没有完成重写,会编译报错
	{
		cout << "B::Print()" << endl;
	}
};

【C++】多态_第6张图片

2.8. 重载、重定义(隐藏)、重写(重定义)对比

【C++】多态_第7张图片

3.抽象类

3.1. 什么是抽象类

在虚函数的后面写上 =0 ,则这个函数为纯虚函数。

包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象

派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象

纯虚函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承 。

例如:

class member // 抽象类,不能用这个类实例化出对象
{
public:
	virtual void discount() = 0; // 纯虚函数,只声明,不用实现因为实现了没用,不会调用父类的纯虚函数
};

class ordinary_member :public member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member :public member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}
};

class diamond_member :public member
{
	virtual void discount()
	{
		cout << "打六折" << endl;
	}
};

int main()
{
	member* gm = new gold_member;
	member* dm = new diamond_member;
	gm->discount();
	dm->discount();
    delete om;
    delete gm;
    delete dm;
	return 0;
}

3.2. 接口继承和实现继承

普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。

虚函数的 继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口

所 以如果不实现多态,不要把函数定义成虚函数。

例如上面的会员类,一个单纯的会员类是抽象的东西(必要区分会员类型),因为不知道到底是普通会员还是黄金会员或者钻石会员,而每个会员所独有的折扣(特性)是必须要存在的,为了不让子类缺少这部分,子类就必须重写纯虚函数才能实例化出对象。

4. 多态原理(★)

4.1虚函数表

下面这个类的对象大小是多少?

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

private:
	int _a;
};

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

【C++】多态_第8张图片

【C++】多态_第9张图片

在监视窗口中可以看到,aa对象中多了一个__vfptr成员,这其实是一个指向虚函数表的指针,而虚函数表是一个函数指针数组,里面放的是虚函数的地址。

再往下看:

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
protected:
	int _a;
};

class gold_member :public ordinary_member
{
public:
	virtual void discount() 
	{
		cout << "打八折" << endl;
	}
protected:
	int _b;
};

void consumption(ordinary_member* member)
{
	member->discount();
}

int main()
{
	ordinary_member om;
	gold_member gm;
	consumption(&om);
	consumption(&gm);
	return 0;
}

根据上面的代码,调用监视窗口查看,对象中的内容:

【C++】多态_第10张图片

虚函数的地址都会被放进虚函数表中,不管有没有被重写!但编译器进行了处理,导致看不见。

同类型的虚表指针是一样的!(虚表在内存中只会被存一份)

	ordinary_member om1;
	ordinary_member om2;
	ordinary_member om3;

【C++】多态_第11张图片

 【C++】多态_第12张图片

ps:在vs下一般认为虚函数表放在常量区。

4.2. 多态的实现原理

为什么需要使用父类的指针或引用才能调用多态?

例如上面这段代码,我们将consumption函数的参数改为父类的对象:

void consumption(ordinary_member member)
{
	member.discount();
}

int main()
{
	ordinary_member om;
	gold_member gm;
	consumption(om);
	consumption(gm);
	return 0;
}

我们会发现,无论是传父类对象还是子类对象,都会调用父类中的discount函数。

这是因为传子类对象过去后,父类对象member会对子类进行切片,而站在父类的角度它只会调用父类中的成员函数,不会调用子类。

也就是说子类传过去后,member对象会将子类中的父类成员进行拷贝,而__vfptr(虚表指针)不会被拷贝,还是会使用父类的虚表指针。因为父类中的虚表是不能被改变的,所以__vfptr也不能改变。(如果改变了,使用父类实例化对象时就会使用子类的虚表)

所以父类的对象调用重写函数不会形成多态!

再来看看传指针和引用的情况:

父类对象:

【C++】多态_第13张图片

子类对象:

【C++】多态_第14张图片

传指针或引用就可以构成多态,是因

  1. 静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为也称为静态多态,比如:函数 重载

  2. 动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用 具体的函数,也称为动态多态

为使用父类对象的指针或引用接收后,不会改变对象本身的性质,传父类就会使用父类的原地址或原空间,传子类就使用子类中继承父类的那部分成员(相当于这里的父类对象是子类中父类那一部分的别名)。(也就是说这里不会存在拷贝行为,还是在原对象的空间中操作)

多态的原理:基类的指针或引用,只指向谁就去谁的虚函数表中找对应位置的虚函数调用

4.3. 多态的静态与动态

  1. 静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为也称为静态多态,比如:函数 重载

  2. 动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用 具体的函数,也称为动态多态

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
protected:
	int _a;
};

class gold_member :public ordinary_member
{
public:
	virtual void discount() 
	{
		cout << "打八折" << endl;
	}
	void fun()
	{
		cout << "gold_member::fun()" << endl;
	}
protected:
	int _b;
};
int main()
{

	gold_member *gm = new gold_member;
	gm->discount();
	gm->fun();
	return 0;
}

【C++】多态_第15张图片

5. 单继承和多继承的虚函数表

5.1. 单继承的虚函数表

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

	virtual void fun2()
	{
		cout << "A::fun2()" << endl;
	}
};

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

	virtual void fun4()
	{
		cout << "B::fun5()" << endl;
	}
};

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

观察下图中的监视窗口中发现看不见fun3和fun4。这里是前面说的,编译器的监视窗口故意隐藏了这两个函数。

【C++】多态_第16张图片

通过查看内存,是可以知道他们的存在于虚函数表的:

【C++】多态_第17张图片

5.2. 多继承的虚函数表(了解)

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

	virtual void fun2()
	{
		cout << "A::fun2()" << endl;
	}
};

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

	virtual void fun4()
	{
		cout << "b::fun4()" << endl;
	}
};

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

	virtual void fun5()
	{
		cout << "C::fun5()" << endl;
	}
};
int main()
{
	C c;
	return 0;
}

多继承的子类中存在两张虚表,且子类中未重写的虚函数放在第一张虚表中。

【C++】多态_第18张图片

6. 总结

1.什么是多态

不同类型的对象完成某个相同的行为,会产生不同的结果。

2.inline函数可以是虚函数吗?

可以

调用时,如果不构成多态,这个函数保持inline属性;如果构成多态,这个函数就没有inline属性,因为调用是到对象的虚函数表中找到虚函数地址,实现调用,无法使用inline属性

3.静态成员函数可以是虚函数吗?

不能

静态成员函数没有this指针,不能访问到虚函数表指针,而且可以通过 类型::静态成员函数 的方式调用,无法访问虚表

4.构造函数可以是虚函数吗?

不能

虚函数表指针是在初始化列表阶段初始化的,如果构造函数是虚函数,这时还没有虚函数表指针,访问不到虚函数表

5.析构函数可以是虚函数吗?

可以

出现这种情况时需要使析构函数是虚函数

Parent* ptr = new child;(动态申请的子类对象,用父类指针接收时)

6.对象访问普通函数快还是虚函数更快?

如果不构成多态,都是编译器确定调用函数的地址,一样快。

如果构成多态,虚函数调用实在运行时,去虚表中确定函数地址,普通函数编译时直接确定地址,普通函数更快。

7.以下程序输出结果是什么()

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

 【C++】多态_第19张图片

你可能感兴趣的:(C++,c++,开发语言,后端,多态)