C++:莫名其妙的"纯虚函数调用"错误

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&()toImpersonator并让它返回对 的引用DerivedClass。

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

自然Impersonator无法按值返回并创建临时对象，因此它必须拥有一个DerivedClass或多个对象，并在适当的时间以某种方式处置它们。适用于此演示程序的最简单方法是让它返回对其数据成员的引用，但真实的程序可能必须执行其他操作。

class Impersonator {
public:
    Impersonator() {}

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

private:
    DerivedClass d;
};