Question

所以我有这两个类：Foo和Bar。

//forward declaration for Bar
class Bar;

typedef enum Type { TYPE1, TYPE2, TYPE3 };

// My class Foo
class Foo
{ 
public:
    explicit Foo(Type fooType) 
        :mType(fooType) 
    {} 

    Type getFooType() const
    {
        return mType;
    }

inline bool operator==(const Bar& bar) { return (bar.getBarType() == mType); } //ERROR: error C2027: use of undefined type 'Bar'

private:
    Type mType; 
};

// My class Bar
class Bar
{ 
public:
    explicit Bar(Type barType) 
        :mType(barType) 
    {} 

    Type getBarType() const
    {
        return mType;
    }

private:
    Type mType; 
};

现在在我的代码中，我想比较两个实例（一个来自Foo，另一个来自Bar类）。像这样：

if(myBar->getBarType() == myFoo->getFooType())
{
 //...
}

问题： 我知道我需要实现operator ==才能进行这种比较。所以我已经如上所述完成了...... 我得到了这个错误，尽管事实上我已经做出了前瞻性声明。我在这里缺少什么，允许我在两个类上使用operator ==进行比较？

Answer 1

您需要在operator==类定义之后定义Bar，而不是在Foo类中定义。在类中声明它，但在外面定义它。

inline Foo::operator==(const Bar &bar) const { ... }

这对您上面的测试非常有帮助，因为左侧有Bar元素，右侧有Foo元素，因此Foo中的operator==赢了＆不予考虑。定义symetric全局operator==函数会很有用。

inline bool operator==(const Bar &bar, const Foo &foo) { return foo == bar; }

Answer 2

你说你希望这种比较起作用......

if(myBar->getBarType() == myFoo->getFooType())

这是比较enum Type函数返回的getXType值，而不是Foo和Bar对象本身，并且枚举在默认情况下具有可比性，因此您不需要提供您自己的operator==。

从来没有，你曾试图这样做，而且... ...

inline bool operator==(const Bar& bar) { return (bar.getBarType() == mType); } //ERROR: error C2027: use of undefined type 'Bar'

...问题是此功能定义出现在翻译单元中的地方未定义Bar。你可以声明函数......

inline bool operator==(const Bar& bar);

...然后在class Bar的定义之后在翻译单元中定义它。

这仍然只允许您在与getFooType()作为左侧参数和右侧Foo进行比较时省略显式Bar调用。为了支持您要求的其他顺序，您需要在Bar内使用const Foo&的类似运算符。

还有一个细节......你说......

我得到了那个错误，尽管事实上我做了前瞻声明。

前向声明只是让编译知道Bar是一个类，它不告诉编译器Bar包含Type getBarType()成员函数，并且需要知识编译你的operator==。

运算符==比较两个不同的类

2 个答案: