Operadores en C y C++

C y C++ tienen los mismos operadores aritméticos y todos ellos se pueden sobrecargar en C++.

Todos los operadores relacionales (de comparación) pueden sobrecargarse en C++. Desde C++20 , el operador de desigualdad se genera automáticamente si operator==está definido y los cuatro operadores relacionales se generan automáticamente si operator<=>está definido. ^{[ 1 ]}

C y C++ tienen los mismos operadores lógicos y todos ellos se pueden sobrecargar en C++.

Tenga en cuenta que no se recomienda sobrecargar los operadores lógicos AND y OR , ya que, al estar sobrecargados, siempre evalúan ambos operandos en lugar de proporcionar la semántica normal de evaluación en cortocircuito . ^{[ 2 ]}

C y C++ tienen los mismos operadores bit a bit y todos ellos se pueden sobrecargar en C++.

C y C++ tienen los mismos operadores de asignación y todos ellos se pueden sobrecargar en C++.

Para los operadores de combinación, a ⊚= b(donde ⊚representa una operación) es equivalente a a = a ⊚ b, excepto que ase evalúa solo una vez.

C++ define palabras clave para actuar como alias de varios operadores: ^{[ 7 ]}

Cada palabra clave es una forma diferente de especificar un operador y, como tal, puede usarse en lugar de la variación simbólica correspondiente. Por ejemplo, (a > 0 and not flag)y (a > 0 && !flag)especifican el mismo comportamiento. Como otro ejemplo, la bitandpalabra clave puede usarse para reemplazar no solo el operador AND bit a bit, sino también el operador de dirección de , y puede usarse para especificar tipos de referencia (por ejemplo, int bitand ref = n).

La especificación ISO C permite el uso de estas palabras clave como macros de preprocesador en el archivo de cabecera iso646.h. Para garantizar la compatibilidad con C, C++ también proporciona la cabecera iso646.h, cuya inclusión no tiene ningún efecto. Hasta C++20, también proporcionaba la cabecera correspondiente ciso646, que tampoco tenía ningún efecto.

Aunque esta tabla es adecuada para describir la mayoría del orden de evaluación, no describe algunos detalles. El operador ternario permite cualquier expresión arbitraria como su operando medio, a pesar de figurar con mayor precedencia que los operadores de asignación y coma. Por lo tanto, se interpreta como , y no como el sin sentido . Así, la expresión en medio del operador condicional (entre y ) se analiza como si estuviera entre paréntesis. Además, el resultado inmediato, sin paréntesis, de una expresión de conversión de C no puede ser el operando de . Por lo tanto, se interpreta como y no .a ? b, c : da ? (b, c) : d(a ? b), (c : d)?:sizeofsizeof (int) * x(sizeof(int)) * xsizeof ((int) * x)

La tabla de precedencia determina el orden de vinculación en expresiones encadenadas, cuando no se especifica expresamente entre paréntesis.

• Por ejemplo, ++x*3es ambiguo sin alguna regla de precedencia. La tabla de precedencia nos dice que: x está más estrechamente "vinculado" a ++ que a * , de modo que lo que sea que haga ++ (ahora o después, véase más abajo), lo hace SOLO sobre x (y no sobre ); es equivalente a ( , ).x*3++xx*3
• De manera similar, con 3*x++, donde aunque el sufijo ++ está diseñado para actuar DESPUÉS de que se evalúe toda la expresión, la tabla de precedencia deja claro que SOLO x se incrementa (y NO ). De hecho, la expresión ( , ) se evalúa con tmp como un valor temporal. Es funcionalmente equivalente a algo como ( , , ).3*xtmp=x++3*tmptmp=3*x++xtmp

• Abstraer el problema de precedencia o enlace, considere el diagrama anterior para la expresión 3+2*y[i]++. El trabajo del compilador es resolver el diagrama en una expresión, una en la que varios operadores unarios (llamémoslos 3+( . ), 2*( . ), ( . )++ y ( . )[ i ]) compiten para enlazarse a y. El orden de la tabla de precedencia resuelve la subexpresión final sobre la que actúa cada uno: ( . )[ i ] actúa solo sobre y, ( . )++ actúa solo sobre y[i], 2*( . ) actúa solo sobre y[i]++ y 3+( . ) actúa 'solo' sobre 2*((y[i])++). QUÉ subexpresión es actuada por cada operador está claro a partir de la tabla de precedencia, pero CUÁNDO actúa cada operador no está resuelto por la tabla de precedencia; En este ejemplo, el operador ( . )++ actúa solo sobre y[i] según las reglas de precedencia, pero los niveles de enlace por sí solos no indican el momento del sufijo ++ (el operador ( . )++ actúa solo después de que y[i] se evalúa en la expresión).

La vinculación de operadores en C y C++ se especifica mediante una gramática de lenguaje factorizada, en lugar de una tabla de precedencia. Esto crea algunos conflictos sutiles. Por ejemplo, en C, la sintaxis para una expresión condicional es:

expresión lógica - OR - expresión ? expresión : expresión condicional

mientras que en C++ es:

expresión lógica - OR - expresión ? expresión : expresión de asignación

Por lo tanto, la expresión:

e = a < d ? a++ : a = d 

se analiza de forma diferente en los dos lenguajes. En C, esta expresión es un error de sintaxis, porque la sintaxis para una expresión de asignación en C es:

unaria - expresión '=' asignación - expresión

En C++, se analiza como:

e = ( a < d ? a ++ : ( a = d ))

que es una expresión válida. ^{[ 11 ] [ 12 ]}

Para usar el operador coma en una expresión de argumento de llamada a función, asignación de variable o una lista separada por comas, se requiere el uso de paréntesis. ^{[ 13 ] [ 14 ]} Por ejemplo,

int a = 1 , b = 2 , weirdVariable = ( ++ a , b ), d = 4 ;

Se ha criticado la precedencia de los operadores lógicos bit a bit. ^{[ 15 ]} Conceptualmente, & y | son operadores aritméticos como * y +.

La expresión se analiza sintácticamente como mientras que la expresión se analiza como . Esto requiere que se utilicen paréntesis con más frecuencia de lo que se haría normalmente.a&b==7a&(b==7)a+b==7(a+b)==7

Históricamente, no existía una distinción sintáctica entre los operadores lógicos y los operadores bit a bit. En BCPL , B y las primeras versiones de C, estos operadores no existían. En cambio, tenían un significado diferente según se utilizaran en un contexto de valor de verdad (es decir, cuando se esperaba un valor booleano; por ejemplo, en se comportaban como un operador lógico, pero en se comportaban como uno bit a bit). Se mantuvo esta distinción para conservar la compatibilidad con versiones anteriores de las instalaciones existentes. ^{[ 16 ]}&&||&|if(a==b&c){...}c=a&b

Además, en C++ (y versiones posteriores de C), las operaciones de igualdad, con la excepción del operador de comparación de tres vías, producen valores de tipo booleano que conceptualmente son un solo bit (1 o 0) y, como tales, no pertenecen propiamente a las operaciones "bit-wise".