C++的重载与虚函数

最新推荐文章于 2023-09-23 21:34:36 发布

风信子IT人

最新推荐文章于 2023-09-23 21:34:36 发布

阅读量1.4k

点赞数 1

分类专栏： C/C++ 文章标签： c++ 编译器 float class delete 汇编

本文链接：https://blog.csdn.net/ariel7321/article/details/4083344

版权

C/C++ 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

C++的重载与虚函数
其实真正要说的是虚函数，不过其中要扯倒重载，所以顺便也说了下重载

1. 重载
1.1 简单重载
      在C++中，是允许同名函数的存在
int add(int i,int j);
float add(float i,float);      而在c中，函数名是唯一的，所以为了区分int和float版本的add，你需要给它们起不同的名字，比如将int的命名为add_int,将float的命名为add_float，这样做的坏处就是程序员要记住很多的函数名，虽然这些函数的功能是一样的，而且也不直观。
      重载函数的存在，使得这种情况不在存在，它可以根据参数的类型，自动调用合适的重载函数，程序员只要记住要使用加法是调用add函数就可以，不同再像C中那样猜测int版的add函数函数名是怎样的，float版的函数名又是怎样的。实际上，这两个版本的add函数名在编译后是不一样的，编译器自动为它们进行了修饰，比如int的修饰成add_int_int,float的修饰成add_float_float，不过这都只是编译生成后的结果，对程序员来说，他只需知道add这个函数，但他要调用的时候，比如使用了int参数，编译器根据参数推出该调用的版本，这里就是add_int，所有这一切程序员都是看不见的，也不需要关心，从而减轻了程序员的工作。
      从上面的说法也可以看出，函数重载也不是能乱重载的，重载的要求是：
      1. 函数的参数类型不一样，像上面的int和float的
      2. 函数的参数个数不一样
      这是因为编译器在修饰生成的函数名时，一般用所有的参数类型来进行修饰，比如void add(int,float) 修饰成add_int_float,void add(int,int,int) 修饰成add_int_int_int，这样符合上面2条要求的重载函数最后生成的函数名是不一样的。
      可能有人会认为，为什么不用返回值来区分，如果编译器能推测出函数调用该返回什么值那自然没什么问题，但很多时候，往往只是调用函数，使用函数的副作用，而不要求返回值，这个时候编译器就推测不出了，比如
void f();
int f();

int main()
{
f();
}
这个时候编译器怎么知道调用哪个函数
1.2 类中的重载函数
不仅仅是全局函数可以重载，类中的函数也可以重载
class Base
{
public:
   int f() const{
      cout<<"Base:f()"<<endl;
      return 1;
   }

   int f(string) const{
      return 1;
   }
};

这看起来跟全局的没什么区别，但是当涉及到继承的时候，事情就变得麻烦起来
class Derived1: public Base
{
public:
//Redefinition
int f() const{
cout<<"Derived1:f()"<<endl;
return 1;
}
};

class Derived2: public Base
{
public:
//change Return type
void f()const
{
cout<<"Derived2:f()"<<endl;
}
}

class Derived3: public Base
{
public:
//change argument list
int f(int) const
{
    cout<<"Dervide3:f()"<<endl;
    return 1;
   }
}
子类中定义了跟父类同名的函数，这个时候该如何办？其实说起来也很简单，只要子类定义了跟父类同名的函数，不管是重写了函数内容（Dervied1),改变了返回类型（Derived2），还是改变了参数列表（Derived3），结果都一样，子类中的同名函数将父类中的同名函数给隐藏了，只要子类中的函数是可见的，通过子类的对象调用父类的同名函数是不合法的，只能调用子类自身的同名函数。这就是所谓的名字隐藏。

2. 重写与虚函数
2.1 基本知识
虚函数在多态中经常用到。你只要有一个基类的指针或引用，编译器会为你调用该指针真正对应的函数
class Base
{
public；
virtual void f()
{
cout<<"Base:f()"<<endl;
}
};

class Derived:public Base
{
public:
   //You can also ingore virtual here
   virtual void f()
   {
     cout<<"Derived:f()"<<endl;
   }
};

int main()
{
Base* p=new Derived();
p->f();
delete p;
}

程序输出Derived::f(),这就是虚函数的作用。你可以不用关心基类指针到底指向那个子类，编译器会为你调用正确的函数。
这是因为编译器使用了晚捆绑的缘故。
当一个类中有一个虚函数时（可以是因为在类中声明了一个虚函数，也可以是因为基类中有虚函数，通过继承得到）。编译器就为这个类创造一个虚表（VTABLE),它当中的虚函数位置是固定的，即使被继承到子类中也一样。当定义了一个这个类的对象时，编译器会在这个对象中放入一个虚指针（VPTR）指向这个表。当调用虚函数时，编译器在汇编代码中插入
一段代码，这个代码首先找到虚表，然后在通过偏移调用正确的函数。
当一个带有虚函数的基类被继承时，这个VTABLE会被完整赋值，当然对应的函数地址会改成子类中的函数地址。如果子类另外声明了虚函数，就会在原来的虚函数后面添加上新的条目。
重写其实就是在子类中对父类的虚函数进行重定义，因为一般子类有自己的特性。
2.2 虚函数与重载
如果子类中只是改写了父类中虚函数的内容，这就只是重写（overriding），函数前面的virtual可以忽略掉
但如果子类中改变了父类中虚函数的参数类型或个数，那么父类中的同名函数就会被隐藏掉，这同普通的重载一样，有一点不一样的是，不可以通过改变返回类型来隐藏父类中的同名函数。
2.3 切片
当用子类对象来初始化父类时（如函数中的call by value），新生成的父类对象会正确初始化它自身的vtable，而不会使用子类的vtable。

注：
虽然通过基类指针调用虚函数，最后调用的是子类的函数，但是如果使用的确实基类的默认参数
class Base
{
public:
virtual void f(int i=0)
{
cout<<i<<endl;
}
};

class Derived: public Base
{
public:
virtual void f(int i=1)
{
cout<<i<<endl;
}
};

int main()
{
Base* p=new Derived();
p->f(); //输出的是0
}

注2：
发生在private继承时的问题,父类中的虚函数是private的，当它被private继承时，子类是无法访问到这个函数的，不过子类仍然可以override这个函数
class Base
{
public:
void nvi()
{
     vfun();
}
private:
virtual void vfun()
{
    cout<<"Base::vfun()"<<endl;
   }
};