C++ Operator Precedence
La siguiente tabla enumera la precedencia y asociatividad de los operadores de C++. Los operadores se enumeran de arriba a abajo, en precedencia descendente. a , b y c son operandos.
| Precedencia | Operador | Descripción | Asociatividad |
|---|---|---|---|
| 1 | a :: b | Resolución de ámbito | Izquierda a derecha → |
| 2 | a ++ a -- | Incremento y decremento sufijo/postfijo | |
type
(
a
)
type
{
a
}
|
Conversión funcional | ||
| a ( ) | Llamada de función | ||
| a [ ] | Operador de Subíndice | ||
| a. b a - > b | Acceso a miembro | ||
| 3 | ++ a -- a | Incremento y decremento prefijos | Derecha a izquierda ← |
| + a - a | Operadores unarios de suma y resta | ||
| ! a ~a | NOT lógico y NOT bit a bit | ||
(
type
)
a
|
Conversión estilo C | ||
| * a | Indirección (dereference) | ||
| & a | Operador de dirección | ||
sizeof
|
Tamaño-de [nota 1] | ||
| co_await | expresión de espera (C++20) | ||
new
–
new[]
|
Asignación dinámica de memoria | ||
delete
–
delete[]
|
Desasignación de memoria dinámica | ||
| 4 | a. * b a - > * b | Operador de acceso a miembro por puntero | Izquierda a derecha → |
| 5 | a * b a / b a % b | Multiplicación, división y resto | |
| 6 | a + b a - b | Suma y resta | |
| 7 | a << b a >> b | Operadores de desplazamiento a la izquierda y desplazamiento a la derecha | |
| 8 | a <=> b | Operador de comparación de tres vías (desde C++20) | |
| 9 | a < b a <= b a > b a >= b |
Para
operadores relacionales
<
y
<=
y
>
y
>=
respectivamente
|
|
| 10 | a == b a ! = b |
Para los
operadores de igualdad
=
y
!=
respectivamente
|
|
| 11 | a & b | AND bit a bit | |
| 12 | a ^ b | XOR bit a bit (o exclusivo) | |
| 13 | a | b | OR bit a bit (or inclusivo) | |
| 14 | a && b | AND lógico | |
| 15 | a || b | OR Lógico | |
| 16 | a ? b : c | Operador condicional ternario [nota 2] | Derecha a izquierda ← |
throw
|
operador throw | ||
| co_yield | expresión de yield (C++20) | ||
| a = b | Asignación directa (proporcionada por defecto para clases de C++) | ||
| a + = b a - = b | Asignación compuesta por suma y diferencia | ||
| a * = b a / = b a % = b | Asignación compuesta por producto, cociente y resto | ||
| a <<= b a >>= b | Asignación compuesta por desplazamiento a la izquierda y desplazamiento a la derecha bit a bit | ||
| a & = b a ^ = b a | = b | Asignación compuesta por AND, XOR y OR bit a bit | ||
| 17 | a, b | Coma | Izquierda a derecha → |
- ↑ El operando de sizeof no puede ser una conversión de tipo estilo C: la expresión sizeof ( int ) * p se interpreta inequívocamente como ( sizeof ( int ) ) * p , pero no como sizeof ( ( int ) * p ) .
-
↑
La expresión en el medio del operador condicional (entre
?y:) se analiza como si estuviera entre paréntesis: su precedencia relativa a?:se ignora.
Al analizar una expresión, un operador que aparece en alguna fila de la tabla anterior con una precedencia se vinculará más estrechamente (como si estuviera entre paréntesis) a sus argumentos que cualquier operador que aparezca en una fila inferior con menor precedencia. Por ejemplo, las expresiones std:: cout << a & b y * p ++ se analizan como ( std:: cout << a ) & b y * ( p ++ ) , y no como std:: cout << ( a & b ) o ( * p ) ++ .
Los operadores que tienen la misma precedencia se asocian a sus argumentos en la dirección de su asociatividad. Por ejemplo, la expresión a = b = c se analiza como a = ( b = c ) , y no como ( a = b ) = c debido a la asociatividad de derecha a izquierda de la asignación, pero a + b - c se analiza como ( a + b ) - c y no como a + ( b - c ) debido a la asociatividad de izquierda a derecha de la suma y la resta.
La especificación de asociatividad es redundante para operadores unarios y solo se muestra para completitud: los operadores unarios prefijos siempre asocian de derecha a izquierda ( delete ++* p es delete ( ++ ( * p ) ) ) y los operadores unarios sufijos siempre asocian de izquierda a derecha ( a [ 1 ] [ 2 ] ++ es ( ( a [ 1 ] ) [ 2 ] ) ++ ). Nótese que la asociatividad es significativa para los operadores de acceso a miembros, aunque se agrupan con operadores unarios sufijos: a. b ++ se analiza como ( a. b ) ++ y no como a. ( b ++ ) .
La precedencia de operadores no se ve afectada por la sobrecarga de operadores . Por ejemplo, std:: cout << a ? b : c ; se analiza como ( std:: cout << a ) ? b : c ; porque la precedencia del desplazamiento aritmético a la izquierda es mayor que la del operador condicional.
Notas
La precedencia y la asociatividad son conceptos en tiempo de compilación y son independientes del orden de evaluación , que es un concepto en tiempo de ejecución.
El estándar en sí no especifica niveles de precedencia. Se derivan de la gramática.
const_cast
,
static_cast
,
dynamic_cast
,
reinterpret_cast
,
typeid
,
sizeof...
,
noexcept
y
alignof
no están incluidos ya que nunca son ambiguos.
Algunos de los operadores tienen grafías alternativas (por ejemplo, and para && , or para || , not para ! , etc.).
En C, el operador condicional ternario tiene mayor precedencia que los operadores de asignación. Por lo tanto, la expresión e = a < d ? a ++ : a = d , que se analiza en C++ como e = ( ( a < d ) ? ( a ++ ) : ( a = d ) ) , no compilará en C debido a restricciones gramaticales o semánticas en C. Consulte la página correspondiente de C para más detalles.
Véase también
| Operadores comunes | ||||||
|---|---|---|---|---|---|---|
| asignación |
incremento
decremento |
aritméticos | lógicos | comparación |
acceso a
miembros |
otros |
|
a
=
b
|
++
a
|
+
a
|
!
a
|
a
==
b
|
a
[
...
]
|
llamada a función
a ( ... ) |
|
coma
a, b |
||||||
|
condicional
a ? b : c |
||||||
| Operadores especiales | ||||||
|
static_cast
convierte un tipo a otro tipo relacionado
|
||||||
|
Documentación de C
para
Precedencia de operadores en C
|