c++之重要的关键字（三）---------virtual

 对于这个关键字，大家肯定都有疑惑过。因为它涉及到类的派生和多态。而virtual修饰的函数叫虚函数。

虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。

如：

      class A                    { public:      void f(){ ..} };

      class B:pbulic  A    { public:     void f(){...} };

      A*p=new B();

      p->f();

大家可以看到，p虽然在此时是B的实例，但是p调用的其实是A::f();

现在稍微改造以下A类:   class A { public:     virtual  void f(){ ..} };

此时A类中f()函数为虚函数,那么p->f();调用的就是B::f();

虚函数只能借助于指针或者引用来达到多态的效果:     A  p;    p.f();   此时p调用的是A::f()。

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。

如：

void bar(A * a)
{
a->foo(); // 被调用的是A::foo() 还是B::foo()？
}
只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a指向的是A类的实例，则A::foo()被调用，如果a指向的是B类的实例，则B::foo()被调用。
多态的作用：
1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，以前需要用switch实现

overload和override

overload被翻译为“重载”。是指编写一个与已有函数同名但是参数表不同的函数，重载不属于多态。
override是指派生类重写基类的虚函数，重写的函数必须有一致的参数表和返回值（C++标准允许返回值不同的情况）。

纯虚函数

class A
{
public:
virtual void foo()=0; // =0标志一个虚函数为纯虚函数
};
纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。

 

析构函数也可以是虚的，甚至是纯虚的

当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。考虑下面的例子：
class A
{
public:
A() { ptra_ = new char[10];}
~A() { delete[] ptra_;} // 非虚析构函数
private:
char * ptra_;
};
class B: public A
{
public:
B() { ptrb_ = new char[20];}
~B() { delete[] ptrb_;}
private:
char * ptrb_;
};
void foo()
{
A * a = new B;
delete a;
}
在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！而B类中有new产生的内存资源未释放，会造成内存泄漏。

实际上，如果B类中没有申请内存资源，delete a 是没有多大问题的，但是我们要养成习惯：基类的析构函数要定义成虚函数。

还有要记住，构造函数不能为虚，因为构造函数必须知道实例的具体的内容和信息。就如本来要构造一个“女生”，你只说“人”，这样当然就无法构造了。

private的虚函数

考虑下面的例子：
class A
{
public:
void foo() { bar();}
private:
virtual void bar() { ...}
};
class B: public A
{
private:
virtual void bar() { ...}
};
在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。
这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。

构造函数和析构函数中的虚函数调用

一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”。例如：
class A
{
public:
A() { foo();} // 在这里，无论如何都是A::foo()被调用！
~A() { foo();} // 同上
virtual void foo();

};
什么时候使用虚函数

在你设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。

“如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的”。

  这句话也可以反过来说：“如果你发现基类提供了虚函数，那么你最好override它”。

  还有就是基类的析构函数要为虚

 

虚基类和抽象类

抽象类是指带有有一个或一个以上的纯虚函数的类。抽象类一般只用于继承，不能定义类对象。

在实现抽象类时，必须实现该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值。

虚基类是相对于它的派生类而言的，它本身可以是一个普通的类。

虚基类：是为了避免多重继承中产生的二义性问题。比如当在多条继承路径上有一个共同的基类，当在多条路径的交汇处可能产生基类的多个实例（副本），为避免这个问题可以使用虚基类，虚基类并不在声明时指出，而是在子类继承时指明是虚继承。
class a{}
class b{}:virtual a