2

我有两个版本的 operator()：

const A& operator(int x ,int y) const;
A& operator(int x ,int y);

但我不知道避免代码重复的最佳方法是什么（因为它们本质上具有相同的逻辑）。

我确实阅读了关于运算符重载（以及其他一些问题）的精彩常见问题解答，但没有找到答案。

EDIT_1：我已经尝试过 Skizz 提出的建议，但类似的东西对我来说不太适用，但也许我错过了一些东西：

因为这在不编译时有效，但会出现以下错误：

错误：从“const value_type {aka const int}”类型的表达式中对“int&”类型的引用进行无效初始化</p>

4

3 回答 3

2

如果这两种方法“本质上具有相同的逻辑”，那么它们肯定都应该被标记为 const。如果它们的行为不同，是否应该将它们称为相同的东西？

你需要的是第三种隐藏的方法来做常见的事情，就像这样：-

const A& operator(int x ,int y) const
{
  return Common (x,y);
}
A& operator(int x ,int y)
{
  return Common (x,y);
}
A& Common (int x, int y) const
{
   // common code
}

这利用了隐式非 const 到 const 的转换。在第一种方法中，this 对象在对 Common 的调用中保持 const，但非常量返回值被转换为 const。第二种，非 const this 对象转换为 const this 对象，返回对象不变。

于 2013-09-09T16:04:15.037 回答
1

如果您将有问题的数据作为共享/唯一指针，您可以将其转发给一个通用函数：

class X {
    public: 
    const A& operator () (int x ,int y) const { 
        common(data, x, y);
        return *data;
    }

    A& operator () (int x ,int y) { 
        common(data, x, y);
        return *data;
    }

    private:
    void common(std::shared_ptr<T>, int x ,int y) const;
    std::shared_ptr<A> data;
};

现在您可以通过 data.get() 访问 T*，即 'T* get() const'。（注意：我认为通用功能是一个糟糕的设计）

你也可以这样做：

class X {
    public:
    const A& operator () (int x ,int y) const { 
        common(x, y); 
        return data;
    }

    A& operator () (int x ,int y) { 
       // ... make mutations
       common(x, y); 
       // ... make mutations
       return data;
    }

    void common(std::shared_ptr<T>, int x ,int y) const;
    T data;
};

或者实际上，使数据可变，如果它没有破坏逻辑常量：

class X {     
    const A& operator () (int x ,int y) const { 
        // ... make mutations on the mutable data, only
        return *lazy_evaluated_data;
    }

    A& operator () (int x ,int y) { 
        const X& self = *this;
        self(x, y);
        return *lazy_evaluated_data;;
    }

    private:
    mutable T lazy_evaluated_data; // or a cache
};
于 2013-09-09T15:30:29.917 回答
0

编写一个辅助函数并从两个运算符中调用它。你需要做一些const_cast<...>(this)丑陋的事情，但这是一种常见的模式。

于 2013-09-09T15:16:04.780 回答