处理 C++ 中的惰性计算 类

Question

假设我有一个类：

class NumberCollection
{
public:
    typedef std::set<int> SetType;
    typedef SetType::iterator iterator;
    void insert(int n);

    iterator begin();
    iterator end();
    size_t size() const;

    iterator difficultBegin();
    iterator difficultEnd();
    size_t difficultSize() const;    

private:
    SetType easySet_, difficultSet_;
}

其中 insert() 将一个元素添加到 easySet_。 difficultSet_ 的成员根据 easySet_ 的成员而变化。

我遇到的问题是，多次插入意味着 difficultSet_ 会不断重新计算。 所以我希望延迟计算 difficultSet_ （即，仅当 difficultBegin()、difficultEnd() 或 difficultSize()< /code> 被调用）。 问题是，然后我实际上必须将 difficultSet_ 变成 mutable 因为否则 difficultSize() 无法对其进行操作。

所以现在我的类声明看起来

class NumberCollection
{
public:
    typedef std::set<int> SetType;
    typedef SetType::iterator iterator;
    void insert(int n);

    iterator begin();
    iterator end();
    size_t size() const;

    iterator difficultBegin();
    iterator difficultEnd();
    size_t difficultSize() const;    

private:
    SetType easySet_; 
    mutable SetType difficultSet_;
    mutable bool upToDate_;
}

我觉得这是一个糟糕的设计。 有没有更好的办法？

Answer 1

这本质上就是 C++ 具有可变结构的原因。 Alan De Smet 关于 mutable 滥用的咆哮展示了以下几种情况：不应该使用可变的。

在这种情况下，hardSize() 不会改变 NumberCollection 所代表的内容 - 这适合标记为 const。 它有时确实需要更改内部结构，这就是为什么您需要将 oddSet_ 和 upToDate_ 标记为可变的。

Answer 2

你的解决方案在 C++98 中很好。 请注意，在 C++11 中，您应该考虑同步对可变数据的访问。 否则，当 STL 使用您的类时，您可能会遇到问题，STL 假定所有 const 成员函数都是线程安全的。

有关更多详细信息，请参阅 const 是否意味着 C+ 中的线程安全+11？

Answer 3

为了帮助理解为什么使用可变，我们可以探索其他选项。

您可以使用const_cast解决同样的问题：

size_t NumberCollection::difficultSize() const
{
     if(!upToDate_)
     {
          NumberCollection& nonConst = const_cast<NumberCollection&>(*this);
          nonConst.difficultSet_ = PerformExpensiveCalculationFunction();
          nonConst.upToDate_ = true;
     }
     // etc....
}

在提供了这个解决方案之后，我会说它不如使用mutable。 如果一个成员被标记为可变，那么只需查看标头，我就可以了解您如何对待它。 如果您使用const_cast，我将无法获得此信息。

但随后有人可能会采取辩论的另一方，并说最好不要在标头中公开实现细节。

Answer 4

这完全就是这样做的方法。 Const 可以表示二进制 const，也可以表示概念上的 const。 使用可变意味着你正在做后者，这很好。