c 中virtual关键字的用法-ag真人游戏

关于virtual关键字的用法总结如下，有错误或者总结不到位的情况请能帮本人指出，非常感谢！

virtual是c oo机制中很重要的一个关键字。只要是学过c 的人都知道在类base中加了virtual关键字的函数就是虚拟函数。

基类的函数调用如果有virtual则根据多态性调用派生类的，如果没有virtual则是正常的静态函数调用，还是调用基类的。

1、虚函数的应用

看下面的一段代码的输出结果：

class base
{
public:base(){}
public:
       virtual void print(){cout<<"base";}
};
 
class derived:public base
{
public:derived(){}
public:
       void print(){cout<<"derived";}
};
 
int main()
{
       base *point=new derived();
       point->print();
}

output：
derived 
这也许会使人联想到函数的重载，但稍加对比就会发现两者是完全不同的：
（1）重载的几个函数必须在同一个类中；
覆盖的函数必须在有继承关系的不同的类中
（2）覆盖的几个函数必须函数名、参数、返回值都相同；
重载的函数必须函数名相同，参数不同。参数不同的目的就是为了在函数调用的时候编译器能够通过参数来判断程序是在调用的哪个函数。这也就很自然地解释了为什么函数不能通过返回值不同来重载，因为程序在调用函数时很有可能不关心返回值，编译器就无法从代码中看出程序在调用的是哪个函数了。
（3）覆盖的函数前必须加关键字virtual；
重载和virtual没有任何瓜葛，加不加都不影响重载的运作。

再看下面林瑞博士讲解的一段关于关键字virtual的用法

#include
class base
{
public:
virtual void f(float x){ cout << "base::f(float) " << x << endl; }
void g(float x){ cout << "base::g(float) " << x << endl; }
void h(float x){ cout << "base::h(float) " << x << endl; }
};
 
class derived : public base
{
public:
virtual void f(float x){ cout << "derived::f(float) " << x << endl; }
void g(int x){ cout << "derived::g(int) " << x << endl; }
void h(float x){ cout << "derived::h(float) " << x << endl; }
};
 
void main(void)
{
derived d;
base *pb = &d;
derived *pd = &d;
// good : behavior depends solely on type of the object
pb->f(3.14f); // derived::f(float) 3.14
pd->f(3.14f); // derived::f(float) 3.14
// bad : behavior depends on type of the pointer
pb->g(3.14f); // base::g(float) 3.14
pd->g(3.14f); // derived::g(int) 3 (surprise!)
// bad : behavior depends on type of the pointer
pb->h(3.14f); // base::h(float) 3.14 (surprise!)
pd->h(3.14f); // derived::h(float) 3.14
}
 
bp 和dp 指向同一地址，按理说运行结果应该是相同的，而事实上运行结果不同，所以他把原因归结为c 的隐藏规则，其实这一观点是错的。决定bp和dp调用函数运行结果的不是他们指向的地址，而是他们的指针类型。“只有在通过基类指针或引用间接指向派生类子类型时多态性才会起作用”(c primer 3rd edition)。pb是基类指针，pd是派生类指针，pd的所有函数调用都只是调用自己的函数，和多态性无关，所以pd的所有函数调用的结果都输出derived::是完全正常的；pb的函数调用如果有virtual则根据多态性调用派生类的，如果没有virtual则是正常的静态函数调用，还是调用基类的，所以有virtual的f函数调用输出derived::，其它两个没有virtual则还是输出base::很正常啊，nothing surprise! 
所以并没有所谓的隐藏规则，虽然《高质量c /c 编程指南》是本很不错的书，可大家不要迷信哦。记住“只有在通过基类指针或引用间接指向派生类子类型时多态性才会起作用”。

2、纯虚函数
纯虚函数定义如下：

c 语言为我们提供了一种语法结构，通过它可以指明，一个虚拟函数只是提供了一个可被子类型改写的接口。但是，它本身并不能通过虚拟机制被调用。这就是纯虚拟函数（purevirtual function）。 纯虚拟函数的声明如下所示：
class query {
public:
// 声明纯虚拟函数
virtual ostream& print( ostream&=cout ) const = 0;
// ...
};
这里函数声明后面紧跟赋值0。

包含一个或多个纯虚拟函数的类被编译器识别为抽象基类。抽象基类不能被实例化，一般用于继承。抽象基类只能作为子对象出现在后续的派生类中

3、 虚拟继承（virtual public）

在多继承下，虚继承就是为了解决菱形继承中，b,c都继承了a，d继承了b,c，那么d关于 a的引用只有一次，而不是 普通继承的 对于a引用了两次……

格式：可以采用public、protected、private三种不同的继承关键字进行修饰，只要确保包含virtual就可以了。

class a
{
  void f1(){};
};
class b : public virtual  a{
  
 void f2(){};
};

虚继承：在继承定义中包含了virtual关键字的继承关系；

虚基类：在虚继承体系中的通过virtual继承而来的基类，

#include 
using namespace std;
class person{
   public:    person(){ cout<<"person构造"<            ~person(){ cout<<"person析构"< };
class teacher : virtual public person{
   public:    teacher(){ cout<<"teacher构造"<             ~teacher(){ out<<"teacher析构"< };
class student : virtual public person{
  public:      student(){ cout<<"student构造"<              ~student(){ cout<<"student析构"< };
class ts : public teacher,  public student{
public:            ts(){ cout<<"ts构造"<                  ~ts(){ cout<<"ts析构"< };
int main(int argc,char* argv[])
{
ts ts;
return 0;
}

这段代码的终端输出结果为：
person构造
teacher构造
student构造
ts构造
ts析构
student析构
teacher析构
person析构
当teacher类和student类没有虚继承person类的时候，也就是把virtual去掉时候终端输出的结果为：
person构造
teacher构造
person构造
student构造
ts构造
ts析构
student析构
person析构
teacher析构
person析构

     大家可以很清楚的看到这个结果明显不是我们所期望的。我们在构造ts的时候需要先构造他的基类，也就是teacher类和student类。而teacher类和student类由都继承于person类。这样就导致了构造ts的时候实例化了两个person类。同样的道理，析构的时候也是析构了两次person类，这是非常危险的，也就引发出了virtual的第三种用法，虚析构。

关于虚继承的相关功能，本人也是一知半解，后续再做深入的研究