Pourquoi convertir les valeurs de retour inutilisées en void?

int fn();

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

Y a-t-il une raison de convertir une valeur de retour inutilisée en annulation, ou ai-je raison de penser que c'est une perte de temps totale?

Suivre:

Eh bien, cela semble assez complet. Je suppose que c'est mieux que de commenter une valeur de retour inutilisée car le code auto-documenté est meilleur que les commentaires. Personnellement, je désactiverai ces avertissements car il s'agit d'un bruit inutile.

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

La réponse de David couvre à peu près la motivation pour cela, pour montrer explicitement aux autres "développeurs" que vous savez que cette fonction retourne mais que vous l'ignorez explicitement.

C'est un moyen de garantir que, là où c'est nécessaire, les codes d'erreur sont toujours traités.

Je pense que pour C ++, c'est probablement le seul endroit où je préfère également utiliser des casts de style C, car utiliser la notation de cast statique complète me semble exagéré ici. Enfin, si vous passez en revue une norme de codage ou en écrivez une, il est également judicieux d'indiquer explicitement que les appels à des opérateurs surchargés (n'utilisant pas la notation d'appel de fonction) devraient également en être exemptés:

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.

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 comme C ++, vous devriez utiliser static_cast :

static_cast<void>(fn());

En ce qui concerne le compilateur, la conversion de la valeur de retour en void n'a pas beaucoup de sens.

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 possibles et émet des avertissements et des suggestions. Si une fonction renvoyait une valeur qui n'a pas été vérifiée, lintcela avertirait si cela était accidentel. Pour faire taire lintcet avertissement, vous lancez l'appel à (void).

La conversion en voidest utilisée pour supprimer les avertissements du compilateur pour les variables inutilisées et les valeurs ou expressions de retour non enregistrées.

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

Toute expression peut être explicitement convertie en type «cv void». La valeur de l'expression est ignorée .

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());

Tous les formulaires sont valides. Je le raccourcis généralement comme:

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

C'est aussi bien.

Depuis c ++ 17, nous avons l' [[maybe_unused]]attribut qui peut être utilisé à la place du voidcast.

Cast to void est gratuit. Ce ne sont que des informations pour le compilateur sur la façon de le traiter.

Pour la fonctionnalité de votre programme, le casting pour annuler 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 sur vos intentions, il est préférable d'utiliser un commentaire. Ajouter un casting comme celui-ci ne semblera qu'étrange et soulèvera des questions sur la raison possible. Juste mon avis...

De plus, lors de la vérification de la conformité de votre code aux normes MISTA (ou autres), les outils automatiques tels que LDRA ne vous permettront pas d'appeler une fonction qui a un type de retour sans qu'elle renvoie une valeur à moins que vous ne convertissiez explicitement la valeur retournée en (void)

C ++ 17 [[nodiscard]]

C ++ 17 a normalisé la "valeur de retour entreprise ignorée" avec un attribut.

Par conséquent, j'espère que les implémentations conformes avertiront toujours seulement quand nodiscardest donné, et jamais avertiront autrement.

Exemple:

main.cpp

[[nodiscard]] int f() {
    return 1;
}

int main() {
    f();
}

compiler:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -o main.out main.cpp

résultat:

main.cpp: In function ‘int main()’:
main.cpp:6:6: warning: ignoring return value of ‘int f()’, declared with attribute nodiscard [-Wunused-result]
    6 |     f();
      |     ~^~
main.cpp:1:19: note: declared here
    1 | [[nodiscard]] int f() {
      | 

Les éléments suivants évitent tous l'avertissement:

(void)f();
[[maybe_unused]] int i = f();

Je n'ai pas pu utiliser maybe_unuseddirectement sur l' f()appel:

[[maybe_unused]] f();

donne:

main.cpp: In function ‘int main()’:
main.cpp:6:5: warning: attributes at the beginning of statement are ignored [-Wattributes]
    6 |     [[maybe_unused]] f();
      |     ^~~~~~~~~~~~~~~~

Le (void)travail de fonte ne semble pas obligatoire mais est "encouragé" dans la norme: Comment puis-je supprimer intentionnellement une valeur de retour [[nodiscard]]?

Comme le montre également le message d'avertissement, une «solution» à l'avertissement consiste à ajouter -Wno-unused-result:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -Wno-unused-result -o main.out main.cpp

bien que je ne recommanderais bien sûr pas d'ignorer les avertissements globalement comme celui-ci.

C ++ 20 vous permet également d'ajouter une raison de l' nodiscardcomme [[nodiscard("reason")]]mentionné à: https://en.cppreference.com/w/cpp/language/attributes/nodiscard

warn_unused_resultAttribut GCC

Avant la standardisation de [[nodiscard]], et pour C, avant de décider finalement de standardiser les attributs, GCC a implémenté exactement la même fonctionnalité avec warn_unused_result:

int f() __attribute__ ((warn_unused_result));

int f() {
    return 1;
}

int main() {
    f();
}

qui donne:

main.cpp: In function ‘int main()’:
main.cpp:8:6: warning: ignoring return value of ‘int f()’, declared with attribute warn_unused_result [-Wunused-result]
    8 |     f();
      |     ~^~

Il convient de noter alors que puisque ANSI C n'a pas de norme pour cela, ANSI C ne spécifie pas quelles fonctions de bibliothèque standard C ont l'attribut ou non et par conséquent, les implémentations ont pris leurs propres décisions sur ce qui devrait ou non être marqué warn_unuesd_result, qui C'est pourquoi, en général, vous devriez utiliser le (void)cast pour ignorer les retours de tout appel aux fonctions de bibliothèque standard pour éviter complètement les avertissements dans toute implémentation.

Testé dans GCC 9.2.1, Ubuntu 19.10.