c++ - texto - uso de la coma

Efecto de usar una coma en lugar de un punto y coma en C y C++

Question

Me he dado cuenta en varias ocasiones al refactorizar varias partes del código C y C ++ que se usa una coma en lugar de un punto y coma para separar las declaraciones. Algo como esto;

int a = 0, b = 0;
a = 5, b = 5;

Donde habría esperado

int a = 0, b = 0;
a = 5; b = 5;

Sé que C y C ++ permiten el uso de comas para separar las declaraciones (especialmente los encabezados de bucle), pero ¿cuál es la diferencia si hay alguna entre estas dos piezas de código? Supongo que la coma se dejó como resultado de cortar y pegar, pero ¿es un error y afecta la ejecución?

Answer 1

Como mencionó Frank , cómo se usa el operador de coma en su ejemplo no causa un error. El operador de coma puede ser confuso por varias razones:

• no se ve con demasiada frecuencia porque solo es necesario en algunas situaciones especiales
• hay varios otros usos sintácticos de la coma que pueden parecerse a un operador de coma, pero no lo son (las comas utilizadas para separar los parámetros / argumentos de la función, las comas utilizadas para separar las declaraciones de variables o los inicializadores)

Dado que es confuso y a menudo innecesario, se debe evitar el operador de coma, excepto en algunas situaciones muy específicas:

• puede ser útil para realizar operaciones múltiples en una o más de las expresiones de control de una declaración for
• se puede usar en macros de preprocesador para evaluar más de una expresión en una sola declaración. Esto generalmente se hace para permitir que las macros hagan más de una cosa y aún así sean una expresión única para que la macro ''encaje'' en lugares que solo permitan una expresión.

El operador de coma es, por definición, un operador malintencionado, por definición, es piratear 2 cosas donde solo se permite una. Casi siempre es feo, pero a veces eso es todo lo que tienes. Y esa es la única vez que debe usarlo; si tiene otra opción, no use el operador de coma.

Fuera de mi cabeza, no puedo pensar en muchas otras razones para usar el operador, ya que puedes obtener un efecto similar al evaluar las expresiones en declaraciones separadas en la mayoría de las otras situaciones (aunque estoy seguro de que alguien comentará sobre ellas). otro uso que he pasado por alto).

Answer 2

El operador de coma evalúa todos los operandos de izquierda a derecha, y el resultado es el valor del último operando.

Es sobre todo útil en bucles for si desea realizar múltiples acciones en la parte "incremento", por ejemplo, (invirtiendo una cadena)

for (int lower = 0, upper = s.size() - 1; lower < upper; ++lower, --upper)
    std::swap(s[lower], s[upper]);

Otro ejemplo, donde podría ser una opción (encontrar todas las ocurrencias en una cadena):

#include <string>
#include <iostream>

int main()
{
    std::string s("abracadabra");
    size_t search_position = 0;
    size_t position = 0;

    while (position = s.find(''a'', search_position), position != std::string::npos) {
        std::cout << position << ''/n'';
        search_position = position + 1;
    }
}

En particular, es lógico y no se puede usar para esta condición, ya que tanto cero como distinto de cero pueden significar que el carácter se encontró en la cadena. Con la coma, por otro lado, se llama position = s.find() cada vez que se evalúa la condición, pero el resultado de esta parte de la condición simplemente se ignora.

Naturalmente, hay otras formas de escribir el ciclo:

while ((position = s.find(''a'', search_position)) != std::string::npos)

o solo

while (true) {
    position = s.find(''a'', search_position);
    if (position == std::string::npos)
        break;
    ...
}

Answer 3

La coma es un operador que devuelve un valor que siempre es el segundo argumento (a la derecha), mientras que un punto y coma solo termina las declaraciones. Eso permite que el operador de coma se use dentro de otras instrucciones o para concatenar varias declaraciones para que aparezcan como una sola.

Aquí se llama a la función f (x) y luego se evalúa x > y para la sentencia if.

if( y = f(x), x > y )

Un ejemplo cuando se usa solo para evitar la necesidad de bloquear

if( ... )
   x = 2, y = 3;

if( ... ) {
   x = 2;
   y = 3;
}

Answer 4

No hace una diferencia en el código que publicaste. En general, la coma separa expresiones como un punto y coma, sin embargo, si toma el todo como una expresión, entonces el operador de coma significa que la expresión se evalúa como el último argumento.

Aquí hay un ejemplo:

b = (3, 5);

Evaluará 3, luego 5 y asignará el último a b. Entonces b = 5 . Tenga en cuenta que los corchetes son importantes aquí:

b = 3, 5;

Evaluará b = 3 , luego 5 y el resultado de la expresión completa es 5, sin embargo, b == 3 .

El operador de coma es especialmente útil en bucles for cuando el código de su iterador no es un simple i++ , pero necesita hacer varios comandos. En ese caso, un punto y coma no funciona bien con la sintaxis for-loop.

Answer 5

Un uso sería en el código de golf:

if (x == 1) y = 2, z = 3;
if (x == 1) { y = 2; z = 3; }

La primera línea es más corta, pero parece demasiado confusa para usar en el desarrollo regular.