Traiter avec le calcul paresseux dans les classes de C

Question

Disons que j'ai une classe:

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_; 
} 

Où insert() ajoute un élément à easySet_. Les membres de difficultSet_ changent en fonction des membres de easySet_.

Le problème que j'ai est que, insertions multiples signifie que difficultSet_ est constamment recalculé. Je veux donc que difficultSet_ soit calculé paresseusement (c'est-à-dire seulement lorsque difficultBegin(), difficultEnd(), ou difficultSize() sont appelés). Le problème est, alors je dois effectivement faire difficultSet_ dans un mutable parce que sinon difficultSize() ne peut pas fonctionner sur elle.

Alors maintenant ma déclaration de classe ressemble

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_; 
} 

Je me sens comme cela est une mauvaise conception bien. Y a-t-il un meilleur moyen?

Answer 1

C'est totalement la façon de le faire. Const peut signifier binaire const, ou cela peut signifier conceptuellement const. En utilisant mutable signifie que vous faites le plus tard, ce qui est bien.

Answer 2

C'est essentiellement la raison pour laquelle C++ a la construction mutable. Le rant d'Alan De Smet sur l'abus de mutable montre les types de situations dans lesquelles mutable ne devrait pas être utilisé. Dans ce cas, difficileSize() ne change pas ce que NumberCollection représente - ce qui est approprié pour marquer comme const. Il a toujours besoin de changer les internes, ce qui explique pourquoi vous devez marquer difficileSet_et upToDate_ comme mutable.

Answer 3

Pour aider à comprendre pourquoi utiliser mutable, nous pouvons explorer d'autres options.

Vous pouvez résoudre le même problème en utilisant const_cast:

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

Après avoir offert cette solution, je vais dire que c'est inférieur à l'aide mutable. Si un membre est marqué mutable, alors simplement en regardant l'en-tête, je peux comprendre comment vous le traitez. Je ne reçois pas cette information si vous utilisez const_cast. Mais alors quelqu'un pourrait prendre l'autre côté du débat, et dire qu'il vaut mieux ne pas exposer les détails de l'implémentation dans l'en-tête.

Answer 4

Votre solution est bonne en C++ 98. Notez que dans C++ 11, vous devriez envisager de synchroniser l'accès à vos données mutables. Sinon, vous risquez de rencontrer des problèmes lorsque votre classe est utilisée par la STL, ce qui suppose que toutes les fonctions membres const sont thread-safe.

Pour plus de détails, voir Does const mean thread-safe in C++11?