Quelle est la bonne utilisation de l'opérateur virgule?

Question

J'ai vu ce code:

 if (cond) {
    perror("an error occurred"), exit(1);
}
 

Pourquoi ferais-tu ça? Pourquoi pas simplement:

 if (cond) {
    perror("an error occurred");
    exit(1);
}
 

Answer 1

Dans votre exemple, il ne sert aucune raison du tout. Il est parfois utile lorsqu'il est écrit comme

if(cond)
  perror("an error occured"), exit(1) ;

- alors vous n'avez pas besoin d'accolades. Mais c'est une invitation à la catastrophe.

L'opérateur virgule est de mettre deux ou plusieurs expressions dans une position où la référence ne permet qu'une seule. Dans votre cas, il n'est pas nécessaire de l'utiliser; dans d'autres cas, comme dans une boucle while, il peut être utile:

while (a = b, c < d)
  ...

où le réel "évaluation" de la boucle while est régi uniquement sur la dernière expression.

Answer 2

Légitime cas de l'opérateur virgule sont rares, mais ils existent. Un exemple est lorsque vous voulez que quelque chose se passe à l'intérieur d'un sursis d'évaluation. Par exemple:

std::wstring example;
auto it = example.begin();
while (it = std::find(it, example.end(), L'\\'), it != example.end())
{
    // Do something to each backslash in `example`
}

Il peut également être utilisé dans des endroits où vous ne pouvez le faire qu'une seule expression, mais qui veulent deux choses. Par exemple, la boucle suivante incrémente x et décrémente y dans la boucle de la troisième composante:

int x = 0;
int y = some_number;
for(; x < y; ++x, --y)
{
    // Do something which uses a converging x and y
}

Ne pas aller chercher pour les utilisations de celui-ci, mais si elle est appropriée, n'ayez pas peur de l'utiliser, et ne pas être jeté pour une boucle si vous voyez quelqu'un d'autre l'utilise. Si vous avez deux choses qui n'ont aucune raison de ne pas être séparé de déclarations, de faire des déclarations séparées au lieu d'utiliser l'opérateur virgule.

Answer 3

L'opérateur virgule permet de grouper les expressions là où on en attend une.

Par exemple, cela peut être utile dans certains cas:

 // In a loop
while ( a--, a < d ) ...
 

Mais dans votre cas, il n'y a aucune raison de l'utiliser. Ce sera déroutant ... c'est tout ...

Dans votre cas, il suffit d'éviter les accolades:

 if(cond)
    perror("an error occured"), exit(1);

// =>
if (cond)
{
    perror("an error occured");
    exit(1);
}
 

Un lien vers une documentation d' opérateur par virgule .

Answer 4

La principale utilisation de l'opérateur virgule est de dissimulation; il permet de faire les deux les choses où le lecteur s'attend seulement une. L'un des plus fréquents utilise—ajout d'effets secondaires à une condition, s'inscrit dans cette de la catégorie. Il y a quelques cas qui pourrait être considéré comme valide, cependant:

Celui qui a été utilisé pour le présenter en K&R: incrémentation des deux les variables en for boucle. Dans un code moderne, cela peut se produire dans un fonction comme std::transformou std::copy, d'où une sortie itérateur est incrémenté symultaneously avec l'itérateur d'entrée. (Le plus souvent, de bien sûr, ces fonctions contiennent un while boucle, avec les incrementations dans des déclarations séparées à la fin de la boucle. Dans de tels cas, il n'y a pas de point à l'aide d'une virgule plutôt que deux états.)

Un autre cas qui me vient à l'esprit est la validation des données des paramètres d'entrée dans un initialiseur liste:

MyClass::MyClass( T const& param )
    : member( (validate( param ), param) )
{
}

(Ce qui suppose que validate( param ) va lever une exception si quelque chose est incorrect.) Cette utilisation n'est pas particulièrement attrayant, en particulier comme il a besoin de l'extra parenthèses, mais il n'y a pas beaucoup d'alternatives.

Enfin, j'ai parfois vu la convention:

ScopedLock( myMutex ), protectedFunction();

, ce qui évite d'avoir à inventer un nom pour l' ScopedLock. Dire la vérité, je ne l'aime pas, mais je l'ai vu utilisé, et l'alternative de ajoutant des accolades pour s'assurer que l' ScopedLock est immédiatement reutilisable n'est pas très joli non plus.

Answer 5

Ceci peut être mieux comprise en prenant quelques exemples:

D'abord: Considérons une expression:

   x = ++j;

Mais pour le moment, si nous avons besoin d'assigner temporairement de débogage de la valeur, alors nous pouvons écrire.

   x = DEBUG_VALUE, ++j; 

Deuxième:
Virgule , des opérateurs sont fréquemment utilisés en for() -boucle par exemple:

for(i = 0, j = 10; i < N; j--, i++) 
 //      ^                   ^     here we can't use ;  

Troisième:
Un exemple de plus(en fait, on peut trouver ce faisant intéressant):

if (x = 16 / 4), if remainder is zero then print  x = x - 1;  
if (x = 16 / 5), if remainder is zero then print  x = x + 1;

Il peut également être fait en une seule étape;

  if(x = n / d, n % d) // == x = n / d; if(n % d)
    printf("Remainder not zero, x + 1 = %d", (x + 1));
  else
    printf("Remainder is zero,  x - 1 = %d", (x - 1));

PS: Il peut également être intéressant de savoir que, parfois, il est désastreux pour utiliser , de l'opérateur. Par exemple, dans la question Strtok d'utilisation, le code ne fonctionne pas, par erreur, OP oublié d'écrire le nom de la fonction et la place de l'écriture, tokens = strtok(NULL, ",'");, il écrivit tokens = (NULL, ",'"); et il n'était pas d'erreur de compilation --mais son expression valide qu' tokens = ",'"; a provoqué une boucle infinie dans son programme.