web-dev-qa-db-fra.com

La lisibilité est-elle une raison valable pour ne pas utiliser const dans les paramètres (de référence)?

Lors de l'écriture de certaines fonctions, j'ai trouvé un mot clé const dans des paramètres comme celui-ci:

void MyClass::myFunction(const MyObject& obj,const string& s1,const string& s2,const string& s3){
}

provoque souvent la division d'une ligne en 2 lignes dans IDE ou vim, donc je veux supprimer tous les mots clés const dans les paramètres:

void MyClass::myFunction(MyObject& obj,string& s1,string& s2,string& s3){
}

est-ce une raison valable pour ne pas utiliser const? Peut-on maintenir les objets paramètres inchangés manuellement?

c++coding-styleconst
25
ggrr

La lisibilité est une raison valable pour apprendre à utiliser les espaces blancs:

void MyClass::myFunction(
        const MyObject& obj,
        const string& s1,
        const string& s2,
        const string& s3
) {
    return;
}

Situés là-bas, les paramètres ne seront pas confondus avec le corps de la fonction. En les localisant sur une ligne différente, vous n'aurez pas à les repositionner lorsque vous changez le nom de myFunction en quelque chose de plus descriptif. Ne pas modifier la position des paramètres lorsqu'ils n'ont pas changé est quelque chose que les utilisateurs d'outils de contrôle de source apprécieront.

const signifie quelque chose. Ne le jetez pas simplement parce que vous manquez d'espace et d'idées. La lisibilité est primordiale, mais casser des choses en son nom est simplement abandonner.

181
candied_orange

En fait, le problème de lisibilité va certainement dans l'autre sens. Tout d'abord, vous pouvez résoudre trivialement votre ligne de démarrage par tilisation des espaces blancs . Mais la suppression de const ne fait pas que raccourcir la ligne, elle change complètement la signification du programme.

Herb Sutter fait référence à const en référence à const comme le plus important const car une référence à const peut se lier à un temporaire et prolonger sa durée de vie. Une référence lvalue à non -const ne peut pas, vous avez besoin d'une variable distincte.

void foo_const(std::string const& );
void foo_nc(std::string& );

std::string some_getter();

foo_const(some_getter());      // OK
foo_const("Hello there"); // OK

foo_nc(some_getter()); // error
foo_nc("Nope");   // error

std::string x = some_getter(); // have to do this
foo_nc(x);                     // ok
std::string msg = "Really??";  // and this
foo_nc(msg);                   // ok

Cela signifie pour la convivialité que vous devrez introduire toutes ces variables temporaires juste pour pouvoir appeler votre fonction. Ce n'est pas génial pour la lisibilité, car ces variables n'ont pas de sens et n'existent que parce que votre signature est incorrecte.

52
Barry

La réponse simple est "non".

La réponse longue est que le mot clé const fait partie du contrat proposé par la fonction; il vous indique que l'argument ne sera pas modifié. Au moment où vous supprimez le const, cette garantie disparaît de la fenêtre. N'oubliez pas que vous ne pouvez pas raisonnablement maintenir la constance (ou toute autre propriété) de quelque chose en utilisant de la documentation, des conventions ou des directives - si la constance n'est pas appliquée par le compilateur, quelqu'un le fera pense qu'il peut faire leur travail est plus facile s'ils jouent avec le paramètre "juste un peu". Considérer:

// parameter "foo" is not modified
void fna(Foo& foo);

void fnb(const Foo& foo);

Outre le fait que cette dernière version est plus concise, elle fournit également un contrat plus solide et permet au compilateur de vous aider à maintenir vos intentions. Le premier ne fait rien pour empêcher la fonction fna(Foo&) de modifier le paramètre que vous lui passez.

Comme dans la réponse @CandiedOrange, vous pouvez utiliser des espaces pour disposer le code et améliorer la lisibilité.

21
Mael

Suppression du mot clé constsupprime la lisibilité car const communique des informations au lecteur et au compilateur.
Réduire la longueur horizontale du code c'est bien (personne n'aime faire défiler latéralement) mais il y a plus à const que du texte. Vous pouvez le réécrire:

typedef string str;
typedef MyObject MObj;
void MyClass::myFunction(const MObj& o,const str& s1,const str& s2,const str& s3)

Ce qui ne change pas le contrat mais répond au besoin de réduire la longueur de ligne. Vraiment je considérerais l'extrait ci-dessus comme moins lisible et opterais pour l'utilisation de plus d'espace comme déjà mentionné dans la réponse de CandiedOrange.

const est une fonctionnalité du code lui-même. Vous ne feriez pas de la fonction un non-membre pour supprimer le MyClass:: section de la déclaration, donc ne supprimez pas le const

14
Erdrik Ironrose

La lisibilité est-elle une raison valable pour ne pas utiliser const dans les paramètres?

Non. L'omission de const peut modifier les fonctionnalités, perdre les protections const fournit et peut potentiellement créer du code moins efficace.

Peut-on maintenir les objets paramètres inchangés manuellement?

Plutôt que de passer du temps manuellement formatage du code

void MyClass::myFunction(const MyObject& obj,const string& s1,const string& s2,const string& s3){
  //
}

Utilisez formatage automatique outils. Écrivez la fonction selon ses exigences fonctionnelle et laissez le formatage automatique gérer la présentation. L'ajustement manuel de la mise en forme n'est pas aussi efficace que l'utilisation de la mise en forme automatique et l'utilisation du temps gagné pour améliorer d'autres aspects du code.

void MyClass::myFunction(const MyObject& obj, const string& s1, const string& s2, 
    const string& s3) {
  // 
}
3
chux - Reinstate Monica