c++ 多态性和虚函数

小鹿的洋花园

已于 2023-03-27 08:26:39 修改

阅读量372

点赞数

分类专栏： c++ 八股文文章标签： c++ 开发语言

于 2023-03-19 16:50:47 首次发布

本文链接：https://blog.csdn.net/syy_lr/article/details/129642131

版权

c++ 八股文专栏收录该内容

7 篇文章 0 订阅

订阅专栏

多态性提供了接口与具体实现之间的另一层隔离。

封装通过组合特性和行为生成新的数据类型，访问控制通过private,将接口从具体实现中脱离出来。

1. 函数调用的捆绑：

把函数体与函数调用相联系称为捆绑。当捆绑在程序运行之前时，被称为早捆绑。

晚捆绑，根据对象的类型，发生在运行时，又被称为晚捆绑。

2. 虚函数

为了实现晚捆绑，c++ 定义了虚函数，基类声明函数时使用virtual这个关键字，所有派生类，也必须是virtual。

在派生类中，virtual 函数的重定义通常被认为是重写。

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print()
   {
     cout<<"Base print"<<endl;
   }
};
class Derive:public Base
{
public:
   void print()
   {
    cout<<"Derive print"<<endl;
   }
};

void print(Base & b)
{
    b.print();
}
int main()
{
    Derive d;
    print(d);
    Base b;
    print(b);
}

Derive print
Base print

虚函数：

基类指针指向派生类对象。调用派生函数。

基类指针指向基类对象，调用基类函数。

3. c++ 如何实现晚捆绑的？虚函数表

编译器会对每个包含虚函数的类创建一个表，编译器放置特定类的虚函数指针，指向这个虚函数表。当通过基类指针做虚函数的时候调用。

编译器静态的插入这个虚函数表，并且虚汗数表中查找函数真正的地址，就能调用正确的函数。

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print(){}
   void print2(){}
};
class Base2
{
public:
   void print(){}
   void print2(){}
};
class Base3
{
public:
   virtual void print(){}
   virtual void print3(){}
};
int main()
{
   cout<<sizeof(Base)<<endl;
   cout<<sizeof(Base2)<<endl;
   cout<<sizeof(Base3)<<endl;
   cout<<sizeof(void *)<<endl;
}

8
1
8
8

每当创建一个包含虚函数的类，或者从包含虚函数的类派生出来的类时，编译器就为这个类创建唯一的VTABLE，编译器放在这个类中，或者类声明为virtual的地址。

如果这个派生类，没有对这个虚函数进行从新定义，编译器就会使用这个基类的虚函数地址。

4. 为什么需要虚函数？

虚函数可以实现多态，晚捆绑，代码的扩展性和复用性，进一步提高。

虚函数不是相当的高效，因为它不是对于绝对地址的一个简单的call,而是需要更为复杂的汇编指令，即需要代码空间，又需要执行时间。

5. 抽象基类和纯虚函数

基类仅仅作为派生类的一个接口，仅对基类进行向上类型转换，并且不希望用户实际的创建一个基类对象。

纯虚函数使用关键字virtual,并且在后面加上= 0。

virtual void f() =0; //纯虚数声明的语法

纯虚函数等于，在函数中保留一个位置，在这个位置不放地址。

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print()const =0;
};
int main()
{
  //Base b; 会报编译错误
}

//包含纯虚函数的类，被称为抽象类。

纯虚函数，可以防止，产生完整的VTABLE。

对纯虚函数定义，是存在可能的，我们告诉编译器，不允许产生抽象基类的对象，如果要创建对象，则纯虚函数必须在派生类中定义。

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print()const =0;
};
void Base::print() const
{
    cout<<"Base"<<endl;
}

class Derive:public Base
{
 public:

    void print() const
    {
        Base::print();
    }
};
int main()
{
  //Base b; 会报编译错误
  Derive D;
}

（为什么会对纯虚函数定义）：它允许我们从常规虚函数到纯虚函数的改变，无需打乱已经存在的代码。另外可以将派生类共同使用的代码写出来。

6. 继承和VTABLE

当实现继承和虚函数时，编译器会为新的类，创建一个新的虚函数表，并且插入新函数的地址，对于没有重新定义的虚函数，使用基类函数的地址。

在派生类中增加新的虚函数会导致什么？

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print(){
    cout<<"Base print"<<endl;
   };
};
class Derive:public Base
{
 public:
    void print() 
    {
        cout<<"Derive print"<<endl;
    }
    virtual externd(){};
};
int main()
{
  //Base b; 会报编译错误
  Base* a =new Derive;
  //  Base              Derive
  // &Base::print       &Derive::print
  //                    &Derive::externd()
}

调用虚函数列表，会通过偏移来实现的。基类指针的虚函数在VTLAB中的位置和派生类的位置一致，指向基类的指针，不会指向派生类新增的虚函数。

对象切片：

多态的目的之一，是让基类对象的操作代码透明的操作派生类的代码。上面，我们对于基类和派生类使用的都是按地址和引用传递。

如果按值传递，会发生什么？

#include<iostream>
using namespace std;
class Base
{
public:
   virtual void print(){
    cout<<"Base print"<<endl;
   };
};
class Derive:public Base
{
 public:
    void print() 
    {
        cout<<"Derive print"<<endl;
    }
    virtual externd(){};
};

void print(Base b)
{
    b.print();
}
int main()
{
  Base b;
  Derive d;
  print(b);
  print(d);
}

Base print
Base print

print接受Base 对象，如果传递的是Derive对象，编译器只会copy Base大小的对象。

将派生类强制转换成了Base对象，当按值传递时，直接copy Base类的对象，并且编译器会自动生成一个。

重载和重新定义

从新定义了一个基类的重载函数将会隐藏所有该函数的其他基类的版本。

include<iostream>
using namespace std;
class Base
{
public:
   virtual void print(){
    cout<<"Base print"<<endl;
   };
   int print(string a){
     cout<<"string Base "<<a<<endl;
   }
};
class Derive:public Base
{
 public:
    void print() 
    {
        cout<<"Derive print"<<endl;
    }
};

int main()
{
  Derive d;
  d.print();
 // d.print("xiaomi"); 不可以使用
 Base &b = d;
 b.print("xiaomi");
}