¿Qué hace aquí el compilador: int a = b * (c * d * + e)? [duplicate]

Tuve un error extraño en mi programa, y ​​después de algunas horas de depuración, encontré la siguiente línea muy estúpida:

int a = b * (c * d *  + e)

Si no lo ves: Entre d y e escribí * +donde solo un +se pretendía.

¿Por qué se compila esto y qué significa realmente?

los + se interpreta como un operador más unario. Simplemente devuelve el valor promocionado de su operando.

unario + devuelve el valor promocionado.
unario - devuelve la negación:

int a = 5;
int b = 6;
unsigned int c = 3;

std::cout << (a * +b); // = 30
std::cout << (a * -b); // = -30
std::cout << (1 * -c); // = 4294967293 (2^32 - 3)

Esto compila porque el + se está interpretando como unario más, que realizará las promociones integrales sobre los tipos integral o enumeración y el resultado tendrá el tipo del operando promocionado.

Asumiendo e es un tipo de enumeración integral o sin ámbito terminaría teniendo las promociones integrales aplicadas de todos modos ya que * aplica el conversiones aritméticas habituales a sus operandos que termina en el promociones integrales para tipos integrales.

Del borrador del estándar C++ 5.3.1 [expr.unary.op]:

El operando del operador unario + tendrá un tipo aritmético, enumeración sin ámbito o puntero y el resultado es el valor del argumento. La promoción integral se realiza en operandos integrales o de enumeración. El tipo del resultado es el tipo del operando promocionado.

Las promociones integrales se tratan en el apartado 4.5 [conv.prom] y si las variables e es un tipo diferente a bool, char16_t, char32_t, or wchar_t y tienen un rango de conversión inferior a En t entonces estaría cubierto por el párrafo 1:

Un prvalue de tipo entero que no sea bool, char16_t, char32_t o wchar_t cuyo rango de conversión de entero (4.13) sea menor que el rango de int se puede convertir en un prvalue de tipo int si int puede representar todos los valores del tipo fuente ; de lo contrario, el prvalue de origen se puede convertir en un prvalue de tipo int sin signo.

Para un conjunto completo de casos podemos mirar preferencia cp.

Unary plus también puede ser útil en algunos casos para resolver la ambigüedad, un caso interesante sería Resolver la sobrecarga ambigua en el puntero de función y std::function para una lambda usando +.

Tenga en cuenta, para esas respuestas, refiriéndose a unario - y valores negativos, esto es engañoso, como muestra este ejemplo:

#include <iostream>

int main()
{
    unsigned  x1 = 1 ;

    std::cout <<  -x1 << std::endl ;
}

lo que resulta en:

4294967295

Véalo en vivo usando gcc en wandbox.

Es interesante notar que unario más se agregó a C99 para la simetría con unario menos, de la Justificación de la Norma Internacional—Lenguajes de Programación—C:

Unary plus fue adoptado por el Comité C89 a partir de varias implementaciones, por simetría con unary minus.

y no puedo encontrar un buen caso en el que el casting no sea suficiente para lograr la misma promoción/conversión deseada. El ejemplo de lambda que cito arriba, usando unario más para forzar que una expresión lambda se convierta en un puntero de función:

foo( +[](){} ); // not ambiguous (calls the function pointer overload)

podría lograrse usando un molde explícito:

foo( static_cast<void (*)()>( [](){} ) );

y podría argumentarse que este código es mejor ya que la intención es explícita.

Vale la pena señalar que Manual de referencia de C++ anotado(BRAZO) tiene el siguiente comentario:

Unary plus es un accidente histórico y generalmente inútil.

Como han explicado, (+) y (-) solo se usaron como operador unario:

Operadores unarios actuar sobre un solo operando en una expresión

int value = 6;
int negativeInt = -5;
int positiveInt = +5;

cout << (value * negativeInt); // 6 * -5 = -30
cout << (value * positiveInt); // 6 * +5 = 30

cout << (value * - negativeInt); // 6 * -(-5) = 30
cout << (value * + negativeInt); // 6 * +(-5) = -30

cout << (value * - positiveInt); // 6 * -(+5) = -30
cout << (value * + positiveInt); // 6 * +(+5) = 30

entonces de tu código:

int b = 2;
int c = 3;
int d = 4;
int e = 5;

int a = b * (c * d *  + e)

//result: 2 * (3 * 4 * (+5) ) = 120

¿Por qué compila? compila porque + se analiza como operador unario más, no como operador de suma. El compilador intenta analizar tanto como sea posible sin generar errores de sintaxis. Así que esto:

d * + e

se analiza como:

• d (operando)
• * (operador de multiplicación)
• + (operador unario más)
  • e (operando)

Considerando que, esto:

d*++e;

se analiza como:

• d (operando)
• * (operador de multiplicación)
• ++ (operador de incremento previo)
  • e (operando)

Además, esto:

d*+++e;

se analiza como:

• d (operando)
• * (operador de multiplicación)
• ++ (operador de incremento previo)
  • + (operador unario más)
    • e (operando)

Tenga en cuenta que no crea un error de sintaxis sino el error del compilador “LValue requrired”.

Para darle un giro adicional a las respuestas correctas ya dadas aquí, si compila con el indicador -s, el compilador de C generará un archivo de ensamblaje en el que se pueden examinar las instrucciones reales generadas. Con el siguiente código C:

int b=1, c=2, d=3, e=4;
int a = b * (c * d *  + e);

El ensamblado generado (usando gcc, compilando para amd64) comienza con:

    movl    $1, -20(%ebp)
    movl    $2, -16(%ebp)
    movl    $3, -12(%ebp)
    movl    $4, -8(%ebp)

por lo que podemos identificar posiciones de memoria individuales -20(%ebp) como variable b, hasta -8(%ebp) como variable e. -4(%epp) es la variable a. Ahora, el cálculo se representa como:

    movl    -16(%ebp), %eax
    imull   -12(%ebp), %eax
    imull   -8(%ebp), %eax
    imull   -20(%ebp), %eax
    movl    %eax, -4(%ebp)

Entonces, como han comentado otras personas que respondieron, el compilador simplemente trata “+e” como la operación positiva unaria. La primera instrucción movl coloca el contenido de la variable e en el registro del acumulador EAX, que luego se multiplica rápidamente por el contenido de la variable d o -12(%ebp), etc.

Esto es solo matemática básica. Por ejemplo:

5 * -4 = -20

5 * +4 = 5 * 4 = 20 

-5 * -4 = 20

Negativo * Negativo = Positivo

Positivo * Negativo = Negativo

Positivo * Positivo = Positivo

Esta es la explicación más fácil que existe.

El menos (-) y el más (+) solo indican si el número es positivo o negativo.