Expressões em C ++
Variáveis e constantes são úteis apenas se você pode usá-los para executar cálculos. O termo expressão
é um jargão C ++ para um cálculo. Você já viu a expressão mais simples:int N- // declarationn = 1- // expressão
Programadores combinar variáveis, constantes e operadores para fazer expressões. A operador realizar alguma operação aritmética em seus argumentos. A maioria dos operadores recebem dois argumentos - estes são chamados operadores binários. Alguns operadores de um único argumento - estes são os operadores unários.
Todas as expressões retornam um valor e um tipo.
operadores binários
UMA operador binário é um operador que recebe dois argumentos. Se você pode dizer var1 var2 op, 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. Os operadores binários comuns aparecem na tabela.
| Precedência | Operador | Significado |
|---|---|---|
| 1 | - (Unário) | Devolve o negativo de seu argumento |
| 2 | ++ (Unário) | Incremento |
| 2 | -- (Unário) | diminuição |
| 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 |
O binário mais simples é o operador de atribuição observou o sinal de igual. O operador de atribuição diz, # 147-Take o valor à direita; lado e armazenar no local à esquerda; do lado do operador # 148.;
Multiplicação, divisão, adição, subtração, e módulo são os operadores utilizados para realizar operações aritméticas. Eles funcionam exatamente como os operadores aritméticos que você aprendeu na escola secundária, com as seguintes considerações especiais:
Multiplicação sempre deve ser expressamente declarada e nunca está implícito como é em álgebra. Considere o seguinte exemplo:
int n = 2 // declarar uma variableint 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 2n como um nome de variável. Desde nomes de variáveis não pode começar com um dígito, ele gera um erro durante a etapa de construção.
O que o programador quis dizer foi:
int n = 2-int m = 2 * n- // este é OK
divisão inteira joga fora o resto. Assim, a seguinte:
int n = 13/7 // atribui o valor de 1 para N
Quatorze dividido por 7 é 2. Treze dividido por sete é 1.
O operador módulo devolve o resto da divisão (Você pode não se lembrar modulo):
int n = 13% 7- // N conjuntos de seis
Quatorze modulo sete é zero. Treze modulo sete é seis.
Desvendando expressões compostas
A única expressão pode incluir vários operadores:
int n = 5 + 100 + 32
Quando todos os operadores são os mesmos, C ++ avalia a expressão da esquerda para a direita:
5 + 100 + 32105 + 32137
Quando diferentes operadores são combinadas em uma única expressão, C ++ usa uma propriedade chamada precedência. Precedência é a ordem 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 avaliados da esquerda para a direita? Consulte de volta à mesa, que lhe diz que a multiplicação tem uma precedência de 3, que é maior do que a precedência de adição que é de 4 (valores menores têm maior precedência). Assim, a multiplicação ocorre pela primeira vez:
5 * + 100 32500 + 32532
A ordem das operações é anulada pelo precedência dos operadores. Como você pode ver
int n = 32 + 5 * 100-
gera a mesma sequência:
32 + 5 + * 10032 500532
Mas e se você realmente quer 5 vezes a soma de 100 mais 32? Você pode substituir a precedência dos operadores envolvendo expressões a serem executadas pela primeira vez em parênteses, como se segue:
int n = 5 * (100 + 32) -
Agora, a adição é efectuada antes da multiplicação:
5 * (100 + 32) 5 * 132660
Você pode combinar parênteses para fazer expressões tão complicado como você gosta. C ++ sempre começa com os parênteses mais profundo-aninhados ele pode encontrar e trabalha o seu caminho para fora.
(3 + 2) * ((100/20) + (50/5)) (3 + 2) * (5 + 10) 5 * 1575
Você sempre pode dividir expressões complicadas, utilizando variáveis intermediárias. O que se segue é mais seguro:
fator int = 3 + 2-int principal = (100/20) + (50/5) total de -int = factor * principal-
Atribuindo um nome para valores intermédios também permite ao programador explicar as partes de uma equação complexa - tornando-se mais fácil para o próximo programador a compreender.