Operadores em C e C++

C++ também contém os operadores para conversão de tipos de dados const_cast, static_cast, dynamic_cast e reinterpret_cast, que não estão listados na tabela.

Precedência de operadores

A seguir é listada a ordem de precedência e associatividade dos operadores. Elementos na mesma linha são calculados com a mesma precedência, de acordo com a direção dada.

A sintaxe das expressões é especificada por uma gramática livre de contexto, a tabela a seguir é inferida pela gramática.

Operadores	Descrição	Associatividade
`::`	Resolução de escopo	esquerda para direita
`++` `--` `()` `[]` `.` `->`	Incremento e decremento pós-fixo Parênteses (chamada de função) Elemento de arranjo Seleção de elemento por identificador Seleção de elemento por ponteiro	esquerda para direita
`++` `--` `+` `-` `!` `~` `(tipo)` `*` `&` `sizeof` `new []` `delete []`	Incremento e decremento prefixo Adição e subtração unária Não lógico e complemento Conversão de tipo de dado Desreferência Referência (endereço de elemento) tamanho de elemento Alocação dinâmica de memória Desalocação dinâmica de memória	direita para esquerda
`.* ->*`	Ponteiro para membro	esquerda para direita
`*` `/` `%`	Multiplicação, divisão, e módulo (resto)
`+` `-`	Adição e subtração
`<<` `>>`	Deslocamento de bits à esquerda e à direita
`<` `<=` `>` `>=`	“menor que” e “menor ou igual que” “maior que” e “maior ou igual que”
`==` !=	“Igual a” e “diferente de ”
`&`	E para bits
`^`	Ou exclusivo para bits
`\|`	Ou para bits
`&&`	E lógico
`\|\|`	Ou lógico
`c?t:f`	Condição ternária	direita para esquerda
`=` `+=` `-=` `*=` `/=` `%=` `<<=` `>>=` `&=` `^=` `\|=`	Atribuição Atribuição por adição ou subtração Atribuição por multiplicação, divisão ou módulo (resto) Atribuição por deslocalmento de bits Atribuição por operações lógicas	direita para esquerda
`throw`	Lançamento de exceção	---
`,`	Vírgula	esquerda para direita

Tabela

Operador	Sintaxe	É sobrecarregável?	Presente em C?
Operadores aritméticos
Adição unária	`+a`	Sim	Sim
Adição	`a + b`	Sim	Sim
Incremento pré-fixado	`++a`	Sim	Sim
Incremento pós-fixado	`a++`	Sim	Sim
Atribuição por adição	`a += b`	Sim	Sim
Subtração unária	`-a`	Sim	Sim
Subtração	`a - b`	Sim	Sim
Decremento pré-fixado	`--a`	Sim	Sim
Decremento pós-fixado	`a--`	Sim	Sim
Atribuição por subtração	`a -= b`	Sim	Sim
Multiplicação	`a * b`	Sim	Sim
Atribuição por multiplicação	`a *= b`	Sim	Sim
Divisão	`a / b`	Sim	Sim
Atribuição por divisão	`a /= b`	Sim	Sim
Módulo (resto)	`a % b`	Sim	Sim
Atribuição por módulo (resto)	`a %= b`	Sim	Sim
Operadores comparativos
Operador	Sintaxe	É sobrecarregável?	Presente em C?
Menor que	`a < b`	Sim	Sim
Menor ou igual que	`a <= b`	Sim	Sim
Maior que	`a > b`	Sim	Sim
Maior ou igual que	`a >= b`	Sim	Sim
Diferente de	`a != b`	Sim	Sim
Igual a	`a == b`	Sim	Sim
Não lógico	`!a`	Sim	Sim
E lógico	`a && b`	Sim	Sim
Ou lógico	`a \|\| b`	Sim	Sim
Deslocamento à esquerda	`a << b`	Sim	Sim
Atribução de deslocamento à esquerda	`a <<= b`	Sim	Sim
Deslocamento à direita	`a >> b`	Sim	Sim
Atribuição de deslocamento à direita	`a >>= b`	Sim	Sim
Operadores lógicos sobre bits
Operador	Sintaxe	É sobrecarregável?	Presente em C?
Complemento	`~a`	Sim	Sim
E	`a & b`	Sim	Sim
Atribuição por e	`a &= b`	Sim	Sim
Ou	`a \| b`	Sim	Sim
Atribuição por ou	`a \|= b`	Sim	Sim
Ou exclusivo	`a ^ b`	Sim	Sim
Atribuição por ou exclusivo	`a ^= b`	Sim	Sim
Outros operadores
Operador	Sintaxe	É sobrecarregável?	Presente em C?
Atribuição	`a = b`	Sim	Sim
Chamada de função	`a()`	Sim	Sim
Elemento de arranjo	`a[]`	Sim	Sim
De referência	`*a`	Sim	Sim
Referência	`&a`	Sim	Sim
Membro de ponteiro	`a->b`	Sim	Sim
Membro de identificador	`a.b`	Não	Sim
De referência de membro de identificador	`a.*b`	Não	Não
De-referência de membro de ponteiro	`a->*b`	Sim	Não
Conversão de tipo de dados	`(tipo) a`	Sim	Sim
Vírgula	`a , b`	Sim	Sim
Condição ternária	`a ? b : c`	Não	Sim
Resolução de escopo	`a :: b`	Não	Não
Tamanho de	`sizeof a`	Não	Sim
Identificador de tipo	`typeid (tipo de dado)`	Não	Não

Sinônimos em C++

C++ define palavras-chave que atuam como apelidos para alguns operadores: and (and), bitand (and), and_eq (and=), or (||), bitor (|), or_eq (|=), xor (^), xor_eq (^=), not (!), not_eq (!=), compl (~). Eles são processados pelo analisador sintático da mesma forma que seus equivalentes.