Quand dois-je utiliser des variables temporaires? [fermé]

StackOverflow https://stackoverflow.com/questions/2725285

  •  02-10-2019
  •  | 
  •  

Question

Plus précisément, je me demande qui de ces je devrais écrire: 

{
    shared_ptr<GuiContextMenu> subMenu = items[j].subMenu.lock();
    if (subMenu)
        subMenu->setVisible(false);
}

ou 

{
    if (items[j].subMenu.lock())
        items[j].subMenu.lock()->setVisible(false);
}

Je ne suis pas tenu de suivre les directives de style. Après optimisation, je ne pense pas que ce soit le choix fait une différence dans la performance. Ce qui est généralement le style préféré et pourquoi?

EDIT: le type d'éléments [j] est .subMenu boost :: weak_ptr. serrure () crée un shared_ptr hors de lui. Il est en fait une différence ambiguë dans les deux versions ci-dessus, en ce qui concerne la durée de la shared_ptr temporaire dure, donc je passai mes deux exemples {accolades} pour résoudre l'ambiguïté là.

Était-ce utile?

La solution

Une autre méthode: 

if(shared_ptr<GuiContextMenu> subMenu = items[j].subMenu.lock()) {
    subMenu->setVisible(false);
}
//subMenu is no longer in scope

Je suppose subMenu est un weak_ptr, dans ce cas, votre deuxième méthode crée deux, qui pourraient temporaires ou pourraient ne pas être un problème. Et votre première méthode ajoute une variable à une portée plus large que nécessaire. Personnellement, j'essaie d'éviter les affectations dans les déclarations de if, mais c'est l'un des rares cas où je me sens le plus utile que les alternatives.

Autres conseils

ce cas particulier , vous devrait vraiment utiliser la version avec la variable temporaire. La raison en est pas la performance, mais correct - au fond, vous n'êtes pas garanti que les deux appels x.lock() retournent la même valeur (par exemple, si un autre thread libère la dernière référence forte sur l'objet juste entre les deux appels.). En maintenant la référence forte dans la variable temporaire, assurez-vous qu'il ne disparaîtra pas.

Autre que:

  • les compilateurs ne peuvent généralement pas optimiser des appels de fonction, à moins qu'ils ne sont prouvable sans effet secondaire (ce qui est difficile à faire, mais les attributs de l'aide mai) ou inline. Dans ce cas, l'appel a des effets secondaires.

  • à l'aide peut conduire à des temporaires des programmes plus courts, plus lisibles et plus maintenable (par exemple. En cas d'erreur, vous le fixer dans un endroit)

Je pense que vous avez raison au sujet soit le choix étant pas différent après optimisation.

Personnellement, je déclarer une nouvelle variable si elle rend le code plus lisible, par exemple lorsque vous êtes enchaînant les appels, ou de mettre les appels de fonction dans les appels de fonction. Tant qu'il est maintenable et le code permet d'obtenir le même effet sans différence de vitesse, tout cela se résume à un code lisible.

Modifier

mmyers acheté un bon commentaire. Oui, faites attention à appeler lock() deux fois, par opposition à une seule fois. Ils auront des effets différents en fonction de votre mise en œuvre.

Le choix est essentiellement à vous, mais la chose de base que vous devez rechercher est maintenabilité.

Lorsque la valeur de retour est autre chose qu'un booléen, l'assigner à une variable intermédiaire peut souvent simplifier le débogage. Par exemple, si vous faites un pas sur ce qui suit: 

if( fn() > 0 ) ...

tout ce que vous savez après le fait est que la fonction retourne une valeur soit inférieure à zéro, ou zéro ou plus. Même si la valeur de retour étaient incorrects, le code peut encore apparaître au travail. Affectation à une variable qui peut être inspecté dans votre débogueur vous permettra de déterminer si la valeur de retour était attendu.

Lorsque le retour est un booléen, la valeur réelle est totalement implicite par le flux de code, de sorte qu'il est moins critique; Cependant, dans l'entretien de code que vous trouverez peut-être plus tard, vous avez besoin de ce résultat, vous pouvez décider de faire une habitude dans tous les cas.

Même si la valeur de retour est booléenne, une autre question à considérer est de savoir si la fonction a nécessité des effets secondaires, et si elle peut être affectée par une évaluation de court-circuit. Par exemple, dans la déclaration: 

if( isValid && fn() ) ...

la fonction ne sera jamais appelée est isValid est faux.

Les circonstances dans lesquelles le code pourrait être rompu en maintenance par le programmeur imprudents (et ce sont souvent les programmeurs moins expérimentés qui obtiennent les tâches de maintenance) sont nombreux, et sans doute mieux éviter.

Dans cet exemple spécifique, je pense que cela dépend de ce que fait lock(). la fonction est cher? Se pourrait-il revenir des choses différentes à chaque fois que la fonction est appelée (pourrait-il retourner un pointeur la première fois et la deuxième fois NULL)? Y at-il un autre fil conducteur qui pourrait entrelacer entre les deux appels à lock()?

Pour cet exemple, vous devez comprendre le comportement des lock() et le reste de votre code pour prendre une décision intelligente.

Je préfère le premier la plupart du temps, car il rend le code plus clair et facile à lire, donc moins sujette à l'erreur. Par exemple, vous avez oublié une parenthèse sur ce second exemple :) Dans ce cas, en fait, je ferais probablement ce que vous avez fait dans le second exemple, si je devais utiliser ce sous-menu plus que quelques fois je partirais avec le premier à rendre plus facile à lire le code. En ce qui concerne la performance, chose que je ne importe quel compilateur sain d'esprit serait en mesure d'optimiser ce (ce qui est probablement la raison pour laquelle vous avez vu aucune différence de performance).

En outre, comme mmyers souligné, cela dépend aussi de ce verrouillage () fait. En général, si elle est une méthode getter simple, ou quelque chose comme ça, vous serez très bien.

Tout ce que vous préférez. Pour moi, cela dépend de combien je vais l'utiliser; pour deux lignes, je pourrais simplement l'écrire deux fois, alors que je crée une variable si je l'utilise plus. Cependant, vous êtes celui qui le plus probablement de maintenir ce code et continuer à regarder, donc utiliser tout ce qui fonctionne pour vous. Bien sûr, si vous êtes une entreprise avec une ligne directrice de codage, suivre.

Je pense que le style préféré est le style que vous pensez rend votre code plus lisible et maintenable. Si vous êtes une équipe de plus d'un, la seule autre considération est qu'il est généralement une bonne idée pour tout le monde à adopter le même style, encore une fois pour une meilleure lisibilité et facilité d'entretien.

Dans ce cas, je pense que vous devriez utiliser le temporaire. Même si vous connaissez la mise en œuvre à .lock () est peu coûteux, qui peut changer. Si vous ne avez pas besoin de verrouillage d'appel () deux fois, non. La valeur est ici qu'il découple votre code de la mise en œuvre de la serrure (). Et c'est une bonne chose en général.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top