11 KiB
title | localeTitle |
---|---|
Logical Operators and If Statements | Operadores lógicos e se declarações |
Se as declarações em C
A capacidade de alterar o comportamento de uma parte do código baseada em determinadas informações no ambiente é conhecida como fluxo de código condicional. Às vezes, você deseja que seu código seja executado de acordo com determinadas condições. Em tal situação, podemos usar instruções If. Também é conhecida como declaração de tomada de decisão, uma vez que toma a decisão com base em determinada expressão (ou em determinada condição). Se a expressão for avaliada como verdadeira, o bloco de código dentro da instrução 'if' será executado. Se a expressão for avaliada como false, o primeiro conjunto de códigos após o término da instrução 'if' (após a chave de fechamento) será executado.Uma expressão é uma expressão que possui operadores relacionais e / ou lógicos operando em variáveis booleanas. . Uma expressão é avaliada como verdadeira ou falsa.
Sintaxe da instrução if
if (testExpression) {
// statements
}
Um exemplo simples
Vamos ver um exemplo disso em ação:
#include <stdio.h>
#include <stdbool.h>
int main(void) {
if(true) {
printf("Statement is True!\n");
}
return 0;
}
output:
Statement is True!
Assim como helloworld.c, stdio.h foi incluído. Novo neste programa é stdbool.h, que é a biblioteca booleana padrão - contém código que nos dá acesso a 'true' e 'false'.
Outra novidade no exemplo acima é a declaração 'if'. Se a declaração dentro dos parênteses for verdadeira, o código dentro dos colchetes da instrução if será executado. No caso deste exemplo, true é true, então o código executará a função printf
.
If-else
Na instrução 'If-else', Se a instrução dentro do parêntese for verdadeira, o código dentro dos colchetes da declaração 'if' será executado e se a instrução dentro do parêntese for falsa, o código dentro dos colchetes do ' else 'declaração será executada.
Claro, esse exemplo não foi muito útil, porque a verdade é sempre verdadeira. Aqui está outro que é um pouco mais prático:
#include <stdio.h>
int main(void) {
int n = 2;
if(n == 3) { // comparing n with 3
printf("Statement is True!\n");
}
else { // if first condition is not true, then comes to this block of code.
printf("Statement is False!\n");
}
return 0;
}
output:
Statement is False!
Existem algumas coisas importantes que são diferentes aqui. Primeiro, o stdbool.h
não foi incluído. Tudo bem, porque true
e false
não estão sendo usadas. Em C, temos declarações que são tratadas como verdadeiras e falsas, embora as palavras verdadeiro ou falso não estejam envolvidas na operação.
Dentro do parêntese da instrução if é algo novo também: n == 3
. Esta é uma comparação entre n
e o número 3. ==
é o operador de comparação e é uma das várias operações de comparação em C.
Aninhado if-else
A instrução if-else permite que uma escolha seja feita entre duas alternativas possíveis. Às vezes, uma escolha deve ser feita entre mais de duas possibilidades. Por exemplo, a função de sinal em matemática retorna -1 se o argumento for menor que zero, retorna +1 se o argumento for maior que zero e retorna zero se o argumento for zero. A seguinte instrução C ++ implementa essa função:
if (x < 0)
sign = -1;
else
if (x == 0)
sign = 0;
else
sign = 1;
Esta é uma declaração if-else em que a instrução seguinte a else é ela própria uma instrução if-else. Se x for menor que zero, o sinal será definido como -1, no entanto, se não for menor que zero, a instrução após o else será executada. Nesse caso, se x for igual a zero, o sinal será definido como zero e, caso contrário, será definido como 1. Os programadores novatos geralmente usam uma sequência de instruções if em vez de usar uma instrução if-else aninhada. Ou seja, eles escrevem o acima na forma logicamente equivalente:
if (x < 0)
sign = -1;
if (x == 0)
sign = 0;
if (x > 0)
sign = 1;
Esta versão não é recomendada, pois não deixa claro que apenas uma das instruções de atribuição será executada para um determinado valor de x. Também é ineficiente, pois todas as três condições são sempre testadas.
Operadores de Comparação
Nome do Operador | Uso | Resultado do Operador ---------------------------- |: ---------: | --------- -------- Igual a | a == b | Verdadeiro se a é igual a b, falso caso contrário Não é igual a | a! = b | Verdadeiro se a não é igual a b, falso caso contrário Maior que | a> b | Verdadeiro se a for maior que b, falso de outra forma Maior que ou igual a | a> = b | Verdadeiro se a for maior que ou igual a b, falso caso contrário Menos que | a <b | Verdadeiro se a for menor que b, falso de outra forma Menor ou igual a | a <= b | Verdadeiro se a for menor ou igual a b, falso de outra forma
Esse exemplo também tem uma nova palavra: else
. O código dentro do bloco else
é executado apenas se o código dentro do if
não for executado.
Há muito o que podemos fazer com todos esses operadores! Considere o seguinte, onde usaremos uma instrução if-else:
#include <stdio.h>
int main(void) {
int n = 5;
if(n == 5) {
printf("n is equal to 5!\n");
}
else if (n > 5) {
printf("n is greater than 5!\n");
}
return 0;
}
output:
n is equal to 5!
A instrução if-else possui um 'else if' anexado a ela. Esse código é executado se a condição dentro do if anterior era falsa, mas adiciona uma condição dentro de seus próprios parênteses que deve ser verdadeira antes que o código seja executado.
Operadores lógicos
Claro, podemos querer que algo aconteça se não for verdade, ou se isso e alguma outra coisa forem verdade. Para isso, temos operadores lógicos:! para não, && para e, e || para ou. Vamos dar uma olhada nisso em ação:
#include <stfio.h>
int main(void) {
int n = 5;
int m = 10;
if(n > m || n == 15) {
printf("Either n is greater than m, or n is equal to 15\n");
}
else if( n == 5 && m == 10 ) {
printf("n is equal to 5 and m is equal to 10!\n");
}
else if ( !(n == 6)) {
printf("It is not true that n is equal to 6!\n");
}
else if (n > 5) {
printf("n is greater than 5!\n");
}
return 0;
}
output:
n is equal to 5 and m is equal to 10!
Aqui está o primeiro conjunto de parênteses: n > m || n == 5
. Isso será verdadeiro se n for maior que m, ou se n for igual a 5. n não for maior que m, mas n for igual a 5. Porque uma dessas coisas é verdadeira, e elas são unidas por um ou, isso declaração será verdadeira e o código dentro será impresso.
Como o código anterior foi executado, ele não verificará as outras declarações, que só serão verificadas se as anteriores não forem verificadas. Apenas para o exercício, no entanto, considere o que o resto do código estaria verificando. n == 5 && m == 10
será verdadeiro se n for igual a 5 e m for igual a 10. Isto é verdade, mas se n for 6 não será mais verdadeiro e o código dentro disso não será executado .
!(n == 6)
usa parênteses para tornar a operação mais óbvia. Assim como em matemática, parênteses podem ser usados para ordem de operações: coisas dentro dos parênteses serão executadas antes de coisas que não estão entre parênteses. Portanto, neste caso, n == 6
será avaliado e é falso. O !
, 'not', inverte isto de false para true, então esta operação retorna true. Como antes, no entanto, ele não será executado apenas porque uma das instruções anteriores era verdadeira e que isso é anexado já teria sido executado.
Finalmente, n > 5
avaliado como verdadeiro? A resposta é não, porque n é 5 e, portanto, não é maior que 5. Como resultado, esse código não será avaliado como verdadeiro. Para que essa avaliação seja verdadeira, o operador >=
deve ser usado.
Um detalhe sobre comparações C
Anteriormente você leu que as comparações estão verificando se algo é verdadeiro ou falso, mas isso é realmente apenas a metade da verdade. Lembre-se que C é sobre ser leve e próximo ao hardware, é fácil verificar se algo é 0, e qualquer outra coisa requer mais trabalho. Por causa disso, o que as comparações estão realmente fazendo é verificar se algo é falso, que é atribuído o valor 0, ou verificar se não é falso (qualquer outro valor).
Como resultado, esta declaração if é verdadeira e válida:
if(12452) {
printf("This is true!\n")
}
Por design, 0 é falso e, por convenção, 1 é verdadeiro. De fato, aqui está uma olhada na biblioteca stdbool.h
descrita anteriormente:
#define false 0
#define true 1
Na verdade, há um pouco mais nisso, mas essa é a parte que faz todo o trabalho.
Essas duas linhas de código informam ao compilador que a palavra 'false' deve ser substituída por '0', e a palavra 'true' deve ser substituída por '1'. stdbool.h
também tem algumas instruções de documentação e compilador que serão discutidas mais tarde, mas essas duas linhas são tudo o que realmente existe.
Dicas e truques
Considere o código abaixo:
#include <stdio.h>
int main() {
int i=3;
if(i=4) {
printf("This block is executed");
}
else {
printf("NO! I am boss");
}
}
Qual será o resultado? "NÃO! Eu sou chefe"? Se você está adivinhando esta saída, então você está errado. Por quê isso aconteceu? porque na instrução if você usou "=" em vez de "==". "==" é comparador.
Ele irá comparar entre duas variáveis, mas "=" é um operador de atribuição quando dissemos i = 4, simplesmente atribuímos o valor 4 ao inteiro i e, como em "C", todo valor NON-ZERO é verdadeiro if (i = 4) é uma declaração verdadeira e instruções sob isso serão executadas
Antes de você ir ...
Uma revisão
- Se as instruções 'if' verificam se a expressão é verdadeira, então ele executa o código dentro das chaves.
- 'else' pode ser adicionado ao final de um 'if' e será executado somente se a instrução if (s) anterior for falsa.
- 'else if' também pode ser adicionado ao final de um 'if' e será executado somente se a instrução if (s) anterior for falsa.
- Tudo em um computador é representado por números, portanto, toda comparação em C pode ser feita tratando valores como números - até mesmo verdadeiros, falsos e caracteres.
- Há um monte de operadores de comparação:
- == é igual a
- ! = não é igual a
- > é maior que
- <é menor que
- > = é menor ou igual a
- <= é menor ou igual a
- Também temos alguns operadores lógicos, que nos permitem encadear operações lógicas:
- ! chama-se NOT operator-Inverte o estado do operando
- && é chamado AND operator-Retorna true quando ambas as condições são verdadeiras
- || é chamado OU operador-Retorna verdadeiro quando pelo menos uma das condições é verdadeira