¿Cómo funciona el operador de coma?

¿Cómo funciona el operador coma en C++?

Por ejemplo, si hago:

a = b, c;  

¿A termina siendo igual a b o c?

(Sí, sé que esto es fácil de probar: solo documente aquí para que alguien encuentre la respuesta rápidamente).

Actualizar: Esta pregunta ha expuesto un matiz al usar el operador de coma. Solo para documentar esto:

a = b, c;    // a is set to the value of b!

a = (b, c);  // a is set to the value of c!

Esta pregunta en realidad se inspiró en un error tipográfico en el código. lo que estaba destinado a ser

a = b;
c = d;

Convertido en

a = b,    //  <-  Note comma typo!
c = d;

Tenga cuidado de notar que el operador de coma puede estar sobrecargado en C++. Por lo tanto, el comportamiento real puede ser muy diferente del esperado.

Como ejemplo, Boost.Espíritu utiliza el operador de coma de forma inteligente para implementar inicializadores de lista para tablas de símbolos. Por lo tanto, hace que la siguiente sintaxis sea posible y significativa:

keywords = "and", "or", "not", "xor";

Tenga en cuenta que debido a la precedencia del operador, el código es (¡intencionalmente!) idéntico a

(((keywords = "and"), "or"), "not"), "xor";

Es decir, el primer operador llamado es keywords.operator =("and") que devuelve un objeto proxy en el que el resto operator,s son invocados:

keywords.operator =("and").operator ,("or").operator ,("not").operator ,("xor");

El operador coma tiene el más bajo precedencia de todos los operadores de C/C++. Por lo tanto, siempre es el último en vincularse a una expresión, lo que significa esto:

a = b, c;

es equivalente a:

(a = b), c;

Otro hecho interesante es que el operador coma introduce un punto de secuencia. Esto significa que la expresión:

a+b, c(), d

se garantiza que tiene sus tres subexpresiones (a+b, C() y D) evaluados en orden. Esto es significativo si tienen efectos secundarios. Normalmente, los compiladores pueden evaluar las subexpresiones en el orden que consideren adecuado; por ejemplo, en una llamada de función:

someFunc(arg1, arg2, arg3)

los argumentos se pueden evaluar en un orden arbitrario. Tenga en cuenta que las comas en la llamada de función son no operadores; son separadores.

sería igual a b.

El operador coma tiene una precedencia menor que la asignación.

El operador coma:

• tiene la precedencia más baja
• es asociativo por la izquierda

Se define una versión predeterminada del operador de coma para todos los tipos (incorporados y personalizados), y funciona de la siguiente manera, dado exprA , exprB:

• exprA es evaluado
• el resultado de exprA se ignora
• exprB es evaluado
• el resultado de exprB se devuelve como el resultado de la expresión completa

Con la mayoría de los operadores, el compilador puede elegir el orden de ejecución e incluso se requiere omitir la ejecución si no afecta el resultado final (p. ej. false && foo() saltará la llamada a foo). Sin embargo, este no es el caso para el operador de coma y los pasos anteriores siempre sucederán^*.

En la práctica, el operador de coma predeterminado funciona casi de la misma manera que un punto y coma. La diferencia es que dos expresiones separadas por un punto y coma forman dos declaraciones separadas, mientras que la separación por comas mantiene todo como una sola expresión. Esta es la razón por la cual el operador de coma a veces se usa en los siguientes escenarios:

• La sintaxis de C requiere un único expresión, no es una declaración. por ejemplo en if( HERE )
• La sintaxis de C requiere una sola declaración, no más, por ejemplo, en la inicialización del for lazo for ( HERE ; ; )
• Cuando desee omitir las llaves y mantener una sola declaración: if (foo) HERE ; (¡Por favor, no hagas eso, es realmente feo!)

Cuando una declaración no es una expresión, el punto y coma no se puede reemplazar por una coma. Por ejemplo, estos no están permitidos:

• (foo, if (foo) bar) (if no es una expresión)
• int x, int y (la declaración de variable no es una expresión)

En tu caso tenemos:

• a=b, c;equivalente a a=b; c;asumiendo que a es del tipo que no sobrecarga el operador de coma.
• a = b, c = d; equivalente a a=b; c=d;asumiendo que a es del tipo que no sobrecarga el operador de coma.

Tenga en cuenta que no todas las comas son en realidad un operador de coma. Algunas comas que tienen un significado completamente diferente:

• int a, b; — la lista de declaración de variables está separada por comas, pero estos no son operadores de coma
• int a=5, b=3; — esta también es una lista de declaraciones de variables separadas por comas
• foo(x,y) — lista de argumentos separados por comas. De hecho, x y y se puede evaluar en ninguna ¡pedido!
• FOO(x,y) — lista de argumentos macro separados por comas
• foo<a,b> — lista de argumentos de plantilla separados por comas
• int foo(int a, int b) — lista de parámetros separados por comas
• Foo::Foo() : a(5), b(3) {} — lista de inicializadores separados por comas en un constructor de clases

^* Esto no es del todo cierto si aplica optimizaciones. Si el compilador reconoce que cierta pieza de código no tiene absolutamente ningún impacto en el resto, eliminará las declaraciones innecesarias.

Otras lecturas: http://en.wikipedia.org/wiki/Comma_operator

El valor de a sera bpero el valor de la expresion sera c. es decir, en

d = (a = b, c);

a sería igual a by d sería igual a c.

El valor de b se le asignará a a. no le pasara nada a c

Sí El operador de coma tiene poca precedencia que el operador de asignación

#include<stdio.h>
int main()
{
          int i;
          i = (1,2,3);
          printf("i:%d\n",i);
          return 0;
}

Salida: i=3
Porque el operador de coma siempre devuelve el valor más a la derecha.
En caso de operador de coma con operador de asignación:

 int main()
{
      int i;
      i = 1,2,3;
      printf("i:%d\n",i);
      return 0;
}

Salida: i=1

Como sabemos, el operador de coma tiene menor precedencia que la asignación…