2010-09-15 22 views
4

Possible en double:
Is there some ninja trick to make a variable constant after its declaration?Ajout const-ness après le fait en C++

Prenons l'exemple minimale suivante:

void MutateData(std::string&); 

int main() 
{ 
    std::string data = "something that makes sense to humans."; 

    ::MutateData(data); // Mutates 'data' -- e.g., only changes the order of the characters. 

    // At this point, 'data' should never be changed. 
    // Mixing the above with const-correct code seems ugly. 
} 

Actuellement, je fais:

namespace 
{ 
    std::string PrepareData(std::string data) 
    { 
    ::MutateData(data); 

    return data; 
    } 
} 

int main() 
{ 
    const std::string data = ::PrepareData("something that makes sense to humans."); 
} 

Quelles sont les solutions élégantes pour simuler const au-delà du point de déclaration?


EDIT: Je oublié de préciser que je ne peux pas facilement (pas mon code) changement MutateData.

+0

Cela ressemble à un doublon de http://stackoverflow.com/questions/3669315/is-there-some-ninja-trick-to-make-a-variable-constant-after-its-declaration/3669477#3669477 –

+0

Merci pour cela. Je savais qu'il aurait déjà dû y avoir une question à ce sujet. Dommage que je ne l'ai pas trouvé avant de poster. – melmitchell

+0

Certains sujets sont difficiles à rechercher, et il n'y a pas de honte à ne pas les trouver. À certains égards, votre titre est supérieur au précédent, ce qui en fait un candidat idéal pour être laissé fermé mais non supprimé comme un signe pour les futurs visiteurs aux prises avec le même problème de recherche. – dmckee

Répondre

1

Qu'en est-:

string MakeData(string const&) 
{ 
    ... 
    return string(...); // for return value optimization 
} 

suivie

int main() 
{ 
    string const& str = MakeData("Something that makes sense to humans"); 
} 

La différence avec ce que vous faites est d'utiliser une référence const, et une seule fonction. Si vous ne pouvez pas modifier MutateData, faites ce que vous avez suggéré (avec la référence const)

+0

Je ne peux pas vraiment penser à l'avantage d'utiliser une référence constante par rapport à une variable réelle. Dans le cas d'une variable, la plupart des compilateurs éliront la copie supplémentaire et créeront l'objet de retour en place. Dans la version de référence, le compilateur doit toujours conserver le temporaire (réserver l'espace dans la pile où la valeur de retour a été créée) et éventuellement créer une référence (ou éviter de le créer, car une référence est un alias il suffit d'utiliser l'identifiant pour faire référence au temporaire, ce qui correspond exactement à l'optimisation de la valeur de retour). –

+0

@David: Vous avez bien sûr raison, les deux sont exactement équivalents. Mais le truc de référence const est assez idiomatique ... –