详解C++三大特性之多态

最新推荐文章于 2022-12-11 11:21:45 发布
最新推荐文章于 2022-12-11 11:21:45 发布
阅读量592 收藏 7
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2076188013/article/details/126420806
版权

文章目录

1.多态概念

概念

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

举个例子：
比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2.多态的定义及实现

虚函数

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

虚函数重写：

派生类中有一个跟基类完全相同的虚函数，包括返回值类型、函数名、参数列表都相同，称子类虚函数重写了父类虚函数。
注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用。

构成多态2个要求

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

1、子类虚函数重写父类虚函数 （重写要求虚函数 + 函数名/参数/返回值都相同）
只要有一个不同，就会直接去调用父类的。

2、必须是父类指针、引用去调用虚函数

class Person
{
protected:
	string _name;
	//int _id;
public:
	Person(const char* name)
		:_name(name)
	{}

	// 虚函数
	virtual void BuyTicket() { cout << _name << " Person: 买票-全价 100元" << endl; };
};

class Student : public Person
{
public:
	Student(const char* name)
		:Person(name)
	{}

	// 虚函数 + 函数名/参数/返回值都相同  -》 重写/覆盖
	// 子类重写了父类的虚函数
	virtual void BuyTicket() { cout << _name << " Student：买票-半价 50 ￥" << endl; }
};

class Soldier : public Person
{
public:
	Soldier(const char* name)
		:Person(name)
	{}

	virtual void BuyTicket() { cout << _name << " Soldier：优先买预留票-88折 88 ￥" << endl; }
};

// 多态2个要求
// 1、子类虚函数重写父类虚函数 （重写要求虚函数 + 函数名/参数/返回值都相同）
// 2、必须是父类指针、引用去调用虚函数

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

int main()
{
	int option = 0;
	cout << "================================================" << endl;
	do
	{
		cout << "请选择身份：";
		cout << "1、普通人 2、学生 3、军人" << endl;
		cin >> option;
		cout << "请输入名字：" << endl;
		string name;
		cin >> name;
		switch (option)
		{
		case 1:
			// 需要转化为const char* 类型字符串
			// 不考虑内存泄露，直接new
			Pay(new Person(name.c_str()));
			break;
		case 2:
			Pay(new Student(name.c_str()));
			break;
		case 3:
			Pay(new Soldier(name.c_str()));
			break;
		default:
			cout << "输入错误，请重新输入" << endl;			break;
		}
		cout << "================================================" << endl;
	} while (option != -1);
}

在这里插入图片描述

换成引用试试。

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

int main()
{
	int option = 0;
	cout << "================================================" << endl;
	do
	{
		cout << "请选择身份：";
		cout << "1、普通人 2、学生 3、军人" << endl;
		cin >> option;
		cout << "请输入名字：" << endl;
		string name;
		cin >> name;
		switch (option)
		{
		case 1:
		{
			// case里面不能直接定义对象，需要加域{}
			Person p(name.c_str());
			Pay(p);
			break;
		}
		case 2:
		{
			Student s(name.c_str());
			Pay(s);
			break;
		}

		case 3:
		{
			Soldier s(name.c_str());
			Pay(s);
			break;
		}

		default:
			cout << "输入错误，请重新输入" << endl;			break;
		}
		cout << "================================================" << endl;
	} while (option != -1);
}

传的是对象就不构成多态了。

// 如果传的是对象，不构成多态了。
void Pay(Person ptr)
{
	ptr.BuyTicket();
    // 调用的都是父类的那个
}

在这里插入图片描述

虚函数重写2个例外

  1. 协变
    基类与派生类虚函数返回值类型不同。但要求他们必须是父子关系，可以是指针或者引用。
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;
	}
};

int main()
{
	Person p;
	Student s;
	Person* ptr = &p;
	ptr->f();

	ptr = &s;
	ptr->f();

	return 0;
}

// virtual A* Person::f()
// virtual B* Student::f()

在这里插入图片描述

// 引用的情况。
class A{};
//class B{};
class B : public A {};

// 虚函数重写对返回值要求有一个例外：协变，要求返回值是父子关系，指针或者引用都行
class Person {
public:
	virtual A& f() { 
		cout << "virtual A& Person::f()" << endl;
		return (A&)A();
	}
};

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

  1. 析构函数重写

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

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	// Person析构函数加了virtual，关系就变了
	// 由原来的重定义(隐藏) -->  重写(覆盖)关系
	// 不过这种变化对于普通对象没有影响
	 ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person p;
	Student st;
	// 派生类的析构函数调用完成后会自动调用基类的析构函数
	return 0;
}

//~Student()
//~Person()
//~Person()

class Person {
public:
	~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	 ~Student() { 
		 cout << "~Student()" << endl;
		 delete[] _name;
		 // 如果以char*打印，打印的是字符串，直到\0才截止
		 // 强转成void*后，打印的是地址
		 cout << "delete: " << (void*)_name << endl;
	 }

private:
	char* _name = new char[10]{ 'j', 'a', 'c', 'k' };
};

int main()
{
	//父类指针，可以指向父类对象，也可以指向子类对象
	Person* ptr = new Person;
	delete ptr; // 调用的是ptr->destructor() + operator delete(ptr)
	// 不构成多态的话，这只是一个普通调用，类型是Person，就会去调用Person的析构函数

	ptr = new Student;
	delete ptr;
	// 这里期望调用子类的析构函数，但还是调用了父类，子类有资源没被释放，内存泄露了
	return 0;
}
// ~Person()
// ~Person()
// 这里只是普通调用而不是多态调用

因此我们希望delete ptr 调用析构函数是一个多态调用。
而多态调用需要的是子类虚函数的重写，且让父类指针或引用去调用。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	~Student() {
		cout << "~Student()" << endl;
		delete[] _name;
		cout << "delete: " << (void*)_name << endl;
	}

private:
	char* _name = new char[10]{ 'j', 'a', 'c', 'k' };
};

int main()
{
	//父类指针，可以指向父类对象，也可以指向子类对象
	Person* ptr = new Person;
	delete ptr; // 调用的是ptr->destructor() + operator delete(ptr)
	// 不构成多态的话，这只是一个普通调用，类型是Person，就会去调用Person的析构函数

	ptr = new Student;
	delete ptr;
	return 0;
}
// 父类析构函数加上virtual 变成多态调用。
// ~Person()
// ~Student()
//	delete: 000001D126A93CD0
// ~Person()

不过子类析构函数最好还是加上virtual。

举个例子

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

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

int main(int argc ,char* argv[])
{
    B*p = new B;
    p->test();
    return 0;
}
// 输出结果？

在这里插入图片描述

注意，一个是继承调用，一个是多态调用。

怎么说呢，这样设计其实不太好。还不如就设计成子类不写virtual就报错，父类子类参数不一致也报错。

如果p直接调用func呢

int main(int argc ,char* argv[])
{
    B*p = new B;
    p->func(); // B->0
    // 这里只是普通调用，不符合多态的条件，p不是父类的指针或引用。
    
    A* p2 = new B;
    p2->func(); // 这才是多态调用 B->1
    return 0;
}

C++11 override 和 final

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

final：修饰虚函数，表示该虚函数不能被重写。

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

在这里插入图片描述

此外，借助final，还能写出不能被继承的类。

// C++11 final修饰父类，表示该类不能被继承
class Car final
{
public:
private:
};
class Benz :public Car
{
public:
};

在这里插入图片描述

// C++98中，只能将父类构造函数私有化来达到间接不能继承的效果
class Car
{
public:
private:
	Car()
	{}
};
class Benz :public Car
{
public:
};

int main()
{
	Benz bz; //err
	return 0; 
}

在这里插入图片描述

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

class Car {
public:
	virtual void Drive() {}
};
// override 写在子类中，要求严格检查是否完成重写，没完成会报错。
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

在这里插入图片描述

仅仅是参数不同也能检查出来没完成重写。

在这里插入图片描述

重载、重写、重定义

  1. 重载
    • 2个函数在一个作用域
    • 函数名相同、参数不同（包括数量、类型、顺序）
  2. 重写(覆盖)
    • 2个函数分别在基类和派生类的作用域
    • 函数名、参数、返回值都必须相同（斜变例外）
    • 2个函数必须是虚函数
  3. 重定义(隐藏)
    • 2个函数分别在基类和派生类的作用域
    • 函数名相同
    • 2个基类和派生类的同名函数不构成重写就是重定义
    • 同名的成员变量也是隐藏关系

3.抽象类

概念

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

// 抽象类 -- 在现实中一般没有具体对应的实体
// 不能实例化出对象
class Car
{
public:
    // 纯虚函数
	virtual void Drive() = 0;
};

int main()
{
	Car c; //err 无法实例化抽象类
	return 0;
}

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

class BMw :public Car
{

};
int main()
{
	BMw bw; // err 也无法实例化出对象
	return 0;
}

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

class BMw :public Car
{
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};
int main()
{
	BMw bw; // 子类重写之后就能实例化出对象了。
	return 0;
}

定义指针

抽象类基类虽然无法实例化对象，但是可以定义出指针。

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

class BMw :public Car
{
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};
int main()
{
	Car* pBMw = new BMw;
	pBMw->Drive();
	return 0;
}

注意：纯虚函数的实现没有意义，也就是纯虚函数可以有函数体，只不过没有意义。
因为没有人可以调用他，只是为了把这个接口继承下去而已。

接口继承和实现继承

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

4.多态原理

虚函数表

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

int main()
{
	Base b;
	cout << sizeof(Base) << endl; //8
	return 0;
}

在这里插入图片描述

除了_b成员，还有一个__vfptr放在对象的前面，对象中的这个指针我们叫做虚函数表指针(v代 表virtual，f代function)。一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

注意：这个指针指向的是虚函数表，表中存有指向虚函数的指针。

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
	void Func2()
	{
		cout << "Func2()" << endl;
	}
	virtual void Func3()
	{
		cout << "Func3()" << endl;
	}
private:
	int _b = 1;
	char _ch;
};

int main()
{
	Base b;
	cout << sizeof(Base) << endl; //12
	// b中有一个_b _ch __vfptr
	return 0;
}

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

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

int main()
{
	Base b;
	cout << sizeof(Base) << endl; // 8
	Derive d;
	cout << sizeof(Derive) << endl; // 12

	return 0;
}

在这里插入图片描述

派生类对象d由2部分构成，一部分是父类继承下来的成员，虚表指针也就是存在这一部分，另一部分就是派生类自己的成员。

总结一下派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后

多态原理

int main()
{
	Base b;
	cout << sizeof(Base) << endl; // 8
	Derive d;
	cout << sizeof(Derive) << endl; // 12

    // prt指向父类对象时，ptr->Func1() 在b的虚表中找到的虚函数是 Base::Func1()
	Base* ptr = &b;
	ptr->Func1();
	ptr->Func2();
    // 当ptr指向子类对象时，ptr->Func1() 在d的虚表中找到的是虚函数是 Derive::Func1()
	ptr = &d;
	ptr->Func1();

	Base* ptr2 = &b;
	ptr2->Func2();
	ptr2 = &d;
	ptr2->Func2();
	return 0;
}

这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

在这里插入图片描述

查看反汇编也可得知，多态调用是在运行时才确定调用函数的地址的。

在这里插入图片描述

引用也有一样的效果：

int main()
{
	Base b;
	Derive d;
	
    // 引用也有一样的效果
	Base& r1 = b;
	r1.Func1();
	r1.Func2();

	Base& r2 = b;
	r2.Func1();
	r2.Func2();
	return 0;
}

在这里插入图片描述

派生类对象也可以赋值给基类对象，完成切片，但为什么这样不能实现多态调用。

int main()
{
	Base b;
	Derive d;
	
	Base& r1 = b;
	r1.Func1(); // Base ：virtual void Func1()
	r1.Func2(); // Base ：void Func2()

	Base& r2 = b;
	r2.Func1(); // Base ：virtual void Func1()
	r2.Func2(); // Base ：void Func2()
	return 0;
}

编译器只会去检查是否符合多态的条件，符合就运行时去找函数地址，不符合就编译时去找函数地址。

对象切片的时候，子类只会拷贝成员给父类对象，不会也不能拷贝虚表指针。
因为如果把虚表指针也拷贝过去，这样父类的虚表指针就也是指向子类的虚表了，调用时就会混乱了。

但是指针、引用切片就不一样了。不存在拷贝，就不会发生上述的混乱情况。
在这里插入图片描述

动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态。
    比如：函数重载（有些书也把函数重载叫做静态的多态）
    这也就是编译时决议。
int main()
{
  int x = 1, y = 0;
  double a = 1.1, b = 0.0;
  swap(x, y);
  swap(a, b);
  // 感觉好像是同一个函数，其实不是，实际是编译链接时根据函数名修饰规则找到不同的函数。
  return 0;
}
  1. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
    这也就是运行时决议。

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

单继承

继续利用上面的例子，当我们给子类自己增加了一个虚函数，也能在虚函数表中找到吗？

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

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

int main()
{
	Base b;
	Derive d;

	return 0;
}

没有发现Func4的？
在这里插入图片描述

借助内存窗口观察一下：
在这里插入图片描述

通过虚表指针，找到虚表，缺省发现虚表中有3个指针存在，前面2个都是继承下来的虚函数。第三个难道就是子类自己的虚函数指针吗？

如何确认呢？
可以再写一个类去继承Derive。

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

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

class DDerive : public Derive
{
public:
	virtual void Func4()
	{
		cout << "DDerive ：virtual void Func4()" << endl;
	}
private:
	int _dd = 3;
};
int main()
{
	Base b;
	Derive d;
	DDerive dd;

	return 0;
}

好像并没有用。

在这里插入图片描述

没办法了，只能尝试去打印虚表。

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

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

// 想办法打印虚表，取内存值，打印并调用，确认是否存在Func4
// 虚表指针指向的是个指针数组，而且全都是函数指针
typedef void(*V_FUNC)();
// 等价于 typedef void(*)() V_FUNC; 必须把typedef的名字放在中间

//void PrintVFTable(V_FUNC a[])
void PrintVFTable(V_FUNC* a)
{
	printf("vfptr:%p\n", a);
	// VS下虚表指针最后是有一个nullptr的 或者清楚有几个虚函数也行
	for (size_t i = 0; i < 3; ++i)
	{
		printf("[%d]:%p\n", i, a[i]);
		// 有了函数地址就可以调用函数
		V_FUNC f = a[i];
		f();
	}
}
int main()
{
	Base b;
	Derive d;
	// 取前四个字节就是虚表指针
	//PrintVFTable((*(int*)&d)); // 这样解引用后是一个int不符合，还需再转一次
	PrintVFTable((V_FUNC*)(*((int*)&d)));

	return 0;
}

在这里插入图片描述

在这里插入图片描述

因此我们也能确认，监视窗口将Func4隐藏了。

注意：

虚表存的只是虚函数的指针，虚函数和普通函数一样都是存在代码段里的。

一个类型就有一个虚表，所有这种类型的对象都存相同的虚表指针，也就是相同类型的对象公用一个虚表。

在这里插入图片描述

这也就要求虚表要放在一个永久的区域，那就只剩静态区或者常量区了。

如何进一步确定？

int c = 0;
int main()
{
    Base b1;
    Base b2;
    Base b3;
    PrintVFTable((V_FUNC*)(*((int*)&b1)));
    PrintVFTable((V_FUNC*)(*((int*)&b2)));
    PrintVFTable((V_FUNC*)(*((int*)&b3)));

    // 验证虚表存在常量区还是静态区
    int a = 0;
    static int b = 1;
    const char* str = "hello";
    int* p = new int[10];
    printf("栈：%p\n", &a);
    printf("静态区/数据段：%p\n", &b);
    printf("静态区/数据段：%p\n", &c);
    printf("常量区/代码段：%p\n", str);
    printf("堆：%p\n", p);
    printf("虚表：%p\n", (V_FUNC*)*((int*)&b3));
    printf("函数地址：%p\n", &Derive::Func1);
    printf("函数地址：%p\n", &Derive::Func2);
    printf("函数地址：%p\n", &Derive::Func3);
    return 0;
}

在这里插入图片描述

通过比对，可以发现，虚表是存在于代码段，而函数也是存在代码段里的。

并且对象存的也只是虚表指针__vfptr。

多继承

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

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

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}

int main()
{
	//printf("%p\n", &Derive::func1);

	Derive d;
	PrintVTable((VFPTR*)(*(int*)&d));
	// 取出d的地址后，类型是Derive* +1跳过的是sizeof(Derive)
	PrintVTable((VFPTR*)(*(int*)((char*)&d+sizeof(Base1))));

	return 0;
}

在这里插入图片描述

在这里插入图片描述

我们可以发现，同样是func1函数，但为啥虚表1和虚表2里面的func1函数地址不同呢？
哪个才是真正的func1呢？

int main()
{
	//printf("%p\n", &Derive::func1);

	Derive d;
	PrintVTable((VFPTR*)(*(int*)&d));
	// 取出d的地址后，类型是Derive* +1跳过的是sizeof(Derive)
	PrintVTable((VFPTR*)(*(int*)((char*)&d+sizeof(Base1))));

	printf("func1 : %p\n", &Derive::func1);
	return 0;
}

在这里插入图片描述

结论就是，VS下将真正的地址封装起来了，通过多次跳转才能真正找到真正的func1。

在这里插入图片描述

int main()
{
	Derive d;
	Base1* ptr1 = &d;
	Base2* ptr2 = &d;
	// 调用的都是Derive::func1 但是是在2个虚表中找到的覆盖的func1
	ptr1->func1(); // Derive::func1
	ptr2->func1(); // Derive::func1
	return 0;
}

调用Base2虚表中的func1时，是ptr2去调用，Base2不是第一个继承的类，ptr2发生切片指针偏移，ptr2指向的不是Derive对象的地址，而是指向的Base2，要找到Base1，就 需要修正存储this指针ecx的值。
在这里插入图片描述

6.细节

内联函数可以是虚函数吗

可以，但是只能是普通调用才会正常展开inline，如果是多态调用则会忽略内联属性。

注意，要想查看inline的展开过程还需要配置一番：
在这里插入图片描述

在这里插入图片描述

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

	virtual void f2();
private:
	int _a;
};

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

	virtual void f2();
};

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

void B::f2()
{
	cout << "B::f2()" << endl;
}

void Func1(A* ptr)
{
	ptr->f1();
	ptr->f2();
}

void Func2(A ptr)
{
	ptr.f1();
	ptr.f2();
}

int main()
{
	A aa;
	B bb;
	Func1(&aa);
	Func1(&bb);

	Func2(aa);
	Func2(bb);

	return 0;
}

静态成员可以是虚函数吗

不能，静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，因此静态成员函数无法放进虚函数表。

在这里插入图片描述

构造函数可以是虚函数吗

不可以，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
多态的调用是调用之前就要去虚表里面去找，构造函数之前，虚表都还没初始化，自然没法找的。

在这里插入图片描述

析构函数可以是虚函数吗

可以，并且最好把基类的析构函数定义成虚函数。

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

如果是普通对象，是一样快。

如果是指针对象或者引用对象，调用普通函数快，调用虚函数时还需要去虚函数表里面找。

虚函数表什么时候生成

虚函数表在编译阶段就生成了，一般情况下存在代码段的。
注意，虚函数表和虚函数表指针不同，构造函数初始化列表时才初始化好虚函数表指针，是让__vfptr指向早就生成好的虚函数表。

尾声

🌹🌹🌹

写文不易，如果有帮助烦请点个赞~ 👍👍👍

Thanks♪(･ω･)ﾉ🌹🌹🌹

😘😘😘

👀👀由于笔者水平有限，在今后的博文中难免会出现错误之处，本人非常希望您如果发现错误，恳请留言批评斧正，希望和大家一起学习，一起进步ヽ(￣ω￣(￣ω￣〃)ゝ，期待您的留言评论。
附GitHub仓库链接

TauCeti0207
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++三大特性，七项原则
qq_43685242的博客
08-07 745
1. C++面向对象三大特性 1. 封装 封装：把客观事物抽象为类，并且类可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏。 类将成员变量封装在类的内部，根据需求设置访问权限，通过成员函数管理内部状态。 2. 多态 多态简单讲可以概括为“一种接口，多种方法”，多种形态，程序在运行过 程才决定要调用的函数，是核心概念。 ps：重载，重写，重定义的区别： 重载，同一作用域的同名函数 1.同一个作用域 2.参数个数，参数顺序，参数类型不同 3.和函数返回值，没有关系 4.const也可以作为
C++面向对象之多态的实现和应用详解
12-31
大家应该都听过C++三大特性之一多态，那么什么多态呢？多态有什么用？通俗一点来讲-> 多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。当多态应用...
C++ 三大特性之多态
chen1415886044的博客
01-30 621
C++的三大特性：封装、继承、多态。封装可以使得代码模块化，继承可以扩展已存在的代码，而多态的目的则是为了接口重用。下面主要以介绍多态为主。 什么是多态 C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。 多态性指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态...
对象的多态性
Nishuibaichuan 的博客
08-19 1119
一.  多态性 多态性在面向对象中是一个最重要的概念，在java中面向对象主要有以下两种主要的体现. 1.  方法的重载和覆写 2.   对象的多态性 对象的多态性主要分为以下两种类型： (1)向上转型：子类对象->父类对象 对于向上转型，程序会自动完成，格式： 对象向上转型：父类   父类对象 = 子类实例; (2)向下转型：父类对象-
C++之多态
m0_72647108的博客
08-17 567
多重继承虚基类抽象类纯虚函数。
java对象的多态性
chenming_1799701236的博客
09-04 334
1、在java中面向对象的多态性主要有一下两种体现：       (1)、方法的重载和重写；       (2)、对象的多态性；       对象的多态性主要是以下两种类型：               (1)、向上转型：子类对象--> 父类对象     格式：父类 父类对象 = 子类实例               (2)、向上转型：父类对象-->子类对象      格式：子类 子
详解C++ 多态的实现及原理
01-20
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用...
详解C++值多态中的传统多态与类型擦除
08-19
值多态是一种介于传统多态与类型擦除之间的多态实现方式，借鉴了值语义，保留了继承，在单继承的适用范围内，程序和程序员都能从中受益。这篇文章主要介绍了C++值多态中的传统多态与类型擦除,需要的朋友可以参考下
C++多继承多态的实例详解
01-01
C++多继承多态的实现 如果一个类中存在虚函数，在声明类的对象时，编译器就会给该对象生成一个虚函数指针，该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制，在编译期间不确定...
c++多态
m0_46408680的博客
05-30 103
多态的定义简单来说就是使一条语句有多种状态。 多态又分为静态多态和动态多态： 静态多态：函数重载和运算符重载属于静态多态，复用函数名。 动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 静态联编：是程序的匹配、连接在编译阶段实现，也称为早期匹配。 重载函数使用静态联编。 动态联编，是指程序联编推迟到运行时进行，所以又称为晚期联编。switch 语句和 i...
java面向对象- 多态性的体现和使用
weixin_34347651的博客
03-27 353
多态体现：方法的重载和重写对象的多态性2.对象的多态性：向上转型：程序会自动完成父类 父类对象 = 子类实例向下转型：强制类型转换子类 子类对象 = （子类）父类实例 classA{ publicvoidtell01(){ System.ou...
C++三大特性之多态
new9232的博客
12-11 832
多态性是面向对象程序设计的重要特性。利用多态性可以设计和实现一个易于扩展的系统。在C++中，多态性是指具有不同功能的函数用同一个函数名，即用同一函数名调用不同内容的函数。
对象的多态性是怎么体现的，与重载有什么不同
Never_turnback的博客
07-06 1048
对象的多态性是怎么体现的，与重载有什么不同 \quad\quad 现在有这样一个需求： \quad\quad要求结合对象的多态性，对一个简易的商场打折系统的代码进行重构: public static int calculatePrice(String discountStrategy, int price, User user) { switch (discountStrate...
面向对象的特征之三:多态性
Kenyangi
10-02 1065
编译，看左边;运行，看右边。
C++ 面向对象程序三大特性之 多态
WhiteShirtI的博客
05-02 1748
多态的概念 不同类的对象对同一消息作出不同的响应就叫做多态，通俗来讲，就是去完成某个行为，当不同的对象去完成时会产生出不同的结果 例如去网吧上机，如果你是vip，那么你上网的价格就会比普通用户上网的价格低；如果你不是vip，那么你上网的价格就是原价。这就是生活中的一种多态现象 多态的定义及使用 例如以下程序，就是一种多态的体现 class Vip { public: virtual void online() { cout << "7折优惠" << endl; } };
重构一：用多态替换switch语句
chens616的专栏
12-16 8639
    编程中我们尽量少用switch语句，使用switch语句会出现大量重复代码，我们可以采用java的多态特性，使用state模式来替换switch语句，具体方式如下：    举个例子，假设一个电影租赁的程序，包括客户(Customer)、租赁(Rental)、电影(Movie)三个类， 在Movie类中，有一个获取电影租金的方法getChartge，它需要根据电影的类型和租期来计算电...
为什么要用多态
tushenfengle的博客
09-30 2171
多态是OOP（面向对象编程）的一项重要技术。 任何技术都不是凭空想出的，他都是为了解决一定实际问题的。多态其实是程序设计的一种方法学，他不仅能让程序设计更加易实现，也更容易维护和扩展。程序的初学者大多很难在一开始就理解这些技术难点。 下面看一个应用场景，一个软件要实现下面功能：用户在界面上添加各种几何图形（圆，三角形和正方形），用户可以以任意顺序、任意数量（当然内存不要溢出即可）添加上述几何图...
【Java】多态代替switch
u010900754的专栏
01-12 2722
尽量消除if-else，使用多态代替。原因在于，如果用if-else，新增一种或者删除一种，所有的if-else都要改动。而使用多态，只需要新增或者删除一个实现类。如果保证只有一处if-else，那么可以不用多态，但是如何保证只有一处呢？所以还是要用多态消除if-else。当然使用了多态也不是说完全不用if-else，多态会在构建子类对象时用一次if-else，之后子类信息已经确定了，后面的行为都...
C++三大特性？多态的使用场景？什么时候用多态？
最新发布
08-11
- *3* [C++ 三大特性之多态(二) 多态的实现原理](https://blog.csdn.net/weixin_57761086/article/details/126674040)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值