Comment défausser const en C++

Question

C'est ce que je suis en train de faire et je ne peux pas:

#include <string> 
using namespace std; 
class A { 
public: 
    bool has() const { return get().length(); } 
    string& get() { /* huge code here */ return s; } 
private: 
    string s; 
}; 

L'erreur que je reçois est:

passing ‘const A’ as ‘this’ argument of 
‘std::string& A::get()’ discards qualifiers 

Je comprends ce que le problème est, mais comment puis-je le réparer? J'ai vraiment besoin de has() pour être const. Merci.

Answer 1

Ajouter une seconde surcharge de get():

string const & get() const { return s; } 

qui sera appelée sur un objet typé const de classe A.

En pratique, je préfère ajouter seulementconst des accesseurs de type, puis garder les modifications entièrement internes à la classe ou même les éviter complètement. Par exemple, cela signifie avoir une méthode DoUpdateLabel(){/*do something with s*/} plutôt que d'exposer les internes. Cela a l'effet secondaire agréable que vous pouvez éviter la duplication des accesseurs dans de nombreux cas.

Si vous devez absolument avoir une modification par accesseurs et vous ne voulez pas une enveloppe supplémentaire de const, vous pouvez utiliser const_cast<>:

bool has() const { return const_cast<A*>(this)->get().length(); } 

Cependant, si get() a des effets secondaires et has() est déclaré const, il est douteux que ce soit le comportement que vous voulez vraiment.

Answer 2

Il est assez courant d'avoir les versions const et non-const des mêmes fonctions. Donc, l'un d'eux serait appelé si votre objet est appelé en tant qu'objet const, et le second - si la même chose se produit avec un non-const.

Je dois mentionner que cette technique est généralement utilisée avec les opérateurs mais convient également pour votre cas actuel.

---

Aussi, dans votre cas actuel, la meilleure approche pourrait signifier avoir SEULEMENT const méthode comme

const string& get() const { return s } 

et refactorisation tous vos autres code afin qu'il fonctionne avec une chaîne retournée par référence constante.

Answer 3

std::string get() const { return s; } 

parce que le passage des chaînes par valeur est généralement pas cher (je ne me souviens pas si cela est une garantie), et je ne pense pas que vous voulez que la chaîne que vous regardez pour changer sous vos pieds lorsque A le modifie.

Answer 4

Essayez ceci:

const string& get() const { return s; } 

La première const applique au type de retour de la méthode get() méthode. Le type de retour est une référence à une chaîne. Dans l'ensemble, il s'agit d'une référence const à une chaîne, qui impose que cette valeur ne soit pas modifiée.

La seconde const s'applique à la méthode, en faisant effectivement une méthode const.

Answer 5

Je pense que votre question est un peu vague.

Vous avez:

bool has() const { return get().length(); } 
string& get() { /* huge code here */ return s; } 

... et ont besoin has() être const.

je peux penser à trois façons de contourner cela, en fonction de ce que vous essayez vraiment faire:

L'option la plus propre serait pour has d'utiliser uniquement le code const. Si certains de vos /* huge code here */ code non-const mais ne change pas réellement la valeur logique de la classe (comme le calcul d'une valeur interne mise en cache) envisagez d'utiliser mutable sur les données impliquées.

Si la partie /* huge code here */ est non const par nature, considère refactorisation dans une autre fonction et de l'appeler séparément:

using namespace std; 
class A { 
public: 
    bool has() const { return get().length(); } 
    const string& get() const { return s; } 
    void computestuff() { /* huge code here */ } 
private: 
    string s; 
}; 

A instance; 

// old client code: 
// string s = instance.get(); 
// 
// new code: 
instance.computestuff(); // non-const call 
instance.get(); // const call 
instance.has(); // const call 

En fin de compte, vous pouvez également jeter le const-ness loin (mais gardez à l'esprit que la nécessité de le faire est presque toujours un signe de mauvaise conception/besoin de refactoriser):

class A { 
public: 
    bool has() const { return const_cast<A*>(this)->get().length(); } 
    string& get() { /* huge code here */ return s; } 
private: 
    string s; 
};