Precedencia de operadores de C++
La siguiente tabla enumera la precedencia y asociatividad de los operadores de C++. Los operadores se listan de arriba a abajo, en orden descendente de precedencia. a, b y c son operandos.
| Precedencia | Operador | Descripción | Asociatividad |
|---|---|---|---|
| 1 | a::b
|
Resolución de ámbito | De izquierda a derecha→ |
| 2 | a++ a--
|
Sufijo/postfijo incremento y decremento | |
type(a) type{a}
|
Conversión funcional | ||
a()
|
Llamada a función | ||
a[]
|
Subíndice | ||
a.b a->b
|
Acceso a miembro | ||
| 3 | ++a --a
|
Prefijo incremento y decremento | De derecha a izquierda← |
+a -a
|
Menos y más unarios | ||
!a ~a
|
NO lógico y NO bit a bit | ||
(type)a
|
Conversión de estilo C | ||
*a
|
Indirección (desreferencia) | ||
&a
|
Dirección de | ||
^^a
|
operador de reflexión (desde C++26) | ||
sizeof
|
Tamaño de[1] | ||
| co_await | expresión await (C++20) | ||
new – new[]
|
Asignación dinámica de memoria | ||
delete – delete[]
|
Desasignación dinámica de memoria | ||
| 4 | a.*b a->*b
|
Puntero a miembro | De 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
|
Desplazamiento a la izquierda y a la derecha bit a bit | |
| 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 operadores de igualdad = y != respectivamente
| |
| 11 | a & b
|
Y bit a bit (AND) | |
| 12 | a ^ b
|
O exclusivo bit a bit (XOR) (o exclusivo) | |
| 13 | a | b
|
O inclusivo bit a bit (OR) (o inclusivo) | |
| 14 | a && b
|
Y lógico (AND) | |
| 15 | a || b
|
O lógico (OR) | |
| 16 | a ? b : c
|
Condicional ternario[2] | De derecha a izquierda← |
throw
|
operador throw | ||
| co_yield | expresión yield (C++20) | ||
a = b
|
Asignación directa (proporcionada por defecto para clases 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 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 | De izquierda a derecha→ |
- ↑ El operando de
sizeofno puede ser una conversión de tipo de estilo C: la expresiónsizeof (int) * pse interpreta inequívocamente como(sizeof(int)) * p, pero no comosizeof((int)*p). - ↑ La expresión en 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 unirá más estrechamente (como si estuviera entre paréntesis) a sus argumentos que cualquier operador que aparece en una fila más abajo con una precedencia más baja. 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 unen 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 por completitud: los operadores unarios prefijo siempre asocian de derecha a izquierda (delete ++*p es delete(++(*p))) y los operadores unarios postfijo siempre asocian de izquierda a derecha (a[1][2]++ es ((a[1])[2])++). Tenga en cuenta que la asociatividad es relevante para los operadores de acceso a miembros, aunque se agrupan con operadores unarios postfijo: 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
|