Ce n'casting de "void" vraiment?

Souvent utilisé déclaration comme (void)x; permet de supprimer les avertissements sur unused variable x. Mais si j'essaie de compiler le suivant, je obtenir certains résultats, je ne comprends pas très bien:

int main()
{
    int x;
    (short)x;
    (void)x;
    (int)x;
}

De la compilation avec g++, je reçois les mises en garde suivantes:

$ g++ test.cpp -Wall -Wextra -o test
test.cpp: In function ‘int main()’:
test.cpp:4:13: warning: statement has no effect [-Wunused-value]
     (short)x;
             ^
test.cpp:6:11: warning: statement has no effect [-Wunused-value]
     (int)x;
           ^

J'en conclus que la coulée de void est très différente de la conversion d'autres types, être le type de cible le même que decltype(x) ou quelque chose de différent. Je pense à des explications possibles est:

C'est juste une convention qui (void)x; mais pas les autres distributions qui va supprimer les avertissements. Toutes les déclarations tout aussi de ne pas avoir d'effet.
Cette différence est en quelque sorte lié au fait que void x; n'est pas une instruction valide alors que short x; est.

Laquelle de ces si tout est correct? Si aucun, alors comment peut-on la différence dans les avertissements du compilateur être expliqué?

C'est juste une convention entre les compilateurs que cette distribution supprime les avertissements. La Norme C++ ne fait pas mention de mises en garde pour "l'instruction n'a pas d'effet" à tous.

InformationsquelleAutor Ruslan | 2015-12-15

c++casting compiler-warnings suppress-warnings void

31

Casting à vide est utilisé pour supprimer les avertissements du compilateur. Le Standard dit au §5.2.9/4 dit,

Toute expression peut être converties explicitement de type “cv vide.” L'
expression de la valeur est ignorée.

InformationsquelleAutor Rahul Tripathi
10

Cette déclaration:
```
(void)x;
```
Dit "Ignorer la valeur de x". Il n'y a pas ce type comme void - c'est l'absence d'un type. Il est donc très différente de ce:
```
(int)x;
```
Qui dit "considère x comme si c'était un nombre entier." Lorsque l'entier résultant est ignoré, vous obtenez un avertissement (si elle est activée).

Lorsque vous ignorez quelque chose qui n'est rien, il n'est pas considéré comme un problème par GCC-et avec raison, puisque la coulée à vide est un idiomatiques façon d'ignorer une variable de manière explicite dans le C et le C++.
- Je n'ai jamais pensé comme ça, mais je suis un peu confus, pensez-vous que vous pourriez donner un exemple pour clarifier le concept de la conversion d'une variable à une void?
- Je suis assez sûr il y a "un tel type de void". Voir [de base.types].
- est coulée une variable à vide. Vous l'avez dit vous-même. Mais une fois que vous avez fait cela, vous ne pouvez rien faire de plus avec elle, parce que le vide d'expression n'a pas de valeur.
- Donc je ne peux pas semblent envelopper ma tête autour de pourquoi quelqu'un voudrait le faire? Est-il jamais un cas où c'est utile?
- Vous avez déjà identifié les cas où il est utile: explicitement le fait d'ignorer une variable ou une valeur de retour.
- Il est beaucoup plus utile de jeter un résultat de retour à vide ((void)foo()) pour dire que vous êtes volontairement abstraction de la valeur de retour. Le seul moment où je peux l'image de la coulée d'une variable est nulle si la variable est utilisée uniquement à l'intérieur de certaines des #ifdef code, et vous souhaitez supprimer l'avertissement lorsque le code n'est pas inclus.
- Oui, le casting d'une variable nulle est généralement effectuée lorsque la variable n'est utilisée que dans un assert() serait de produire des avertissements dans les versions release.
InformationsquelleAutor John Zwinck
4

La norme ne précise pas la génération d'un avertissement ("diagnostic" dans standardese) pour les variables locales ou des paramètres de la fonction. De même, il ne prévoit pas comment une telle mise en garde pourrait être supprimée. Casting d'une expression variable de void pour supprimer cette alerte est devenu un idiome dans le C et, plus tard, C++ de la communauté au lieu de cela, car le résultat ne peut pas être utilisé de quelque façon (autres que, par exemple,(int)x), il est donc peu probable que le code correspondant est simplement manquantes. E. g.:
```
(int)x;  //maybe you meant f((int)x);
(void)x; //cannot have intended f((void)x);
(void)x; //but remote possibility: f((void*)x);
```
Personnellement, je trouve cette convention trop obscure encore, c'est pourquoi je préfère utiliser un modèle de fonction:
```
template<typename T>
inline void ignore(const T&) {} //e.g. ignore(x);
```
La idiomatiques façon d'ignorer les paramètres de la fonction est, cependant, d'omettre leur nom (comme vu ci-dessus). Une utilisation fréquente que j'ai pour cette fonction, c'est quand j'ai besoin d'être en mesure de nom de paramètre d'une fonction dans conditionnellement code compilé comme un assert. Je trouve par exemple la suite plus lisible que l'utilisation de #ifdef NDEBUG:
```
void rate(bool fantastic)
{
    assert(fantastic);
    ignore(fantastic);
}
```
- Depuis C++17 vous pouvez utiliser [[maybe_unused]] attribut au lieu de tous ces "créatifs" des manières d'ignorer un paramètre.
InformationsquelleAutor Arne Vogel
0

Utilisation Possible:
```
auto it = list_.before_begin();
for (auto& entry : list_)
{
    (void)entry; //suppress warning
    ++it;
}
```
Maintenant l'itérateur, "elle", pointe vers le dernier élément
- La question n'était pas "quand est-il utile", mais plutôt "pour quoi faire".
InformationsquelleAutor Traummaennlein

Vous devez vous connecter pour publier un commentaire.