Question

假设我们有以下课程：

// Foo.h
class Foo
{
  public:
    Foo();
    int getA() const;
    int getB() const;
    bool getC() const;
    bool getD() const;
    bool operator==(const Foo& other) const;

  private:
    int a;
    int b;
    bool c;
    bool d;
}

// Foo.cpp
bool Foo::operator==(const Foo& other) const
{
    return (a == other.a && b == other.b && c == other.c && d == other.d);
}

由于需求的变化，我们现在需要实现一个比较Foo s的附加函数 - 但不关心Foo中的d值是否相等。问题是现在在哪里实现这个功能。

它可以在需要它的类附近/中实现......

// Bar.cpp
bool compareFoosExceptForD(const Foo& lhs, const& Foo rhs)
{
    return (lhs.getA() == rhs.getA() && lhs.getB() == rhs.getB() && lhs.getC() == rhs.getC())
}

但是这两个功能羡慕和代码重复（例如，如果Foo得到int e，我们需要更新其==运算符和compareFoosExceptForD函数。

将其置于Foo内会解决上述两点，但也感觉不完全正确“相等，但不关心D”是一种非常特殊的雪花功能除了导致其包含的Bar类之外，不太可能在任何地方使用。

// Foo.h
class Foo
{
  public:
    Foo();
    //...
    bool equalIgnoringD(const& Foo other);
    //...
}

// Foo.cpp
bool Foo::equalIgnoringD(const Foo& other) const
{
    return (a == other.a && b == other.b && c == other.c);
}

bool Foo::operator==(const Foo& other) const
{
    return (equalIgnoringD(other) && d == other.d);
}

有没有更好的方法可以解决这个问题，我现在想念，或者我的直觉就是表现出来并将功能添加到Foo是正确的方法？

（注意：以上示例相当简化。Foo包含更多功能和成员，int和bool是（在现实）类和结构本身，它们实现了==运算符。）

Answer 1

我想这整个问题都是基于某种观点的。我个人将采用第二条路径，将equalIgnoringD(const Foo& other)作为Foo的成员来实现，并在operator==中重用该功能，而不是在compareFoosExceptForD中实现Bar.cpp。 / p>

如果稍后确实将另一个成员e添加到Foo，则不必记住更新Bar separatley。假设您从现在开始每年将e添加到Foo。我肯定知道我会忘记更新Bar，因为显然Foo和Bar之间没有其他链接来指示依赖性。这就是为什么我本人接受Foo中具有“非常特殊的雪花功能”的原因。此外，谁知道此功能是否特别。以后您可能最终不得不在其他地方使用它。

关于您的问题，是否有更好的方法可以解决此问题：我无法自发想到。正如ShadowRanger所说，“最佳”解决方案始终取决于整个环境。

如何以及在何处实现检查“部分平等”的函数

1 个答案: