C++:莫名其妙的 "pure virtual function call"错误

Question

我在使用 Microsoft Visual C++ 2015 时遇到了一些困难，但能够用一个小程序重现该问题。给定以下类:

class BaseClass {
public:
    BaseClass()
        : mValue( 0 )
        , mDirty( true )
    {}
    virtual ~BaseClass() {}
    virtual int getValue() const { if( mDirty ) updateValue(); return mValue; }

protected:
    virtual void updateValue() const = 0;

    mutable bool mDirty;
    mutable int  mValue;
};

class DerivedClass : public BaseClass {
public:
    DerivedClass() {}

protected:
    void updateValue() const override
    {
        mValue++;
        mDirty = false;
    }
};

class Impersonator {
public:
    Impersonator() {}

    // conversion operator
    operator DerivedClass() const
    {
        return DerivedClass();
    }

    // conversion method
    DerivedClass toDerived() const
    {
        return DerivedClass();
    }
};

当我执行以下操作时出现“纯虚函数调用”错误:

void use( const BaseClass &inst )
{
    // calls `getValue` which in turns calls the virtual function 'updateValue'
    int value = inst.getValue();
}

int main()
{
    // creates a temporary, then passes it by reference:
    use( DerivedClass() ); // this works

    // calls conversion operator to create object on stack, then passes it by reference:
    DerivedClass i = Impersonator();
    use( i ); // this works

    // calls conversion method to create a temporary, then passes it by reference:
    use( Impersonator().toDerived() ); // this works

    // calls conversion operator to create a temporary, then passes it by reference:
    Impersonator j = Impersonator();
    use( j ); // causes a pure virtual function call error!

    return 0;
}

鉴于我无法更改 void use(const BaseClass&) 函数，我可以更改 Impersonator 类中的任何内容以允许使用最后一次调用而不生成调试错误？

Answer 1

缓解我看到的问题的唯一方法是将 operator const BaseClass&() 添加到 Impersonator 并让它返回对 DerivedClass< 的引用.

与编译器尝试使用的有问题/错误的转换相比，这将创建更好的转换。

自然 Impersonator 将无法按值返回并创建一个临时对象，因此它必须拥有一个 DerivedClass 对象或多个对象，并处理它们在适当的时候以某种方式。适用于此演示程序的最简单方法是让它返回对其数据成员的引用，但真正的程序可能需要做其他事情。

class Impersonator {
public:
    Impersonator() {}

    // conversion operator
    operator DerivedClass()
    {
        return d;
    }
    operator const BaseClass&()
    {
        return d;
    }

private:
    DerivedClass d;
};