“可变函数”的正确替代方案；在 c++

Question

在 C++ 中将算法包装在类中时，我经常遇到 const 正确性的问题。我觉得我想要一个可变的函数，尽管这是不允许的。谁能告诉我如何实现下面的类？

以下是我想要编写的代码。

• 函数 run() 不应该是 const 函数，因为它改变了 数据。
• 函数 get_result() 应该 是一个常量函数（就用户而言），因为它返回 数据。

但是，如果用户请求结果而不调用 run()，我希望 get_result() 函数运行该算法。这破坏了 const 的正确性，因为我有一个 const 函数调用一个非常量函数。

class operate_on_data
{
  std::vector<double> m_data;  // the data to modify
  bool m_completed;  // check to see if the function run() has been called
public:
  operate_on_data(std::vector<double> data)
    : m_data(data), m_completed(false) {}  //initialise
  void run() //I don't want this function to be const  
  {
    //The algorithm goes here - it alters m_data.
    m_completed = true;  //the algorithm has been run
  }
  std::vector<double> get_result() const //I want this function to be const
  {
    /*The following breaks const correctness because 
      I am calling a non-const function from a const function
      - but this feels like the right thing to do ... */ 
    if (!m_completed) run();  //run the algorithm if it has not run already
    return m_data; //return
  }
};

我成功编译上述类的唯一方法是

• 使 run() const 并使 m_data 和 m_completed 可变。这是可行的，但在概念上是错误的，因为 run() 明显会更改数据。
• 使 get_result() 不是一个常量函数。这似乎也是错误的，因为用户希望这个函数是一个简单的返回，因此是恒定的。
• 将 run() 函数放入 get_result() const 函数中，并使数据变量可变。

我的理解是 mutable 关键字是为第三个选项设计的，其中实现需要更改数据，但用户合理地期望一个简单的返回，因此 const 函数。

但是，我不想执行此最终选项，因为我希望用户能够准确选择何时更改数据。然而，他们有可能忘记调用 run()，因此如果他们请求结果而不调用 run()，我想强制该算法。我觉得想要使 run() 可变 - 但我不被允许这样做。

编写这样一个类的正确方法是什么？

Answer 1

使 run() 常量，并使 m_data 和 m_completed 可变。这是可行的，但在概念上是错误的，因为 run() 明显改变了数据。

实际上并非如此。事实上，你的类中的变量已经改变，但你永远无法证明这一点。调用 run() 不会更改用户能够从类的接口中检索的任何内容。如果您无法检索有关此类更改的任何信息，那么您就不可能演示该更改。这不仅仅是一个语义问题，它直接说明了“mutable”关键字的全部要点。

“mutable”关键字被严重误解了。

也就是说，尽管根据我所掌握的最少信息，我可能会按照上述方式进行操作，但我并不推荐这样做。几乎肯定有一种更好的方法，从更广泛的角度来看待您的问题。

我可能使用的另一种方法显然是您要避免的：强制用户在使用 get_data() 之前调用 run() 。但说实话，这也是一个非常次优的方法。也许更是如此。

编辑：

如果您确实决定使用可变方法，那么我建议进行一些更改。拥有一个名为“run()”的 const 函数并且不返回任何有趣的内容会非常令人困惑。这个函数当然应该是非常量的。因此，如果已经决定这样做，我要做的是让 run() 调用一个 const 和私有函数，该函数具有当前 'run()' 函数的行为，该函数也由 get_data( ）在规定的条件下。

Answer 2

一些抽象的注释可能会帮助您澄清事情：

• const 方法是那些不修改对象的概念“状态”的方法，
• 非const 方法是那些修改对象 的概念“状态”的方法。 。
• 此外，可变字段是每个对象的字段，但不被视为对象概念状态的一部分（就像一些延迟评估和记住的缓存值）。

问题可能是 operate_on_data 可能并不是真正定义良好的类。什么是“operate_on_data”类的对象？这个对象的“状态”是什么？什么不是？这听起来很尴尬（至少对我来说）——并且某些设计的听起来很尴尬的描述可能表明是反直觉的设计。

我的想法是，您将“操作”和“操作结果”的不同概念保留在一个奇怪的类中，这会导致混乱。

Answer 3

我认为你的问题是语义问题，而不是语法问题。

在我看来，在不首先调用 run() 的情况下请求结果是一个错误，并且应该会导致异常。

如果它不是一个错误并且确实应该是可能的，那么我认为首先使用 run() 没有任何意义，所以只需放弃它并完成所有工作即可（非常量）get_result()。

Answer 4

只需将其设置为错误（界面的一部分）即可在运行算法之前获取结果。然后，将工作与结果分开，使两者都能够正确地指示其常量。如果您尝试在运行算法之前调用 get 方法以向客户端表明他们做错了什么，则 get 方法可能会抛出异常。

Answer 5

如果 get_result() 可能实际更改数据，那么它就不是 const。如果您希望它是 const，请不要调用 run()，而是抛出异常。

您应该使用 mutable 来缓存数据，即不会更改实例状态且仅出于性能原因而存储的数据。

Answer 6

如果我处于这个位置，我可能会抛出一个例外。

但是，您可能逃脱

if (!m_completed) (const_cast <operate_on_data *> (this))->run();

但是，如果随后在实际上已定义为的operate_on_data实例上调用get_result const，您输入 lala-land。

Answer 7

const的概念取决于类的实现；重要的是逻辑语义，而不是字段级别/函数级别的常量。因此，如果需要从 const 调用非常量方法，只需进行 const 强制转换即可。我更喜欢：

void X::foo(  ) const {
      X & self = const_cast<X &>(*this);
      self.bar( ); //"bar" non-const function
}

Answer 8

如果 run() 在对象中唯一更改的是 m_completed，那么可以声明 m_completed mutable 和 run()< /代码> <代码>常量。如果 run() 更改了其他内容，那么调用 get_result() 也会更改这些其他内容，这意味着 get_result() 绝对不应该 <代码>常量。

不过，为了完善讨论，您会注意到每个 STL 容器都有两个 begin() 函数和两个 end() 函数。一个 begin() 和一个 end() 函数将返回可变迭代器，而另一个 begin() 和 end()< /code> 函数将返回 const_iterator。

事实上，可以使用 const 和非 const 版本重载 run()。然后 get_result() 将调用 run() 的 const 版本，因为它将被视为唯一合法的选项：

class operate_on_data
{
    std::vector<double> m_data;
    bool m_completed;
public:
    operate_on_data(std::vector<double> data)
        : m_data(data), m_completed(false) { }
    void run()
    {
       //The algorithm goes here - it alters m_data.
       m_completed = true;
    }

    void run() const
    {
        // something that does not modify m_data or m_completed
    }
    std::vector<double> get_result() const
    {
        if (!m_completed)
            run();
        return m_data;
    }
};

但是，这只有意义如果 run() 的 const 版本不会更改任何状态。否则，run() 的非 const 性质将泄漏到 get_result() 中，并使 const- get_result() 是一个公然的谎言。

---

我认为示例代码有些人为。如果没有，您实际上是在采用以下方法：

std::vector<double> results = do_calculation(data);

并将其包装在具有非常薄的接口的对象中（即返回 std::vector< 的 get_results() 方法） /代码>）。我没有看到对象化版本有太多改进。如果您想缓存计算结果，通常只需将 std::vector 保留在将创建并使用此值的代码周围的 int 上，这通常是很有意义的目的。