jeter les valeurs de retour inutilisées à néant

Question

 int fn();

void whatever()
{
    (void) fn();
}
 

Existe-t-il une raison de rejeter une valeur de retour inutilisée ou ai-je raison de penser que c'est une perte de temps totale?

Suivre:

Cela semble assez complet. Je suppose que cela vaut mieux que de commenter une valeur de retour non utilisée, car un code auto-documenté est préférable à un commentaire. Personnellement, je vais désactiver ces avertissements car il s'agit d'un bruit inutile.

Je vais manger mes mots si un insecte s'échappe à cause de cela ...

Answer 1

David réponse couvre assez bien la motivation pour cela, explicitement montrer aux autres les "développeurs" de qui vous savez, cette fonction retourne mais vous êtes explicitement de l'ignorer.

C'est une façon de s'assurer que, lorsque nécessaire, les codes d'erreur sont toujours traitées.

Je pense que pour le C++ c'est probablement le seul endroit que je préfère utiliser C-style jette trop, puisque l'utilisation de la pleine statique de la fonte de la notation se sent juste comme exagéré ici. Enfin, si vous êtes à l'examen d'une norme de codage ou d'écriture, c'est aussi une bonne idée de préciser explicitement que les appels à la surcharge des opérateurs (n'utilisant pas d'appel de fonction de la notation) devraient être exemptés de cette trop:

class A {};
A operator+(A const &, A const &);

int main () {
  A a;
  a + a;                 // Not a problem
  (void)operator+(a,a);  // Using function call notation - so add the cast.

Answer 2

Au travail, nous utilisons cela pour reconnaître que la fonction a une valeur de retour mais le développeur a affirmé qu’il était prudent de l’ignorer. Puisque vous avez marqué la question en C ++, vous devriez utiliser * static_cast *:

 static_cast<void>(fn());
 

En ce qui concerne le compilateur, la valeur de retour renvoyée à void a peu de signification.

Answer 3

La vraie raison de faire cela remonte à un outil utilisé sur le code C, appelé lint .

Il analyse le code à la recherche de problèmes éventuels et émet des avertissements et des suggestions. Si une fonction renvoyait une valeur qui n'était alors pas vérifiée, lint avertirait au cas où cela serait accidentel. Pour faire taire lint sur cet avertissement, vous lancez l'appel en (void) .

Answer 4

La conversion en void est utilisé pour supprimer les avertissements du compilateur pour les variables inutilisées et non enregistrées retour des valeurs ou des expressions.

La Norme(2003) dit au §5.2.9/4 dit,

Toute expression peut être converties explicitement de type "cv vide." La valeur de l'expression est jeté.

Vous pouvez donc écrire :

//suppressing unused variable warnings
static_cast<void>(unusedVar);
static_cast<const void>(unusedVar);
static_cast<volatile void>(unusedVar);

//suppressing return value warnings
static_cast<void>(fn());
static_cast<const void>(fn());
static_cast<volatile void>(fn());

//suppressing unsaved expressions
static_cast<void>(a + b * 10);
static_cast<const void>( x &&y || z);
static_cast<volatile void>( m | n + fn());

Toutes les formes sont valides. J'ai l'habitude de faire plus court:

//suppressing  expressions
(void)(unusedVar);
(void)(fn());
(void)(x &&y || z);

Il est aussi d'accord.

Answer 5

Pour la fonctionnalité de votre programme, la conversion en annulation n'a pas de sens. Je dirais également que vous ne devriez pas l'utiliser pour signaler quelque chose à la personne qui lit le code, comme suggéré dans la réponse de David. Si vous souhaitez communiquer quelque chose à propos de vos intentions, il est préférable d'utiliser un commentaire. Ajouter un casting comme celui-ci ne fera que paraître étrange et soulèvera des questions sur la raison possible. Juste mon avis...