虚拟继承函数的 C++ 内联

Question

好吧，这更多的是要求澄清 C++ 的一个特性是如何工作的，而不是一个是否可以的答案。我将从解释我遇到的问题开始，因为直接的答案是它不是一个很好的类设计。

我有一个类正在形成一个无法维护的 if 语句 block ；当我试图将它变成一个复合体时，我开始对让深层拷贝工作比对原始 blob 以及一般的小对象分配问题更加困惑。因此，我开始寻找一种方法将 blob 拆分为几个类，编译器可以将这些类转换回原始 blob。

在下面的代码中，我知道 foo_b 和 foo_c 中的 super::get_x() 是可内联的——来自其他堆栈溢出问题--但我不确定 foo_c 中的 super::get_z() 是否是。最后对 f.get_x()、f.get_y() 和 f.get_z() 的调用是否为虚函数调用是因为它不是显式的，并且它不知道 foo 是否有子类，或者它们是否是可内联的，因为它实际上没有？

namespace PRIVATE {

class foo_a 
{
    int x, y, z;
public:
    foo_a(int X, int Y, int Z)
    {
        x = X; y = Y; z = Z;
    }
    virtual ~foo_a() { }

    virtual void update() { };

    virtual int get_x() const { return x; } 
    virtual int get_y() const { return y; }
    virtual int get_z() const { return z; }
};

class foo_b : public virtual foo_a 
{
typedef foo_a super;
    unsigned char c_0,c_1,c_2, mod;

public:
    foo_b(int X, int Y, int Z) : foo_a(X, Y, Z)
    {
        c_0 = c_1 = c_2 = mod = 0;
    }
    virtual ~foo_b() { }

    void activate_b()
    {
        c_2 = c_1;
        c_1 = c_0;
        c_0 = 5;

        mod = c_0? 1 + (c_1? 1 + (c_2? 1 : 0) : 0) : 0;
    }

    virtual void update()
    {
        super::update();

        if(c_0) { --c_0; mod = 1;
        if(c_1) { --c_1; mod = 2;
        if(c_2) { --c_2; mod = 3; }}};
    }
    virtual int get_x() const { return super::get_x() + mod; };
    virtual int get_y() const { return super::get_y() - mod; };
};

class foo_c : public virtual foo_b 
{
typedef foo_b super;
    bool active;

public:
    foo_c(int X, int Y, int Z) : foo_b(X, Y, Z)
    {
        active = false;
    }
    virtual ~foo_c() { }

    bool activate_c(bool X) { return (active = X); }

    virtual int get_x() const 
    { 
        int t = super::get_x();
        return active? t % 8 : t;
    }
    virtual int get_z() const 
    { 
        int t = super::get_z();
        return active? t % 8 : t;
    }
};

}

class foo : public virtual PRIVATE::foo_c 
{
public:
    foo(int X, int Y, int Z) : PRIVATE::foo_c(X, Y, Z) { }
    virtual ~foo() { }
};


int main(int argc, const char * argv[])
{
    foo * f = new foo(4, 6, 8);
    f->activate_b();
    f->get_x();
    f->get_y();
    f->get_z();

    delete f;

    return 0;
}

Answer 1

查看 C++ FAQ :

Therefore the only time an inline virtual call can be inlined is when the compiler knows the "exact class" of the object which is the target of the virtual function call. This can happen only when the compiler has an actual object rather than a pointer or reference to an object. I.e., either with a local object, a global/static object, or a fully contained object inside a composite.