C++ virtual虚函数

C++, virtual function, dynamic resolution/binding
C++, 虚函数, 动态绑定

Semantics of Virtual function 虚函数的基本语法

虚函数是实现多态性polymorphism的基础。有了虚函数，程序可以实现动态绑定。样例如下：

class A {
public:
    virtual void vf() {
        cout << "A vf()" << endl;
    }
};

class B : public A{
public:
    void vf() {
        cout << "B vf()" << endl;
    }
};

int main()
{
    A *a = new A();
    a->vf();  // output: A vf()
    A *b = new B();
    b->vf();  // output: B vf()
    return 0;
}

1. 虚函数的virtual对所有派生类中的相同函数签名的函数都有作用。（函数签名包括函数名和参数列表）

class A {
public:
    virtual void vf() {  // A::vf is a virtual function
        cout << "A vf()" << endl;
    }
}
class B : public A {
public:
    void vf() {  // B::vf is still a virtual function
        cout << "B vf()" << endl;
    }
}
class C : public B {
public:
    void vf() {  // C::vf is still a virtual function
        cout << "C vf()" << endl;
    }
}

2. 多级继承时，最初的虚函数可以是任意一级的类的函数。将上面的代码样例修改如下：

class A {
public:
    void vf() {  // A::vf is not a virtual function
        cout << "A vf()" << endl;
    }
}
class B : public A {
public:
    virtual void vf() {  // B::vf is a virtual function
        cout << "B vf()" << endl;
    }
}
class C : public B {
public:
    void vf() {  // C::vf is still a virtual function
        cout << "C vf()" << endl;
    }
}

在这种情况下，父类A的指针不管指向哪个类的对象，当调用vf()函数时，因为父类的vf()不是虚函数，则不会发生动态绑定，而是发生静态绑定，调用父类的vf()。子类B的指针指向B类或者继承自B的子类的对象时，当调用vf()函数时，因为B类的vf()是虚函数，所以发生了动态绑定，调用该对象的vf()函数。

3. virtual不可用在函数定义外，如下所示

class A {
public:
    virtual int vf();
};

virtual int A::vf() {  // error: 'virtual' outside class declaration
    return 0;
}

virtual函数，即虚函数的声明方式应是在类定义内使用virtual，如下

class A {
public:
    virtual int vf();
};

int A::vf() {  // vf is a virtual function
    return 0;
}

3. 纯虚函数
含有纯虚函数的类叫抽象类，抽象类不能定义对象。纯虚函数的定义如下：

virtual void pvf() = 0;

抽象类的子类如果没有实现纯虚函数，则子类也是抽象类。
4. 虚函数可以重复声明，但没有意义
不管是纯虚函数，虚函数，或者函数定义，都可以重复。只要纯虚函数和虚函数在定义前出现即可。
5. 虚函数不能是template模版函数
// todo
6. 虚函数不能是静态函数。static静态函数，顾名思义
// todo
7. 虚函数的访问权限由指针的类型决定
无论子类的虚函数的访问修饰符是什么，该虚函数是否能被访问由指向该虚函数所在对象的指针决定。代码如下：

class A
{
public:
	virtual void vf()
    {
        cout << "A vf()" << endl;
    }
}
class B : public A
{
private:
	virtual void vf()
    {
        cout << "B vf()" << endl;
    }
}
class C : public B
{
public:
	virtual void vf()
    {
        cout << "B vf()" << endl;
    }
}
int main()
{
    A *pa = new B();
    pa->vf();  // output : B vf()
    B *pb = new B();
    pb->vf();  // error
    pb = new C();
    pb->vf();  // error
    pa = new C();
    pa->vf();  // output : C vf()
    return 0;
}

虚函数只对指针有效。如果变量是对象object，那么会静态调用该对象的相应函数。
父类指针可以直接指向子类对象，但子类指针不能直接指向父类对象，需要进行强制转换。可以用C风格和C++风格，如下

A *a = new B();  // 父指针指向子类对象
B *b = new A():  // error: invalid conversion from 'A*' to 'B*'
b = (B*)(new A());  // C style
b = static_cast<B*>(new A());  // C++ style

子类指针指向父类对象的情况

不管是什么指针，调用的虚函数版本只跟指针指向的对象有关。切记，小心子类指针指向父类对象的情况。父类对象可以强转并赋值给子类指针。

• 如果调用子类的变量，则是未定义的（由编译器决定）。
• 如果调用子类实现的虚函数，则会调用子类的实现，但由于子类实现的函数可能会调用子类的变量，因此该虚函数的子类实现仍是未定义的（由编译器决定）。
• 调用子类的普通函数同上。
• 如果调用子类未实现的虚函数，则会调用父类的虚函数。
  总之，用子类指针指向父类对象，可以安全的调用父类的变量和函数。但调用子类的变量和函数会导致未定义。而且最危险的是，当delete子类指针时，会导致Invalid free() / delete / delete[] / realloc() （来自Valgrind）。虽然编译器一般不会报error/warning。但强烈禁止这么做。

函数默认参数