👍作者主页:进击的1++
🤩 专栏链接:【1++的C++进阶】
一,什么是多态?
多态的定义:不同继承关系的类对象,去调用同一个函数,产生不同的行为。再说通俗点就是:一个行为,不同的对象去做会产生不同的结果。
构成多态的条件:
- 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写
重写的条件:
- 是虚函数 (被virtual修饰的成员函数)
- 三同(函数名,参数,返回值)
特例:
- 子类虚函数不加virtual依旧构成重写。
- 重写的协变:返回值可以不同,但必须是父子关系的指针或引用
- 如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,
都与基类的析构函数构成重写。虽然函数名不相同,看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor
而且不符合重写就是隐藏关系,这也是我们判断隐藏关系的条件之一。
2. 必须是基类的指针或引用去调用虚函数。
实例如下:
class A
{
public:
virtual void Func1()
{
cout << "A::Func1()" << endl;
}
protected:
int _a;
};
class B:public A
{
public:
virtual void Func1()
{
cout << "B::Func1()" << endl;
}
protected:
int _b;
};
void Test1()
{
B t1;
A& a1 = t1;
a1.Func1();
A* ptra = &t1;
ptra->Func1();
}
上面还遗留一个问题,为什么要把析构函数重写。
来看以下代码:
class A
{
public:
virtual ~A()
{
cout << "~A()" << endl;
}
A& operator=(const A& a)
{
cout << "A::operator=()" << endl;
return *this;
}
virtual void Func1()
{
cout << "A::Func1()" << endl;
}
protected:
int _a;
};
class B:public A
{
public:
virtual ~B()
{
cout << "~B()" << endl;
}
/*B& operator=(const B& a)
{
A::operator=(*this);
cout << "B::operator=()" << endl;
return *this;
}*/
virtual void Func1()
{
cout << "B::Func1()" << endl;
}
protected:
int _b;
};
void Test1()
{
A* ptra1 = new A;
A* ptra2 = new B;
delete ptra1;
delete ptra2;
}
若析构函数没有重写:
我们可以看到new的B类类型的对象没有调用自己的析构而是其指针类的析构函数。这就会存在空间没有释放的问题,造成内存泄漏。
若构成重写后:
我们可以看到new出的B对象调用了自己的析构函数。并且上一篇文章我们讲过,子类对象的析构会先调用自己的构造函数,然后调用父类的构造函数。
这里我们做一个小的总结:通过上述的两段代码,我们会发现,多态调用重写函数,指向哪个对象就去调用哪个对象的重写函数。
二,剖析多态的调用原理
首先我们先来回答这么一个问题:
class A
{
public:
virtual void Func1()
{
cout << "A::Func1()" << endl;
}
virtual int Func2()
{
cout << "A::Func2()" << endl;
return 0;
}
protected:
int _a;
};
class B:public A
{
public:
virtual void Func1()
{
cout << "B::Func1()" << endl;
}
protected:
int _b;
};
void Test2()
{
A t2;
B t1;
cout << sizeof(t1) << endl;
}
上述代码中的sizeof的值为多少呢?
答案为12!!可能会有人疑惑,为什么不是8呢?
我们通过监视窗口来观察。
我们发现,除了子类的成员变量和继承的A的成员变量外还多了一个_vfptr。这是虚函数表指针。
那么这个表中放的是什么呢?
我们继续来看下面这段代码:
class A
{
public:
virtual void Func1()
{
cout << "A::Func1()" << endl;
}
virtual int Func2()
{
cout << "A::Func2()" << endl;
return 0;
}
virtual int Func4()
{
cout << "A::Func4()" << endl;
return 0;
}
protected:
int _a;
};
class B:public A
{
public:
virtual void Func1()
{
cout << "B::Func1()" << endl;
}
virtual int Func3()
{
cout << "B::Func3()" << endl;
return 0;
}
virtual int Func4()
{
cout << "B::Func4()" << endl;
return 0;
}
protected:
int _b;
};
typedef void(*Vfptr)();
void PrintVFptr(Vfptr* arr)
{
for (int i = 0; arr[i] != nullptr; ++i)
{
printf("vfptr[%d]->%p ", i, arr[i]);
Vfptr pf = arr[i];
pf();
}
}
void Test2()
{
A t2;
B t1;
printf("B::vfptr\n");
PrintVFptr((Vfptr*)*(int*)(&t1));
printf("A::vfptr\n");
PrintVFptr((Vfptr*)*(int*)(&t2));
}
再解读前,我们先来说明一个东西,只要是该类的虚函数,就会被存入该类的虚函数表中,并且对于单继承来说,每个类只有一份虚函数表,子类继承了父类的虚函数表,并且将重写的虚函数覆盖为自己的。也就是说子类的虚函数表是:继承父类的并进行重写覆盖后+自己的虚函数。
我们回来来解读上结果:Func1,Func4都进行了重写,所以我们发现其A与B打印出的函数地址不同。而Func2是通过继承下来的虚函数,但并没有进行重写,会存在虚表中,因此其在A和B的虚表中的函数指针相同。Func3则是子类中独有的虚函数,因此只在子类的需表中有。
所以多态的原理是:在编译阶段会形成虚函数表,在调用构造函数的初始化列表阶段会对虚函数表进行初始化。当程序运行后,在指向对象的虚函数表中去找对应的虚函数,这也是为什么我们前面说指向谁就调用谁,而对于普通函数来说,其在编译阶段就已经确定了调用谁。
动态绑定与静态绑定
-
静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为,也称为静态多态,比如:函数重载。
-
动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用具体的函数,也称为动态多态。
三,抽象类
什么叫抽象类?
在虚函数的后面写上 =0 ,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象。纯虚函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承。
那么什么是接口继承呢?
普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态。
因此如果不实现多态,不要把函数定义成虚函数。
我们来看一道例题:
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;
}
问这道题的输出是什么?
答案是:B->1
这是为什么呢?
首先我们的我们用一个指向B对象的指针p去调用test函数,而test函数是父类中的虚函数,没有重写,会继承到子类B中,这时我们会忽略一个问题—this指针,test中的this指针是A类类型的指针,这符合构成多态的一个条件:父类指针或引用去调用虚函数。 我们将B*指针传过去后会发生切片,在test中调用func(),由于虚函数的继承是几口继承,因此其会继承父类的接口,用子类的实现。感觉像头和身子拼接起来的一样。因此,在这道题中会用到父类中func函数的缺省参数,而实现部分则用的是子类中的func。所以答案为:B->1。
四,多继承中的虚函数表
以以下代码为例:
class Base1
{
public:
virtual void func1()
{
cout << "Base1::func1" << endl;
}
protected:
int _a;
};
class Base2
{
public:
virtual void func1()
{
cout << "Base2::func1" << endl;
}
virtual void func2()
{
cout << "Base2::func2" << endl;
}
protected:
int _b;
};
class Boss:public Base1,public Base2
{
public:
virtual void func1()
{
cout << "Boos::func1" << endl;
}
virtual void func2()
{
cout << "Boos::func2" << endl;
}
virtual void func3()
{
cout << "Boos::func3" << endl;
}
protected:
int _c;
};
typedef void(*Vfptr)();
void PrintVFptr(Vfptr* arr)
{
for (int i = 0; arr[i] != nullptr; ++i)
{
printf("vfptr[%d]->%p ", i, arr[i]);
Vfptr pf = arr[i];
pf();
}
}
int main()
{
Base1 b1;
Base2 b2;
Boss d;
cout << "Base1" << endl;
PrintVFptr((Vfptr*)*(int*)(&b1));
cout << "Base2" << endl;
PrintVFptr((Vfptr*)*(int*)(&b2));
cout << "Boos--1" << endl;
PrintVFptr((Vfptr*)*(int*)(&d));
cout << "Boos--2" << endl;
PrintVFptr((Vfptr*)(*(int*)((char*)&d + sizeof(Base1))));
}
通过上述窗口和打印出的结果看,我们发现多继承其有n个虚函数表,n与继承的父类个数有关。并且,子类自身的虚函数放在第一个虚表中,如上述func3()。
还有一个有趣的现象:
Base1 b1;
Base2 b2;
Boss d;
Base1* ptr1 = &d;
Base2* ptr2 = &d;
ptr1->func1();
ptr2->func1();
若我们用子类的地址赋值给不同的父类指针去调用func1()按理来说,其两个指针都指向同一个子类对象,并且func1()都进行了重写,因此ptr1,ptr2 , Boos虚表中的func1()的地址应该是一样的,但是结果却不一样,这是为什么呢?
下面是d对象的模型:
因此当ptr2去调用func1()时,其传过去的this指针,并不是d的起始地址,因此为了使其this指针变为d的this 指针,这里编译器会进行一个操作,计算出Base1的大小,将ptr2减去Base1的大小,这时this指针就指向了d的起始位置,自然调用的就是d对象中的func1()。
补充两个关键字:
- final:修饰虚函数,表示该虚函数不能再被重写。
- override: 检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错。