多态

最新推荐文章于 2024-07-28 18:22:25 发布
最新推荐文章于 2024-07-28 18:22:25 发布
阅读量198 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuruhua/article/details/80866484
版权

一、概念

1、什么是多态？

同一种事务，在不同场景下的多种形态。

2、分类：

A、静态多态(静态链编译，静态绑定，早绑定)：静态多态是编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对 应的函数就调用该函数，否则出现编译错误  。【编译器在编译期间来确定程序的行为（确定具体调用哪个函数）】【a、函数重载；b、泛型编程】

B、动态多态(静态链编，动态绑定，晚绑定)：【在程序运行时确定程序的具体行为】

（1）条件：a、基类中必须包含虚函数，在派生类中必须对基类的虚函数进行重写；b、必须通过基类指针或引用调用虚函数

（1B）基类中必须包含虚函数，并且派生类一定要对基类中的虚函数进行重写 

重写：a）、基类中将被重写的函数必须是虚函数；b）、基类和派生类中虚函数的原型（返回值类型 函数名字（参数列表）要保持一致（完全相同，但是协变和析构函数例外）。 c）基类中虚函数和派生类虚函数的访问限定符可以不同（一般基类中的限定符为公有的，因为基类的虚函数要在类外进行调用）

协变（基类里的虚函数返回基类对象的指针或引用，派生类中虚函数返回派生类对象的指针或者引用）

析构函数：基类和派生类中函数的名字不同，一般建议把基类中的函数给成虚函数

3、代码实现多态

4、动态多态的调用原理：口述加例子 

1‘、

class Base
{
public:
	virtual void Test1(){
		cout << "Base:Test1()" << endl;
	}
};
//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
public:
	virtual void Test1(){
		cout << "Derived::Test1()" << endl;
	}
};
void TestVirtualFunc(Base& b)
{
	b.Test1();
}
int main()
{
	Base b;
	Derived d;
	TestVirtualFunc(b);//引用的是基类中的对象，调用基类中的函数
	TestVirtualFunc(d);//引用的是派生类对用，调用派生类中的
	system("pause");
	return 0;
}

 

2’、下述代码会产生问题：

using namespace std;
class Base
{
public:
 virtual void Test1(){
  cout << "Base:Test1()" << endl;
 }
 virtual void Test2(){
  cout << "Base::Test2()" << endl;
 }
 void Test3(){
  cout << "Base::Test3()" << endl;
 }
 virtual void Test4(int){
  cout << "Base::Test4()" << endl;
 }
};//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
public:
	virtual void Test1(){
		cout << "Derived::Test1()" << endl;
	}
	void Test2(){
		cout << "Derived::Test2()" << endl;
	}
	virtual void Test3(){
		cout << "Derived::Test3()" << endl;
	}
	virtual void Test4(char){
		cout << "Derived::Test4()" << endl;
	}//参数类型不同，基类中为int，派生类中为char
};
void TestVirtualFunc(Base& b)
{
	b.Test1();
	b.Test2();
	b.Test3();
	b.Test4(12);
	b.Test5('a');
}
int main()
{
	Base b;
	Derived d;
	TestVirtualFunc(b);
	TestVirtualFunc(d);
	system("pause");
	return 0;
}

 

（b）、以下会发生重写虚函数返回值类型存在差异的错误：

class Base
{
public:
	 
	virtual int Test5(){
		cout << "Base::Test5()" << endl;
		return 0;
	}
};
//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
public:
	 
	virtual char Test5(){
		cout << "Derived::Test5()" << endl;
		return 0;
	}
};

但是协变不会产生错误，如下述代码：

class Base
{
public:
	 
	virtual Base* Test5(){
		cout << "Base::Test5()" << endl;
		return 0;
	}
};
//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
public:
	 
	virtual Derived* Test5(){
		cout << "Derived::Test5()" << endl;
		return 0;
	}
};

 

3‘、如下，析构函数调用派生类中的对象，释放的是基类中的指针，指向派生类中的对象，基类与派生类中都为虚函数，所以发生了重写。

class Base
{
public:
	 
	virtual Base* Test5(){
		cout << "Base::Test5()" << endl;
		return 0;
	}
	virtual ~Base()
	{
		cout << "Base:~Base()" << endl;
	}
};
//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
public:
	 
	virtual Derived* Test5(){
		cout << "Derived::Test5()" << endl;
		return 0;
	}
	virtual ~Derived()
	{
		cout << "Derived:~Derived()" << endl;
	}
};
 
int main()
{
	Base *pb = new Derived;
	delete pb;
	system("pause");
	return 0;
}

 

 

 

因为pb是派生类中的对象，调用派生类中的对象。

 

（B2）通过基类对象的指针或者引用调用虚函数  

小结：若要构成重写，把普通的函数给成虚函数，基类和派生类中的原型要保持一致。但是协变和析构函数例外

 3、模拟实现一个多态例子：根据指针（引用）指向的对象来确定具体调用哪个类的虚函数

二、

1、

 

 

（1）、访问限定符不同的含义是基类中的成员函数必须是公有的，因为指针或者引用要通过基类中的对象来调用，派生类中的限定符可以不是公有的。

class Base
{
public:
	virtual void Test1(){
		cout << "Base:Test1()" << endl;
	}
	virtual void Test2(){
		cout << "Base::Test2()" << endl;
	}
 
};
//重写：派生类和基类中虚函数原型要保持一致
class Derived : public Base
{
protected:
	virtual void Test1(){
		cout << "Derived::Test1()" << endl;
	}
	void Test2(){
		cout << "Derived::Test2()" << endl;
	}
 
};
void TestVirtualFunc(Base* b)
{
	b->Test1();
	b->Test2();
}
int main()
{
	Base b;
	Derived d;
	TestVirtualFunc(&b);
	TestVirtualFunc(&d);
	system("pause");
	return 0;
}

 

 

通过派生类的对象调用函数，则是不正确的，以下测试代码会产生错误：

void TestVirtualFunc(Base* b)
{
	 
	Derived d;
	d.Test2();
}

但是通过基类中的对象调用就不会产生错误，原因是编译期间，编译器只会把b当成基类的指针对待（编译期间不管实际的类型，只看静态的类型（在声明变量时给的类型）（动态类型：变量实际给定的对象指定的类型））

（2）同名隐藏：基类与派生类有同名的成员，就会发生同名隐藏。派生类中调用同名的对象优先调用派生类的。在基类和派生类中只要不构成重写就是重定义。

问题：

a、什么是函数重载，同名隐藏，重写？ 

b、哪些函数不能定义为虚函数？  

3、抽象类：在成员函数(必须为虚函数)的形参列表后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。【方法只给出来，不实现】

（1)抽象类不能实例化对象，下述代码会发生问题：

class WC;
class Person
{
public:
	virtual void GoToWC(WC &c);
};
int main()
{
 Person p;
 return 0;
}

但是可以定义指针，以下代码就正确了

int main()
{
	Person *p;
	return 0;
}

（2）纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。

class WC;
class Person
{
public:
	virtual void GoToWC(WC &c);
};
class Man :public Person
{
public:
	//虚函数
	
	virtual void GoToWC(WC &c)
	{
		//操作
	}
	
};
int main()
{
	Person *p;
	//如果派生类不是一个虚函数，则也是一个抽象对象,实例化后编译时会发生问题，所以必须定义虚函数
	Man m;
	return 0;
}

 

（3）

class Base
{
public:
	void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	int _b;
};
int main()
{
	cout << sizeof(Base) << endl;
	system("pause");
	return 0;
}

 

 

 

 

 

如果给成一个虚函数，则会多出4个字节：

public:
	virtual void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	int _b;
};

 

 

 

 

（3）

class Base
{
public:
	virtual void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	int _b;
};
int main()
{
	cout << sizeof(Base) << endl;
	Base b;
	b._b = 1;
	system("pause");
	return 0;
}

 

 

（4）Base类对象大小：成员大小总和+4字节（多出来的4个字节是一个地址，该地址指向一个空间，空间中存放虚函数的地址即虚函数的表格（虚表）

a、

class Base
{
public:
	virtual void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	virtual void Test2()
	{
		cout << "Base::Test2()" << endl;
	}
	virtual void Test3()
	{
		cout << "Base::test3()" << endl;
	}
	int _b;
};
typedef void (*PVTF)();
void PrintVTP(Base &b)
{
	PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
 	while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
	{
		(*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
		++pVTF;
	}
	cout << endl;
}
class Derived :public Base
{
public:
	int _d;
};
int main()
{
	cout << sizeof(Base) << endl;
	cout << sizeof(Derived) << endl;
	Base b;
	b._b = 1;
	Derived d;
	d._b = 1;
	d._d = 2;
	PrintVTP(b);
	PrintVTP(d);
	system("pause");
	return 0;
}

 

 

基类中的虚表：将类中的虚函数按照在类中声明的先后次序添加到虚函数表中

b、单继承派生类的虚表：将基类虚函数表中的内容拷贝一份，

class Base
{
public:
	virtual void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	virtual void Test2()
	{
		cout << "Base::Test2()" << endl;
	}
	virtual void Test3()
	{
		cout << "Base::test3()" << endl;
	}
	int _b;
};
typedef void (*PVTF)();
void PrintVTP(Base &b,const string &str)
{
	PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
	cout << str << endl;//引用之前先打印str
 	while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
	{
		(*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
		++pVTF;
	}
	cout << endl;
}
class Derived :public Base
{
public:
	int _d;
};
int main()
{
	cout << sizeof(Base) << endl;
	cout << sizeof(Derived) << endl;
	Base b;
	b._b = 1;
	Derived d;
	d._b = 1;
	d._d = 2;
	PrintVTP(b,"Base VTF:");
	PrintVTP(d,"Derived VTF:");
	system("pause");
	return 0;
}

 

重写部分代码（派生类）：

class Derived :public Base
{
public:
	virtual void Test2()
	{
		cout << "Derived::Test2()" << endl;
	}
	int _d;
};

 

 

 

说明：单继承派生类的虚表：将基类虚函数表中的内容拷贝一份，一旦对派生类进行改写，编译器用改写后相同偏移量的位置把基类的虚函数替换成派生类自己的虚函数。

c、按照派生类特有虚函数的声明次序将其增加到虚函数表的最后。

# include<iostream>
# include<stdio.h>
# include<stdlib.h>
# include<string>
using namespace std;

class Base
{
public:
	virtual void Test1()
	{
		cout << "Base::Test1()" << endl;
	}
	virtual void Test2()
	{
		cout << "Base::Test2()" << endl;
	}
	virtual void Test3()
	{
		cout << "Base::test3()" << endl;
	}
	int _b;
};
typedef void(*PVTF)();
void PrintVTP(Base &b, const string &str)
{
	PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
	cout << str << endl;//引用之前先打印str
	while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
	{
		(*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
		++pVTF;
	}
	cout << endl;
}
class Derived :public Base
{
public:
	virtual void Test4()
	{
		cout << "Derived::Test4()" << endl;
	}
	virtual void Test2()
	{
		cout << "Derived::Test2()" << endl;
	}
	virtual void Test3()
	{
		cout << "Derived::Test3()" << endl;
	}
	virtual void Test5()
	{
		cout << "Derived::Test5()" << endl;
	}
	int _d;
};
int main()
{
	cout << sizeof(Base) << endl;
	cout << sizeof(Derived) << endl;
	Base b;
	b._b = 1;
	Derived d;
	d._b = 1;
	d._d = 2;
	PrintVTP(b, "Base VTF:");
	PrintVTP(d, "Derived VTF:");
	system("pause");
	return 0;
}

 

 

 

 

 

 

 

（5）

 

 

 

 

虚函数的调用原理：a、从对象的前4个字节取虚表的地址；b、传递this指针；c、从虚表中取对应的虚函数：虚表的地址+偏移量；d、执行当前虚函数。

void TestFunc(Base &pb)
{
	pb.Test1();
	pb.Test2();
	pb.Test3();
}
int main()
{
 Base b;
 TestFunc(b);
 Derived d;
 TestFunc(d); 
 system("pause");
 return 0;
}

 

执行以上代码，首先查看是不是基类里面的虚函数的指针，如果是、则调用虚函数

如果传递基类的对象，到基类的虚表中查找对应的虚函数；如果查找的是派生类的对象，到派生类的虚表中查找对应的虚函数。

void TestFunc(Base &pb)
{
	pb.Test1();
	pb.Test2();
	pb.Test3();
}
int main()
{
	Base b;
	b.Test1();
 	Derived d;
 	system("pause");
	return 0;
}

执行以上代码，则不用查看是不是基类里面的虚函数和指针，因为是一个成员函数，不会按照多态的方式进行调用。

 

 

 

（7）带有虚函数的多继承场景下派生类的对象模型及派生类的虚表

a、

class B1
{
public:
	virtual void Test1()
	{
		cout << "B1::Test1()" << endl;
	}
	virtual void Test2()
	{
		cout << "B1::Test2()" << endl;
	}
	int _b1;
};
class B2
{
public:
	virtual void Test3()
	{
		cout << "B1::Test3()" << endl;
	}
	virtual void Test4()
	{
		cout << "B1::Test4()" << endl;
	}
	int _b2;
};
class Derived :public B1, public B2
{
public:
	int _d;
};
typedef void(*PVTF)();
void PrintVTP(B1 &b, const string &str)
{
 PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
 cout << str << endl;//引用之前先打印str
 while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
 {
  (*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
  ++pVTF;
 }
 cout << endl;
}
void PrintVTP(B2 &b, const string &str)
{
 PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
 cout << str << endl;//引用之前先打印str
 while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
 {
  (*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
  ++pVTF;
 }
 cout << endl;
}
int main()
{
	cout << sizeof(Derived) << endl;
	Derived d;
	d._b1 = 1;
	d._b2 = 2;
	d._d = 3;
	system("pause");
	return 0;
}

 

 

 

 

 

 

b、进行重写之后：把相同偏移量位置的虚函数替换成派生类自己的虚函数

class Derived :public B1, public B2
{
public:
	virtual void Test2()
	{
		cout << "Dereved::Test2()"<<endl;
	}
	virtual void Test3()
	{
		cout << "Dereved::Test3()" << endl;
	}

	int _d;
};

 

 

 

 

c、增加派生类自己的虚函数（只有两个虚表指针，不可能将其重新放到一个虚表里面），将其放到第一张虚表的后面，因为如果从第二张虚表开始取，需要将其偏移一个位置才能取，这样的方式不方便。将派生类新增加的虚函数放置到第一张虚表的最后。

class Derived :public B1, public B2
{
public:
	virtual void Test5()
	{
		cout << "Dereved::Test5()" << endl;
	}
	virtual void Test2()
	{
		cout << "Dereved::Test2()"<<endl;
	}
	virtual void Test3()
	{
		cout << "Dereved::Test3()" << endl;
	}
	virtual void Test6()
	{
		cout << "Dereved::Test6()" << endl;
	}

	int _d;
};

 

（8）菱形继承

class B
{
public:
	virtual void Test1()
	{
		cout << "B::Test1()" << endl;
	}
	virtual void Test2()
	{
		cout << "B::Test2()" << endl;
	}
	int _b;
};
class c1 :public B
{
public:
	virtual void Test1()
	{
		cout << "C1::Test()" << endl;
	}
	virtual void Test2()
	{
		cout << "C1::Test3()" << endl;
	}
	int _c1;
};
class c2 :public B
{
public:
	virtual void Test2()
	{
		cout << "C2::Test2()" << endl;
	}
	virtual void Test4()
	{
		cout << "C2::Test4()" << endl;
	}
	int _c2;
};
class Derived :public c1, public c2
{
public:
	virtual void Test1()
	{
		cout << "Derived::Test1()" << endl;
	}
	virtual void Test3()
	{
		cout << "Derived::Test3()" << endl;
	}
	virtual void Test4()
	{
		cout << "Derived::Test4()" << endl;
	}
	virtual void Test5()
	{
		cout << "Derived::Test5()" << endl;
	}
	int _d = 0;
};
typedef void(*PVTF)();
void PrintVTP(c1 &b, const string &str)
{
	PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
	cout << str << endl;//引用之前先打印str
	while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
	{
		(*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
		++pVTF;
	}
	cout << endl;
}
void PrintVTP(c2 &b, const string &str)
{
	PVTF *pVTF = (PVTF*)(*(int *)&b);//指向表格第一个元素的地址
	cout << str << endl;//引用之前先打印str
	while (*pVTF)//因为表格最后的位置为0，为0则不进入，完成循环
	{
		(*pVTF)();//(*pVTF)拿到空间中的内容//(*pVTF)()调用这个函数
		++pVTF;
	}
	cout << endl;
}
int main()
{
	cout << sizeof(Derived) << endl;
	Derived d;
	d.c1::_b = 1;
	d._c1 = 2;
	d.c2::_b = 3;
	d._c2 = 2;
	d._d = 5;
	c1& cc1 = d;
	PrintVTP(cc1, "Derived VTF--->cc1");
	c1& cc2 = d;
	PrintVTP(cc2, "Derived VTF--->cc2");
	system("pause");
	return 0;
}

 

 

对多态理解的总结：

 

 

xuruhua
关注
面向对象编程——多态
m0_68989458的博客
05-01 1039
面向对象编程——多态
多态VI-综合文档
05-23
在LabVIEW（Laboratory Virtual Instrument Engineering Workbench）环境中，多态VI（Virtual Instruments）提供了类似的功能，使得开发者可以创建更加灵活、可扩展的代码结构。本文将深入探讨多态VI的概念、工作...
C++多态编程
gehulushang的博客
11-07 209
首先上一段代码： #include <iostream> using namespace std; class Demo{ public: virtual void prin(){ cout<<"woshi"<<endl; } }; class Lidemo : public Demo{ public: void prin(...
基本的编程概念 ——多态（Polymorphism）详解
最新发布
Python老吕的博客
07-28 284
多态是面向对象编程中不可或缺的一部分，它极大地增强了软件的灵活性和可扩展性。掌握多态的概念和实现方式，对于编写高质量、易维护的面向对象程序至关重要。希望本文能够帮助读者更好地理解多态，并在实际编程中灵活运用这一强大的特性。博主：Python老吕CSDN网站为我们搭建了一个如此卓越的学习平台，使我们有机会分享知识与经验。在《Python初级开发者之路》中，我们旨在帮助您从新手成长为一名能够独立解决问题的初级开发者。
pb的多态思想
实践不息，学习不止，创新不断
08-24 487
一、目的：想自定义一个工具按钮组，包括添加、删除、保存、重置等基本操作。 二、方法： 1、如果在每个按钮里面写代码，具体到一个窗口中，如果不合适无法修改（排除） 2、把程序代码集成到工具栏的函数中，按钮直接接调用函数，但在具体的窗口中，仍无法修改uo对象的函数。（排除）
C++编程之多态
amao_ios_Allen的博客
02-10 185
不管今天讲啥，我们先来说说重载，重写，重定义的区别： 重载：函数名相同，参数列表不相同，返回类型可相同可不相同。 重写：也叫覆盖，在不同的作用域中（基类和派生类），函数名相同，参数相同，返回值相同（协变除外），基类函数必须含有virtual关键字。 重定义：也叫隐藏，在不同的作用域中（基类和派生类），函数名相同，不是重写就是重定义。 今天，我们来看一下多态。 多态：顾名思义，多种形态。在C...
Java编程那些事儿63—多态性
iteye_8557的博客
09-27 126
Java编程那些事儿63—多态性 郑州游戏学院 陈跃峰 出自：http://blog.csdn.net/mailbomb 8.5.3 多态性 多态性是面向对象技术中最灵活的特性，主要是增强项目的可扩展性，提高代码的可维护性。 多态性依赖继承特性，可以把多态理解为继承性的扩展或者深入。 在这里把多态性分为两方面来进行介绍，对象类型的多态和对象方法的多态。 为了方便后续的讲解，首...
类的多态练习_C++_类的多态练习_
09-29
首先，我们要明白多态性的两种主要形式：静态多态（Static Polymorphism）和动态多态（Dynamic Polymorphism）。静态多态主要通过函数重载（Function Overloading）和运算符重载（Operator Overloading）实现，...
labview创建多态VI
09-19
创建多态VI在LabVIEW中的实现主要依赖于函数选板（Function Palette）上的数据类型结构（Data Type Structure）。下面将详细介绍如何在LabVIEW中创建和使用多态VI。 1. **定义多态VI的基本结构** 在LabVIEW中，一...
Java 语言程序设计：第5章接口多态.ppt
09-20
Java 语言程序设计第 5 章接口多态 本章主要讲解 Java 语言程序设计中接口和多态的概念、语法和应用。接口是 Java 语言中的一种抽象机制，它提供了一种定义类之间的“协议”的方式，允许类之间实现多继承，同时免除...
多态代码实例
04-10
在编程领域，多态（Polymorphism）是一个关键概念，尤其在面向对象编程中发挥着重要作用。多态允许我们使用一个通用的接口来处理不同类型的对象，提供了代码的灵活性和可扩展性。虚函数（Virtual Function）是实现...
面向对象编程（多态封装）
12-04
讲述在面向对象程序或者模型设计时，父类，子类之间的封装，继承，以及类的多态性
JAVA基础编程——多态
止步听风的博客
05-08 1028
多态 面向对象的三大特性是封装、继承和多态。之前解释了封装和继承，这里说明一下多态。 多态主要体现在以下两个方面： 方法的多态：重载和覆写 重载：是指同名方法，根据不同的参数类型及个数可以完成不同的功能 覆写：是指同名方法，根据实例化的子类对象不同，所完成的功能也不同 对象的多态：父子类对象的转换 向上转型：子类对象转型为父类对象，自动转换，格式为：父类 父类对象 = 子类实例 向下转型：父类对象转型为子类对象，强制转换，格式为：子类 子类对象 = (子类)父类实例 class
java多态性编程_Java编程基础篇之多态性
weixin_42628573的博客
02-16 102
通过继承和重载的结合，超类可以定义供他所有子类可以使用方法的通用形式。如下代码：class Figure{double dim1;double dim2;Figure(double a, double b){dim1 = a;dim2 = b;}double GetArea(){System.out.println("The figure is undefined!");return 0;}}cl...
pb运行时多态方法
MagicDog200的专栏
08-21 955
父类型变量=create using 子类型名称函数参数指定为父类型，传入子类型类型的行为都是子类型定义的。类似于C++的虚函数。
【JavaSE】面向对象编程思想之多态（图文详解）
m0_73648729的博客
08-06 877
多态的概念：通俗来说，就是多种形态，总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。
C++中的静态多态与动态多态解析
本文将探讨C++中的静态多态与动态多态，这两种多态形式在C++中扮演着重要角色，分别代表了编译期多态和运行期多态。动态多态主要通过虚函数实现，允许在运行时根据对象的实际类型调用相应的函数，而静态多态则主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuruhua

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值