C++: 多态

最新推荐文章于 2025-05-17 22:15:01 发布

长亭序宴

最新推荐文章于 2025-05-17 22:15:01 发布

阅读量918

点赞数 10

文章标签： c++ 开发语言

本文链接：https://blog.youkuaiyun.com/2301_79490289/article/details/139130331

版权

2.6override 和 final（C++11）

1.final

2.override

2.7重载、覆盖（重写）和隐藏（重定义）的区别

一、多态的概念

完成某个行为时，不同对象会产生不同状态。

二、多态的定义及实现

2.1虚函数

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

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

2.2虚函数的重写

虚函数的重写（覆盖）：派生类有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称派生类的虚函数重写了基类的虚函数。

大家看到这可能会想到前面继承学的隐藏，回顾一下隐藏的概念。只要父类和子类有共同的成员名字，就构成隐藏，这不需要父类和子类的函数参数也相同。虚函数的重写比隐藏的定义更严格，两个分别在父类和子类函数的关系，函数名相同，不是重写，就是隐藏。如果满足重写，那就是重写。

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

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

上述代码就展示了虚函数的重写，注意虽然子类可以不加virtual 也能和父类构成重写，但这种写法不太规范，不建议使用。

2.3多态的构成条件

多态是在不同的继承关系的类对象，去调用同一函数，产生了不同的行为。

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

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

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

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

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

void Func(A& a)
{
   a.Print();
}

int main()
{
    A a1;
    Func(a1);

    B b1;
    Func(b1);
    return 0;
}

传给Func的是基类的引用，传的是基类，调用的就是基类的函数，传的是派生类，那么调用的就是派生类的函数。非常方便。Func的函数是灵魂，它的参数是基类的引用或者指针。

2.4虚函数重写的两个例外

1.协变

（基类与派生类虚函数返回类型不同）

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

2.析构函数的重写

如果基类函数的析构函数是虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然此时基类与派生类析构函数名字不同，但这里是编译器对析构函数名称进行了统一处理，处理成了destructor，所以可以看成是相同的。这时候，只有delete调用析构函数的时候，才能构成多态。

2.5虚函数重写的实质

虚函数重写，继承了接口，重写的是具体的实现。

2.6override 和 final（C++11）

这两个关键字是用来帮助用户检测某个函数是否重写的。

1.final

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

class A
{
public:
      virtual void Func() final
    {
 
    }

};

2.override

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

class A
{
virtual void Func()
{
   cout<<A::Func()<<endl;
}

};

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

2.7重载、覆盖（重写）和隐藏（重定义）的区别

重载

a.两个函数在同一个作用域

b.函数名相同，参数类型、顺序或个数不同

重写（覆盖）

a.两个函数分别在基类和派生类作用域

b.函数名，参数和返回值都必须相同（协变例外）

c.两个函数必须是虚函数

重定义（隐藏）

a.两个函数分别在基类和派生类作用域

b.两个函数的函数名相同

c.基类和派生类的函数名相同，不构成重写就是重定义

三、抽象类

3.1概念

在虚函数的后面写个=0，那么这个虚函数就是纯虚函数。包含纯虚函数的类叫抽象类。纯虚函数不能实例化对象，继承以后的纯虚函数也不能实例化对象，它规定必须重写这个函数才能使用。纯虚函数体现了接口继承，因为虚函数的重写本就是继承了接口，重写了实现。这里纯虚函数重写主要就是继承了接口。

3.2接口继承和实现继承

普通函数的继承，派生类继承了基类的函数，继承的是实现。

虚函数继承是一种接口继承，继承的是基类的接口，就是参数的列表，目的是为了重写，达成多态。达成同一个接口但能有不同的反应。所以如果不实现多态，就不要写虚函数。

四、多态的原理

4.1虚函数表

写个代码，基类为Person，有两个虚函数分别是Print（）和Func2（）和一个普通函数Func3(),派生类为Student，继承了Person，并且重写了Person里的Print（）。

namespace ting 
{
	class Person
	{
	public:
		virtual void Print()
		{
			cout << "买票全价" << endl;
		}

		virtual void Func2()
		{
			cout<<"Person::Func2()" << endl;
		}

		 void Func3()
		{
			cout << "Person::Func3()" << endl;
		}
	};

	class Student: public Person
	{
	public:
		virtual void Print()
		{
			cout << "买票85折" << endl;
		}
	private:
		int a = 18;
	};

	void test1()
	{
		Person p1;
		Student s1;
	}
}

测试代码主要是对test1()的调用，这里暂时不写了。通过对上述代码调试，监视窗口可以看到s1和p1里都有一个_vfptr放在对象的前面（如下图所示），对象中的这个指针我们叫做虚函数表指针(v即virtual，f即function,ptr即指针）

一个含有虚函数的类中至少要有一个虚函数表指针，这个指针指向一个虚函数表，这个虚函数表里存储虚函数的地址，虚函数表也叫虚表。

通过观察，我们得到以下结论：

1.派生类对象，上述s1中，包含的内容有两部分。一是它从父类继承的成员，比如虚表指针，第二部分是它自己的成员。

2.基类对象和派生类对象不一样，这里Print（）在派生类进行了重写，所以在s1里的虚表里原来存Person::virtual void Print()这个函数的地址，现在存Student::virtual void Print()函数的地址。完成了覆盖。重写是语法层面上的，覆盖是原理层上的叫法。

3.Func2继承下来了，它是虚函数，所以放在虚表中，Func3继承了，不过它不是虚表，所以没放在虚表里。

4.虚函数表本质是一个指针数组，一般这个数组的最后放了nullptr.

5.派生类的虚表生成：1,先将基类的虚表拷贝一份到派生类虚表中 2，如果派生类重写了基类的某个虚函数，则用这个虚函数覆盖虚表内的虚函数。 3,派生类自己新增加的虚函数按其在派生类的声明次序，增加到派生类虚表的最后。

6.对象中存的是虚表指针，虚表指针中存的是虚表，虚表中存的是虚函数指针，虚函数指针指向虚函数，虚函数和普通函数一样存在代码段。虚表在vs下存在代码段。

4.2多态的原理

拿出上面的代码分析。

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

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

void Func(A& a)
{
   a.Print();
}

int main()
{
    A a1;
    Func(a1);

    B b1;
    Func(b1);
    return 0;
}

在Func调用基类的对象a1时，Func从传来的引用，基类的对象a1中去找虚函数指针，找虚表，然后找到要调用的函数。如果是派生类的对象b1,就从b1中去找虚函数指针，找虚表，找到相应的地址和指向的函数，从而实现了多态，即相同的接口，传的对象不同，实现不同的行为。

多态的函数调用，并不是在编译时确定的，而是在运行时在对象中去找的。

4.3静态绑定和动态绑定

静态绑定又称为前期绑定，在程序编译时就确定了程序的行为，也成为静态多态。比如：函数重载。

动态绑定又称为晚期绑定，在运行期间，根据具体拿到的类型，确定程序的具体行为，调用具体的函数，称为动态多态。

五、单继承和多继承关系中的虚函数表

看到这一节，即将进入王炸阶段。复杂程度可以把初学者按在地上狠狠摩擦。（手动呲牙）

这里主要关注的是派生类的虚函数表。

5.1单继承

如何打印派生类B的对象的虚表?

namespace ting
{
	class A
	{
	public:
		virtual void Func1() {};
		virtual void Func2() {};
		virtual void Func3() {};
		virtual void Func4() {};
	};

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

	void test2()
	{
		A a1;
		B b1;

	}
}

具体过程在下面代码中注释了，这里主要讲几个要点：

1.为了获取虚表地址，首先获取a1地址，a1是整个对象的地址，我们要取虚表的地址，虚表地址在a1的前面4个或8个字节（32位是4个字节，64位是8个字节）。可以通过强制类型转换。再解引用。

不过这里采用先转为VFPTR的二级指针，VEPTR*是虚表指针，VFPTR**是指向虚表的指针，通过先转化位二级指针，再解引用，转化为虚表指针。这样比较安全，一般情况下，直接强制转换成VFPTR*可能不太准确。

2.得到虚表指针的地址，就可以访问这个虚表指针数组，这个虚表指针数组里存的都是虚表地址。

由于前面提到了虚表指针数组的最后一个元素是nullptr，所以可以通过这个条件来遍历整个指针数组，打印这个虚表里存的地址，打印地址的占位符是%p，64位。还需要把这个VFPTR强制转换为void*，才可以进行打印。

3.取出虚表指针数组中存储的虚函数指针，用这个指针来调用相应的函数，在函数内部进行区别。就能看到地址对应的函数和虚表中存储的全部虚函数地址了！

namespace ting
{
	class A
	{
	public:
		virtual void Func1() { cout << "A:Func1()" << endl; };
		virtual void Func2() { cout << "A:Func2()" << endl; };
		virtual void Func3() { cout << "A:Func3()" << endl; };
		virtual void Func4() { cout << "A:Func4()" << endl; };
	};

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

	typedef void(*VFPTR) ();//把这个函数指针，重命名为VFPTR
	void PrintVFTable(VFPTR vtable[])
	{
		cout << " 虚表地址：" << vtable << endl;
		for (int i = 0;vtable[i] != nullptr; ++i)
		{
			printf("0x%p->", (void*)vtable[i]);//这里是打印地址，用printf
			VFPTR f = vtable[i];//取上面那个函数地址
			f();//用指针调用函数，函数名就是函数地址
		}
	}
	void test2()
	{
		A a1;
		B b1;

		//取虚表地址并强制转换称VFPTR类型
		VFPTR* vtable_a1 = *(VFPTR**)(&a1);
		PrintVFTable(vtable_a1);

		VFPTR* vtable_b1 = *(VFPTR**)(&b1);
		PrintVFTable(vtable_b1);

	}
}