[C++](16)多态：虚函数，使用，多态的原理

最新推荐文章于 2024-05-23 20:19:57 发布
最新推荐文章于 2024-05-23 20:19:57 发布
阅读量640 收藏 10
点赞数 8
分类专栏： C++学习 文章标签： c++ mfc 开发语言 算法 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CegghnnoR/article/details/125960887
版权

文章目录

概念

多态的概念：多态就是多种形态，具体来说就是去完成某个行为，当不同类型的对象去完成时会产生出不同的状态。

例子：比如买票这件事，不同的人去买是不一样的，成人买是全价，学生买是半价，军人享有优先权。

定义及实现

虚函数与重写(覆盖)

  • 被 virtual 修饰的函数被称为虚函数。

  • 派生类中有与基类中的在返回类型、函数名、参数列表都完全相同的虚函数，则称派生类中的该虚函数重写（覆盖）了基类的虚函数。

  • 注意：参数列表相同是指参数的个数、类型以及类型的顺序相同。与参数名称，缺省值无关。

以买票为例，有以下继承关系，其中各写一个买票 BuyTicket 虚函数，派生类虚函数重写基类虚函数：

class Person
{
public:
	//虚函数
	virtual void BuyTicket()
	{
		cout << "Person：买票-全价" << endl;
	}
};

class Student : public Person
{
public:
    //虚函数
	virtual void BuyTicket()
	{
		cout << "Student：买票-半价" << endl;
	}
};

class Soldier : public Person
{
public:
    //虚函数
	virtual void BuyTicket()
	{
		cout << "Soldier：优先买票-全价" << endl;
	}
};

👆：派生类的虚函数的 virtual 也可以省略不写，因为先继承了基类函数接口声明，它依然是虚函数。但是我们为了规范，应该加上 virtual

注意：

  • virtual 关键字只在声明时加上，在类外实现时不能加
  • static 和 virtual 是不能同时使用的

多态构成条件

多态的实现有两个要求：

  1. 派生类虚函数重写基类虚函数（重写：三同+虚函数）。
  2. 基类指针或者引用去调用虚函数。

第一点已经满足了，要满足第二点我们还要再实现一个函数：

void Pay(Person* ptr)
{
	ptr->BuyTicket();
}

也可以传引用：

void Pay(Person& ref)
{
	ref.BuyTicket();
}

注意：不可以直接传对象，否则就不满足第二点

最后是一个简单的菜单(传指针)：

void test1()
{
	int option;
	Person p;
	Student st;
	Soldier so;
	do
	{
		cout << "请选择身份：";
		cout << "1.成人 2.学生 3.军人" << endl;
		cin >> option;
		switch (option)
		{
		case 1:
			Pay(&p);
			break;
		case 2:
			Pay(&st);
			break;
		case 3:
			Pay(&so);
			break;
		default:
			cout << "输入错误" << endl;
			break;
		}
	} while (option != -1);
}
//结果：
//请选择身份：1.成人 2.学生 3.军人
//1
//Person：买票-全价
//请选择身份：1.成人 2.学生 3.军人
//2
//Student：买票-半价
//请选择身份：1.成人 2.学生 3.军人
//3
//Soldier：优先买票-全价
//请选择身份：1.成人 2.学生 3.军人

虚函数重写的例外

协变

对于虚函数的返回值，如果是父子关系的类型的指针或引用，依然构成虚函数重写。

例子：

A 和 B 是父子关系，Person 类和 Student 类中的虚函数返回类型虽然不同，但是依然构成虚函数重载，满足多态的条件。

class A
{};

class B : public A
{};

class Person
{
public:
	virtual A* f()
	{
		cout << "virtual A* Person::f()" << endl;
		return nullptr;
	}
};

class Student : public Person
{
public:
	virtual B* f()
	{
		cout << "virtual B* Student::f()" << endl;
		return nullptr;
	}
};

void test2()
{
	Person p;
	Student s;
	Person* ptr = &p;
	ptr->f();

	ptr = &s;
	ptr->f();
}
//结果：
//virtual A* Person::f()
//virtual B* Student::f()

接口继承

上文提到：派生类的虚函数的 virtual 也可以省略不写，因为先继承了基类函数接口声明，它依然是虚函数。但是我们为了规范，应该加上 virtual

这其实是个坑，如下题：

以下程序输出的结果是什么？（ ）

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()
{
	B* p = new B;
	p->test();
	return 0;
}

A. A->0 B. B->1 C. A->1 D. B->0 E. 编译出错 F. 以上都不正确

答案：

B

解析：

B 继承了 A 类的 test 函数，所以可以调用，但是 test 函数内部的 this 指针依然是 A* 类型。p 是 B* 类型，传给 this 会发生切割。然后再用 this 指针去调用 func 函数，也就是 this->func() ，this 是基类指针，func 构成虚函数重写，所以满足多态的两个条件。this 指向的是 B 类型对象，则调用 B 类里的虚函数，该虚函数继承了基类虚函数的接口，也就是说，B 类里的 func 的参数列表显式写出来的缺省值是没有意义的，是用来迷惑你的，真正的缺省值还是 1，最后打印 B->1，选 B

总结：

  1. 派生类的虚函数继承是接口继承，virtual 和参数列表缺省值都会原样照搬基类的虚函数。
  2. 虚函数重写指的是重写函数实现。

扩展：

把 p->test(); 改成 p->func(); 结果是什么？（ ）

答案：

D

解析：

这里是直接调用，没有构成多态，也就没有接口继承，所以结果就是 B->0，选 D

析构函数的重写

上篇文章提到：基类和派生类的析构函数构成隐藏关系，由于多态的需要，析构函数名会被统一处理成 destructor。

只要加上 virtual 满足三同。即可构成重写（覆盖）关系。

如下场景：

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

class Student : public Person
{
public:
	~Student()
	{
		cout << "~Student()" << endl;
	}
};

void test4()
{
	Person* p = new Student;
	delete p;
}
//结果：
//~Person()

p 虽然指向的是 Student 类型的对象，但是由于本身是 Person* 所以只会调用 Person 的析构函数，而调不到 Student 的析构函数，如果 Student 类内有动态分配空间，那么就会造成内存泄漏。

这里就需要多态调用析构函数：

给析构函数加上 virtual，构成函数重写，p 作为基类指针去调用

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

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

void test4()
{
	Person* p = new Student;
	delete p;
}
//结果：
//~Student()
//~Person()

建议：如果设计的一个类，可能会作为基类，其析构函数最好定义为虚函数。

C++11 的 final 和 override

final：

  1. 修饰虚函数，表示该虚函数不能被重写

该关键字写在虚函数后面

class Car
{
public:
	virtual void Drive() final //final函数
	{}
};

class Benz : public Car
{
public:
	virtual void Drive() //此处报错：无法重写“final”函数 "Car::Drive"
	{
		cout << "Benz" << endl;
	}
};
  1. 修饰类，表示不能被继承
class Car final	//final类
{
public:
	virtual void Drive()
	{}
};

class Benz : public Car	//此处报错：不能将“final”类类型用作基类
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

该关键字写在派生类虚函数的后面：

class Car
{
public:
	void Drive() //未被virtual修饰
	{}
};

class Benz : public Car
{
public:
	virtual void Drive() override //此处报错：使用“override”声明的成员函数不能重写基类成员
	{
		cout << "Benz" << endl;
	}
};

重载、隐藏（重定义）、重写（覆盖）的对比

img

抽象类

  • 在虚函数后面写上 =0，则这个函数为纯虚函数，包含纯虚函数的类叫做抽象类（也叫接口类）。
  • 抽象类不能实例化出对象。派生类继承后也不能实例化对象，只有重写纯虚函数，派生类才能实例化出对象。
  • 纯虚函数也可以实现函数体，但是没有意义，在基类中只给出声明，它的实现留给派生类去做。
  • 纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

如下 Drive 函数是一个纯虚函数，Car 是一个抽象类：

class Car	//抽象类
{
public:
	virtual void Drive() = 0;	//纯虚函数
};

此时基类无法定义出对象：

void test5()
{
	Car c;	//此处报错：不允许使用抽象类类型 "Car" 的对象
}

但是 Car* 指针还是可以创建的。

例子：

class Car
{
public:
	virtual void Drive() = 0;
};

class BMW : public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW" << endl;
	}
};

class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

void test5()
{
	Car* pBMW = new BMW;
	Car* pBenz = new Benz;
	pBMW->Drive();
	pBenz->Drive();
}
//结果：
//BMW
//Benz

建议：对于不需要实例化对象的基类，其内部虚函数最好写成纯虚函数，规范其派生类虚函数重写。

多态的原理

虚函数表

class Base
{
public:
	virtual void Fun()
	{
		cout << "Fun()" << endl;
	}
private:
	int _b = 1;
};

sizeof(Base) 是多少？

答案：32位平台下是8，64位平台下是16。

其实除了 _b 成员，还多了一个虚函数表指针 __vfptr，虚函数表简称虚表。

下面对 Base 类增加一个虚函数 Fun2 和一个普通函数 Fun3，Derive 类继承 Base，重写 Fun1。然后创建对象，观察监视窗口。

class Base
{
public:
	virtual void Fun1()
	{
		cout << "Base::Fun1()" << endl;
	}
	virtual void Fun2()
	{
		cout << "Base::Fun2()" << endl;
	}
	void Fun3()
	{
		cout << "Base::Fun3()" << endl;
	}
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Fun1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

void test6()
{
	Base b;
	Derive d;
}

img

虚表指针 __vfptr 其实就是函数指针数组。

可以发现，普通函数 Fun3 没有进入虚表。Derive 类里的 Fun1 完成了重写，d 的虚表中存的是重写后的 Derive::Func1，未被重写的 Fun2 存放的还是原来的。

由此得出：

  • 重写是语法层的概念，派生类对基类虚函数实现进行了重写。

  • 覆盖是原理层的概念，派生类的虚表拷贝基类虚表进行了修改，覆盖要重写的虚函数指针。

所以多态调用的实现，是依靠运行时，去指向的对象的虚表中查找调用函数的地址

对比多态调用和普通调用：

  • 多态调用：运行时决议——运行时确定调用函数的地址（查虚函数表）
  • 普通调用：编译时决议——编译时确定调用函数的地址

下面写一个多态调用和一个普通调用，对比二者的汇编代码：

void test6()
{
	Base b;
	Derive d;
	Base* p = &d;

	p->Fun1();	//多态调用
	b.Fun3();	//普通调用
}
//结果：
//Derive::Func1()
//Base::Fun3()

	p->Fun1();	//多态调用
00B22C45  mov         eax,dword ptr [p]  //p存的是d对象的地址，这里就是将p移动到eax中
00B22C48  mov         edx,dword ptr [eax]  //[eax]就是取eax指向的内容，这里就是将d对象的虚表指针移动到edx
00B22C4A  mov         esi,esp  
00B22C4C  mov         ecx,dword ptr [p]  
00B22C4F  mov         eax,dword ptr [edx]  //[edx]就是取edx指向的内容，这里就是将虚表里的虚函数指针移动到eax
00B22C51  call        eax  //通过eax里的虚函数指针调用函数
00B22C53  cmp         esi,esp  
00B22C55  call        __RTC_CheckEsp (0B2131Bh)  
	b.Fun3();	//普通调用
00B22C5A  lea         ecx,[b]  
00B22C5D  call        Base::Fun3 (0B2151Eh)  //这里就是直接call，因为函数地址已经在编译时确认了

为什么派生类赋值给基类对象无法构成多态？

对象切片的时候，派生类只会拷贝成员给基类对象，不会拷贝虚表指针。况且从逻辑上讲，基类对象本就应该调用基类里的函数，如果拷贝了虚表指针，基类对象调用的却是派生类函数，就发生混乱了。而指针和引用可以明确表示，自己指向的是哪一类的对象就调用哪一类的函数。

动态绑定和静态绑定

  1. 静态绑定又称为前期绑定（早绑定），在程序编译期间确定了程序的行为，也称为静态多态，如：函数重载
  2. 动态绑定又称后期绑定（晚绑定），是在程序运行区间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

补充：VS监视窗口下的虚表

A 类有一个虚函数 Fun1，B 类重写 Fun1，然后单独写了一个虚函数 Fun2。然后创建对象，观察监视窗口：

class A
{
	virtual void Fun1()
	{
		cout << "A::Fun1()" << endl;
	}
};
class B : public A
{
	virtual void Fun1()
	{
		cout << "B::Fun1()" << endl;
	}
	virtual void Fun2()
	{
		cout << "B::Fun2()" << endl;
	}
};
void test7()
{
	A a;
	B b;
}

img

按理说，虚函数指针应该进入虚表，B 类有两个虚函数，所以 B 的虚表应该有两个虚函数指针。但是监视窗口只显示了一个。还有一个虚函数指针去哪了？

打开内存窗口看看：

img

我们发现，它的下一个位置还存着一个地址 0x0059146f，它是虚函数 Fun2 的地址吗？

我们可以通过以下代码打印虚表并调用虚函数：

typedef void(*V_FUN)();

void PrintVFTable(V_FUN* a)
{
	for (size_t i = 0; i < 2; ++i)
	{
		printf("[%d]:%p->", i, a[i]);	//打印函数指针
		V_FUN f = a[i];
		f();	//调用函数
	}
}

void test7()
{
	A a;
	B b;
	PrintVFTable((V_FUN*)*(int*)&b); //这里传参要取b的前4个字节
}
//结果：
//[0]:00591479->B::Fun1()
//[1]:0059146F->B::Fun2()

👆原理：

要打印 b 的虚表，首先就要获得 b 的 __vfptr ，但是我们不能直接 b.__vfptr 去取；注意到它其实就是 b 的前4个字节，只能通过 *(int*)&b 取出，说明：b 不能直接转换成 int，而 &b 可以转换成 int*，然后解引用就可以获得 b 的前4个字节；最后将这 4 个字节转换成 V_FUN* 也就是函数指针数组类型进行传参。

V_FUN 是我们自己 typedef 出来的函数指针类型，方便接下来的使用；PrintVFTable 的形参 V_FUN* a 就是函数指针数组，内部使用for循环打印 a 数组的前两个函数指针并调用函数。

总结：

由结果看出，它成功调用了 Fun2，确实是 Fun2 的地址，这说明，vs监视窗口看到的虚函数表不一定是真实的，可能被处理过。

补充：小题

虚表存在哪个区域？

  • 一个类对应一个虚表，同类型的不同对象存的虚表指针都指向这个虚表。

  • 所以虚表首先不可能在栈和堆，栈里是存函数栈帧的，虚表不会随函数的开始结束而开辟销毁，也不可能在堆区，因为它不是动态开辟的。

那么到底存在哪呢？我们下面来实验一下：

void test8()
{
	int a = 0;
	int* p = new int;
	static int b = 1;
	const char* str = "hello world";
	A aa;
	printf("栈区：%p\n", &a);
	printf("堆区：%p\n", p);
	printf("静态区（数据段）：%p\n", &b);
	printf("常量区（代码段）：%p\n", str);
	printf("虚表：%p\n", *(int*)&aa);
}
//结果：
//栈区：004FF650
//堆区：006B4160
//静态区（数据段）：00D3D008
//常量区（代码段）：00D3AF24
//虚表：00D3ADD0

虚表的地址和常量区更接近，说明虚表存在常量区（代码段）。

多继承的虚函数

以下是一个多继承体系，基类 Base1 和 Base2 分别有两个虚函数 fun1 fun2，派生类继承它俩，并重写 fun1 ，增加一个独有的虚函数 fun3。最后创建派生类对象然后通过监视窗口进行观察。

class Base1
{
public:
	virtual void fun1()
	{
		cout << "Base1::fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "Base1::fun2()" << endl;
	}
private:
	int b1;
};

class Base2
{
public:
	virtual void fun1()
	{
		cout << "Base2::fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "Base2::fun2()" << endl;
	}
private:
	int b2;
};

class Derive : public Base1, public Base2
{
public:
	virtual void fun1()
	{
		cout << "Derive::fun1()" << endl;
	}
	virtual void fun3()
	{
		cout << "Derive::fun3()" << endl;
	}
private:
	int d1;
};
void test8()
{
	Derive d;
}

img

d 里面存在两个虚表指针，分别指向从 Base1 和 Base2 继承的虚表，并且它们俩的 fun1 都被重写了。

那么问题来了：

fun3 去哪里了？它的函数指针也应该被存进虚表啊。

上面补充过了，监视窗口不一定准，我们还是要自己打印虚表：

typedef void(*V_FUN)();
void PrintVFTable(V_FUN* a)
{
	cout << "虚表地址：" << a << endl;
	for (size_t i = 0; a[i] != nullptr; ++i)
	{
		printf("[%d]:%p->", i, a[i]);
		V_FUN f = a[i];
		f();
	}
	cout << endl;
}

👆：对打印虚表函数稍加改进：增加打印虚表地址，循环条件改成 a[i] != nullptr 因为在vs下，虚表末尾的下一位置一定为空。

通过监视窗口可以看出，d 的前4个字节一定是 Base1 类的虚表指针，Base2 的虚表指针距离 Base1 虚表指针 sizeof(Base1) 的长度，需要对 &d 转换成 char* 后进行偏移。

void test8()
{
	Derive d;
	PrintVFTable((V_FUN*)*(int*)&d);
	PrintVFTable((V_FUN*)*(int*)((char*)&d + sizeof(Base1)));
}
//结果：
//虚表地址：00139B94
//[0]:00131028->Derive::fun1()
//[1]:001312DA->Base1::fun2()
//[2]:001310A0->Derive::fun3()
//
//虚表地址：00139BA8
//[0]:0013111D->Derive::fun1()
//[1]:001310EB->Base2::fun2()

通过结果可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

菱形继承

B C 对 fun 函数重写，虚拟继承防止数据冗余和二义性。

class A
{
public:
	virtual void fun()
	{}
	int _a;
};

class B : virtual public A
{
public:
	virtual void fun()
	{}
	int _b;
};

class C :virtual public A
{
public:
	virtual void fun()
	{}
	int _c;
};

class D : public B, public C//此处报错：“D” : “void A::fun(void)”的不明确继承
{
public:

};

但是报错了，这是怎么回事？

因为虚拟继承会将 D 的两个虚表指针变为一个虚表指针，但是这一个虚表指针应该指向 B 类型的虚表还是 C 类型的虚表是不明确的，所以会报错。

解决方式：在 D 内也重写 fun 函数：

//略。。。
class D : public B, public C
{
public:
	virtual void fun()
	{}
};

小问题

  1. inline 和 virtual 可以同时修饰函数吗？

    答：可以，但是如果是多态调用，编译器会忽略这个 inline ，虚函数会放到虚表中。

  2. 静态成员函数可以是虚函数吗？

    答：不可以，因为静态成员函数没有 this 指针，它的调用可以不借助于对象，而直接使用 :: 调用。违背了多态的概念，无法用于实现多态。

  3. 构造函数可以是虚函数吗？

    答：不可以，因为虚函数存在虚表中，要调用就需要虚表指针。但是虚表指针是在构造函数初始化列表才初始化的。也就是说，要调用构造函数就需要虚表指针，但是不调构造函数没有虚表指针，这就矛盾了，最终导致对象无法被创建。

  4. 析构函数可以是虚函数吗？

    答：可以，并且最好把基类的析构函数定义成虚函数， 具体参考本章：定义及实现/虚函数重写的例外/析构函数的重写。

  5. 对象访问普通函数快还是虚函数快？

    答：对于普通对象的调用是一样快的，如果是指针或引用的调用，则调用普通函数快，因为其与虚函数构成多态，运行时调用虚函数需要去虚函数表中去找。

  6. 虚函数表是在什么阶段生成的，存在哪？

    答：在编译阶段生成，存在常量区（代码段）。

世真
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
详细分析C++ 多态和虚函数
08-18
主要介绍了C++ 多态和虚函数的相关资料，文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
C++ 运用虚指针访问虚函数表，并使用函数指针调用虚函数，可以任意访问虚函数！！！！！！撸了两天！！！！！，附代码
weixin_46609502的博客
05-07 714
通过虚指针访问虚函数表并且调用虚函数表内函数实现多态。 多态的实现就是通过虚函数表和继承来实现 一、多态的实现 现在有两个类 1.父类如下 class base { public: virtual void P() { cout<<"PPPPP of base"<<endl; } virtual void P1() { cout<<"PPPPPP111111 of base"<<endl
c++多态及虚函数表内部原理实战详解
bitcarmanlee的博客
05-17 3563
1.多态实现方式 c++的多态机制主要是靠虚函数来实现。具体来说，就是用父类的指针指向子类的实例，然后通过父类指针调用子类对象中的成员函数。这样，就实现了父类指针的“多态"。 想了解虚函数实现机制，就必须先了解对象的存储方式。 2.类的存储方式 我们以为的存储方式是这样： 上面的图，表示对象的数据和函数代码都要分配内存空间，这样内存的利用效率显然较低，因此实际上存储方式是这样： 每个对象占用存储空间的只是该对象的数据部分（虚函数指针和虚基类指针也属于数据部分），函数代码属于公用部分。我们常说的“A对象的成
C++：多态与虚函数,纯虚函数
a2998658795的博客
07-28 614
C++：多态与虚函数,纯虚函数
C++多态: 虚函数 协变与析构函数的重写
HUAERBUSHI521的博客
06-26 1605
一.多态 定义:顾名思义就是多种形态,就是对于同一个行为,不同的对象去完成就会产生不同的结果. 多态的构成条件 多态是继承体系中的一个行为,如果要在继承体系中构成多态,需要满足两个条件: 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数,并且派生类必须要对继承的基类的虚函数进行重写 二.虚函数 虚函数就是被virtual修饰的类成员函数(这里的virtual和虚继承的virtual虽然是同一个关键字,但是作用不一样). class preson{ public: ..
C++ 多态(1): 虚函数及实现原理
TechArtisan6的博客
07-09 1239
C++远征之多态篇视频教程 笔记 方便自己查阅和复习，温故而知新。 目录 1虚函数及实现原理 2 代码示例1 3 代码示例2 参考资料 多态 多态指相同对象接收到不同消息或不同对象收到相同消息时产生不同的动作。 多态分为静态多态和动态多态。 (1) 静态多态也称为早绑定。 (2) 动态多态也称为晚绑定，必须以封装和继承为基础。 1虚函数及实现原理 (1...
c++语言中虚函数实现多态的原理详解
12-25
自上一个帖子之间跳过了一篇总结性的帖子，之后再发，今天主要研究了c++语言当中虚函数对多态的实现，感叹于c++设计者的精妙绝伦 c++中虚函数表的作用主要是实现了多态的机制。首先先解释一下多态的概念，多态是c++...
C++中的多态与虚函数的内部实现方法
01-01
1、什么是多态 多态性可以简单概括为“一个...（2）运行时多态：主要通过虚函数来实现。 2、几个相关概念 （1）覆盖、重写（override） override指基类的某个成员函数为虚函数，派生类又定义一成员函数，除函数体的其余
深入解析C++中的虚函数与多态
01-21
1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是...
C语言——函数指针与指针函数
qq_67319052的博客
05-19 617
函数指针与指针函数有什么区别？
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 700
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
复现的博客
05-23 273
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c语言操作注意事项
dropLin的博客
05-20 186
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C++质数的那些事（判断指数、区间筛质数、互质等等）
最新发布
A1063348628的博客
05-23 119
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
【C++】多态
malloc不出对象的博客
05-23 375
本篇文章讲解的C++中的多态，它是面向对象语言中最重要的特性之一，它能对同一行为表现出不同的形态！！
C++中的复合数据类型及高级特性概览
a_Loki的博客
05-23 198
C++作为一种面向对象的编程语言，提供了丰富的复合数据类型和高级特性，以增强代码的表达能力和效率。本文将概述结构体、联合体、枚举类型的基本概念，探讨函数重载的原则，解释重载解析的优先级，并简要介绍内联函数的作用及其优缺点。
【C语言】实现贪吃蛇--项目实践（超详细）
2301_78724721的博客
05-23 669
本次实现贪吃蛇会使⽤到的⼀些Win32 API知识，接下来我们就学习⼀下。
文件操作（C语言）
2303_76654613的博客
05-19 670
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 738
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
c++实验多态与虚函数实验
04-28
好的，我可以为您介绍一下关于C++中多态和虚函数的实验。 首先，多态是指不同对象以不同的方式响应相同的消息的能力。在C++中，通过虚函数来实现多态。虚函数是指在基类中被声明为虚函数的函数，在派生类中被重写后，在程序中使用基类指针或引用调用该函数时，会调用派生类中的函数。 下面是一个简单的多态和虚函数的实验示例： ```c++ #include<iostream> using namespace std; class Shape { public: virtual void draw() { cout << "Drawing Shape" << endl; } }; class Circle: public Shape { public: void draw() { cout << "Drawing Circle" << endl; } }; class Square: public Shape { public: void draw() { cout << "Drawing Square" << endl; } }; int main() { Shape *s; Circle c; Square sq; s = &c; s->draw(); s = &sq; s->draw(); return 0; } ``` 运行结果为： ``` Drawing Circle Drawing Square ``` 在上述示例中，我们定义了一个基类Shape和两个派生类Circle和Square，分别重写了基类的虚函数draw()。在程序中，我们先定义了一个基类指针s，然后将其指向第一个派生类对象c，再调用s的虚函数draw()，此时会调用派生类Circle的draw()函数，因为指针实际上指向的是Circle类型的对象。接着，我们将指针s重新指向第二个派生类对象sq，再次调用s的虚函数draw()，此时会调用派生类Square的draw()函数。 通过这个实验，我们可以看到多态和虚函数的特性，即通过基类指针或引用调用虚函数时，会根据实际对象的类型来调用相应的派生类函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

世真

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

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

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

打赏作者

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

抵扣说明：

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

余额充值