面向对象的一些常见问题总结。

1,构造函数中调用虚函数的问题。
注：一般编译器都会在执行完base subject的构造函数和调用用户代码之前，实施当前对象vptr的初始化工作。

因此，如果当前对象内定义了某函数，构造函数中调用的一定是当前对象内的，virtual可以认为不存在。

实例代码：

#include <iostream>
using namespace std;

class Base
{
public:
    Base()
    {
        f();
    }
    virtual void f()
    {
        cout << "Base" << endl;
    }
};

class Derive : public Base
{
public:
    Derive()
    {
        f();
    }
    virtual void f()
    {
        cout << "Derive" << endl;
    }
};


int main()
{
    Derive d;
    return 0;
}

输出:
Base
Derive
这种布局不好,构造函数中调用virtual函数,可以等价认为virtual根本不存在.


2,

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void f()
    {
        cout << "Base" << endl;
    }
};

class Derive : public Base
{
public:
    virtual void f()
    {
        cout << "Derive" << endl;
    }
};


int main()
{
    Derive* d = new Derive;
    d -> f();

    Base* b = d;
    b -> f(); //正常的多态性

    Base* b2 = (Base*)d;
    b2 -> f(); //输出Derive
    //原因：这里只是指针赋值，b2所指对象的vptr没有改变，所以调用Derive函数。

    Base b3 = (Base)(*d);
    b3.f(); //输出Base
    //原因:d的基类部分,b3执行copy constructor, b3.f(),静态绑定.
}

3,

#include <iostream>
#include <cstdio>
using namespace std;

class A
{
public:
    A()
    {
        func(0); //非常不好的布局,构造函数调用虚函数,可认为virtual不存在.
    };
    virtual void func(int data)
    {
        printf("A1 :%d\n",data);
    }
    virtual void func(int data) const
    {
        printf("A2 :%d\n",data);
    }
    void func(char *str)
    {
        printf("A3 %s)\n",str);
    }
};

class B : public A
{
public:
    void func()
    {
        printf("B1 :%s\n","");
    }
    void func(int data)
    {
        printf("B2 :%d\n",data);
    }
    void func(char *str)
    {
        printf("B3 %s)\n",str);
    }
};

int main()
{
    A *pA;
    B b;
    //输出 A1 :0  调用了A的构造函数


    pA=&b;
    pA->func(1);
    //子类指针赋值给基类指针,调用virtual函数, 多态性执行子类 输出 B2 :1
    pA->func("test");
    //func(char *str) 非virtual函数,静态绑定,执行基类 输出 A3 test)
    A().func(1);
    //基类先执行构造函数 输出 A1 :0  后调用成员函数 输出 A1 :1

    const A *pcA;	
    pcA=&b;
    pcA->func(2);
    //多态性,但是子类没有重载virtual void func(int data) const,默认采用基类的实现, 输出 A2 :2

    return 0;
}