Índice:
Vídeo: Curso C++ - Aula 17 - Operadores Aritméticos - eXcript 2025
Variáveis e constantes são úteis somente se você pode usá-las para realizar cálculos. O termo expressão é jargão C ++ para um cálculo. Você já viu a expressão mais simples:
int n; // declaração n = 1; // expressão
Os programadores combinam variáveis, constantes e operadores para criar expressões. Um operador executa alguma operação aritmética em seus argumentos. A maioria dos operadores leva dois argumentos - estes são chamados operadores binários . Alguns operadores tomam um único argumento - estes são os operadores unários .
Todas as expressões retornam um valor e um tipo.
Operadores binários
A operador binário é um operador que leva dois argumentos. Se você pode dizer var1 op var2, então op deve ser um operador binário. Os operadores binários mais comuns são as mesmas operações simples que você aprendeu na escola primária. Os operadores binários comuns aparecem na tabela.
| Precedência | Operador | Significado |
|---|---|---|
| 1 | - (unary) | Retorna o negativo de seu argumento |
| 2 | ++ (unary) | Incremento |
| 2 | - (unary) | Decreado |
| 3 | * (binário) | Multiplicação |
| 3 | / (binário) > Divisão | 3 |
| % (binário) | Modulo | 4 |
| + (binário) | Adição | 4 |
| - (binário) | Subtração | 5 |
| =, * =,% =, + =, - = (especial) | Tipos de atribuição |
|
Multiplicação, divisão, adição, subtração e módulo são os operadores utilizados para executar a aritmética. Eles funcionam exatamente como os operadores aritméticos que você aprendeu na escola de gramática, com as seguintes considerações especiais:
-
Considere o seguinte exemplo: int n = 2; // declara uma variável int m = 2n; // isso gera um erro
A expressão acima não atribui
m o valor de 2 vezes n . Em vez disso, C ++ tenta interpretar 2 n como um nome de variável. Uma vez que os nomes das variáveis não podem começar com um dígito, ele gera um erro durante a etapa de construção. O que o programador significava era:
int n = 2; int m = 2 * n; // esta é OK
A divisão Inteira joga o restante.
-
Assim, o seguinte: int n = 13/7; // atribui o valor 1 a n
Quatorze dividido por 7 é 2. Treze divididos por sete é 1.
O operador do módulo retorna o restante após a divisão
-
(você pode não se lembrar do módulo): int n = 13% 7; // define n para 6
Quatorze módulos sete é zero. Treze módulos 7 são seis.
Unraveling expressions compostos
Uma única expressão pode incluir vários operadores:
int n = 5 + 100 + 32;
Quando todos os operadores são iguais, C ++ avalia a expressão da esquerda para a direita:
5 + 100 + 32 105 + 32 137
Quando diferentes operadores são combinados em uma única expressão, C ++ usa uma propriedade chamada
precedência. Precedência é a ordem em que os operadores são avaliados em uma expressão composta. Considere o seguinte exemplo: int n = 5 * 100 + 32;
O que vem primeiro, multiplicação ou adição? Ou essa expressão é simplesmente avaliada da esquerda para a direita? Volte para a tabela, que diz que a multiplicação tem uma precedência de 3, que é maior do que a precedência de adição, que é 4 (valores menores têm maior precedência). Assim, a multiplicação ocorre primeiro:
5 * 100 + 32 500 + 32 532
A ordem das operações é anulada pela precedência dos operadores. Como você pode ver
int n = 32 + 5 * 100;
gera o mesmo resultado:
32 + 5 * 100 32 + 500 532
Mas e se você realmente quiser 5 vezes a soma de 100 mais 32? Você pode substituir a precedência das operadoras envolvendo as expressões que deseja executar primeiro entre parênteses, da seguinte maneira:
int n = 5 * (100 + 32);
Agora a adição é realizada antes da multiplicação:
5 * (100 + 32) 5 * 132 660
Você pode combinar parênteses para tornar as expressões tão complicadas quanto você quiser. O C ++ sempre começa com os parênteses aninhados mais profundos que pode encontrar e funciona para fora.
(3 + 2) * ((100/20) + (50/5)) (3 + 2) * (5 + 10) 5 * 15 75
Você sempre pode dividir expressões complicadas usando variáveis intermediárias. O seguinte é mais seguro:
int factor = 3 + 2; int principal = (100/20) + (50/5); int total = factor * principal;
Atribuir um nome para valores intermediários também permite ao programador explicar as partes de uma equação complexa - tornando mais fácil para o próximo programador entender.
