Operadores Booleanos

Ver Todos os Exercícios

Teoria

E aí galerinha! Aqui é o Juan do Responde Aí. E hoje vamos estudar os operadores booleanos? Verdadeiro!

Operadores Booleanos

Como você responderia à pergunta “Está chovendo?”. Provavelmente com “sim” ou “não”, certo?! Isso é um exemplo de pergunta booleana, que você pode responder com uma afirmativa ou negativa.

Em nossos códigos, vamos usar esse tipo de lógica com muita frequência, e por isso hoje vamos estudar os operadores booleanos.

Os operadores booleanos são forma de a gente realizar operações lógicas no C++. Eles são interessantes porque o resultado deles sempre é uma variável do tipo bool, ou seja, o resultado de um operador booleano é 1 para verdadeiro e 0 para falso.

Operadores relacionais

Os operadores relacionais são usados para realizar comparações entre dois valores. Os operadores relacionais são:

Os resultados dessas operações podem ser guardados em variáveis do tipo bool. Uma outra forma é colocar a expressão entre parêntesis e poderemos usá-la no cout.

Detalhe: Quando for usar operadores booleanos dentro do cout sempre use os parêntesis! Pois pra evitar confusão entre os operadores maior ( > ) e menor ( < ) com os operadores de inserção ( < < e > > ) alguns compiladores dão erro quando usamos os operadores booleanos sem os parêntesis.

Então vamos fazer um exemplo. Crie duas variáveis inteiras com valores quaisquer. E agora vamos ver se as variáveis são iguais, e saber se uma é maior que a outra.

Na linha 09 a gente usou o operador de comparação == para saber se os valores de x e y são iguais, e guardamos o resultado na variável booleana resposta. Na linha 13 a gente usou o operador para saber se x é menor que y e usando os parêntesis, a gente pode imprimir o resultado diretamente com cout.

Operadores lógicos

O segundo tipo de operador boleado são os operadores lógicos. Esses são usados diretamente na realização de matemática booleana.

Geralmente, os operadores lógicos são usados com variáveis booleanas, ou então são usados junto com duas expressões de comparação.

A operação ( x > y ) tem resultado false e operação ( a = = b ) tem resultado true. Depois o operador OU (||) usa estes dois resultados booleanos. O resultado final é 0 o que quer dizer que o resultado final é falso.

Se você ficar com dúvida sobre o comportamento dos operadores lógicos, dar uma olhada na tabela verdade pode ajudar:

O operador de negação ! vai ser útil quando quisermos inverter um valor lógico.

Tipos diferentes... comportamentos diferentes...

E o que acontece quando comparamos tipos diferente? Por exemplo, se for comparar o double 45.3 com o inteiro 30, o C++ faz todo o processo de converter os tipos automaticamente e sempre traz a resposta correta:

É super tranquilo. O C++ percebe que estamos comparando dois números e efetua a comparação normalmente! Sempre que tivermos dois números (int, float ou double) o C++ faz a comparação normalmente.

Mas e quando têm uma letra envolvida na parada? Por exemplo. O que é maior, o número 100 ou a letra ‘C’? Essa pergunta não parece ter muita lógica. Mas vamos colocar isso em um código e ver o que acontece:

O que aconteceu aqui? Uma conversão implícita! Pois é, os operadores booleanos também fazem conversões automáticas de tipos e por isso devemos ter cuidado quando formos utilizar operadores lógicos em valores de tipos diferentes.

O processo de conversão implícita ocorre com os operadores relacionais da mesma forma que os ocorre com aritméticos: quando tipos de dados diferentes são usados em uma operação, os tipos mais baixos são convertidos em tipos mais altos.

É muito importante ter isso em mente caso não queira gerar erros no seu código.

Voltando ao exemplo 100   >   ‘ C ’ , o que ocorreu é que a letra ‘C’ foi convertida em um número de acordo com a Tabela ASCII, que é uma tabela padronizada que relaciona caracteres e números. Nessa tabela a letra ‘C’ equivale ao número 67. Então o C++ compara se 100   >   67 e por isso o resultado é true.

Vamos ver mais alguns exemplos. Agora vamos ver como os operadores lógicos se comportam quando usamos valores não booleanos:

Notou? Quando usamos o 5 (ou qualquer número diferente de zero) esse número será tratado como true. E quando o 0.0 (ou qualquer número igual a zero) esse número será tratado como false. Não importa se o tipo é int, double ou float.

Talvez você ache um pouco confuso, mas com a prática você vai sacando como usar. As conversões automáticas são ótimas e quando bem usadas são super úteis e nos poupam um monte de trabalho. Mas se forem mal usadas, as conversões automáticas podem causar bugs difíceis de detectar.

Só tenha em mente três coisas:

  • Os operadores relacionais fazem conversão da mesma forma que os operadores aritméticos;
  • Já para os operadores lógicos tudo que for numericamente igual a zero é tradado como falso e todo o resto é considerado verdadeiro!
  • Variáveis do tipo char e caracteres de textos são convertidos para inteiros de acordo com a tabela ASCII

Uma boa dica é tentar comparar apenas números com números (ints, floats e doubles entre si). Comparar booleanos com booleanos, e comparar caracteres com caracteres. Isso vai te ajudar a evitar erros e tirar um 10 na prova!

Por hoje é isso! Agora vamos responder umas questões de fixação!

Operadores lógicos

Tipos diferentes... comportamentos diferentes...

Exercícios Resolvidos

Exercício Resolvido #1

Faça um programa que receba dois valores inteiros. Depois confira se o primeiro é maior do que o segundo. Imprima 1 se for verdade e 0 se for falso.

Passo 1

A entrada desse programa são dois números inteiros. Então vamos criar duas variáveis inteiras para guardar os valores inseridos pelo usuário, e uma variável booleana para armazenar o resultado da comparação.

Vamos começar usando os comandos cout e cin para receber as variáveis do usuário.

Passo 2

O foco da questão é realizar a operação booleana de “maior que” e pra isso vamos usar o operador booleano > .

Com esse operador podemos comparar dois valores da seguinte forma:

v a l o r 1 > v a l o r 2

Se o primeiro valor for maior que o segundo, o resultado da operação é verdadeiro que é representado pelo número 1 .

Mas caso o primeiro valor seja menor ou igual ao segundo, então a operação é falsa e o resultado é representado pelo número 0 .

Com isso em mente, a gente pode efetuar a operação v a r 1 > v a r 2 e guardar o resultado da operação na variável r e s u l t a d o , que vai valer 1 (verdadeiro) ou 0 (falso). Veja o código:

Passo 3

Ok, agora a variável r e s u l t a d o armazena o resultado da operação booleana. Então usando o comando c o u t podemos imprimir o valor armazenado nessa variável.

Se a operação for verdadeira será impresso o valor 1 , se a operação for falsa será impresso o valor 0 :

E é isso, a questão está feita! Até a próxima!

Resposta

Exercício Resolvido #2

Observe o código abaixo. Nele contém alguns erros comuns quando usamos os operadores relacionais. Identifique os erros, e reescreva o código com as correções.

Passo 1

Em questões que pedem erros no código, primeiro devemos olhar a estrutura geral. Nesse caso parece estar tudo certo. A função main() foi declarada corretamente e os headers foram inseridos corretamente.

Então vamos olhar o código dentro da main(). As variáveis foram declaradas corretamente também? Não! Falta um ponto e vírgula logo depois de r6 na linha 08.

Passo 2

Agora que já vimos a estrutura geral, vamos olhar as operações relacionais com mais atenção.

Note que na linha 10 o operador de atribuição = foi usado no lugar do operador de igualdade ==. Onde está X = Y; (que significa: atribuir o valor Y à variável X), deveria ser X == Y; (compare se o valor de X é igual ao valor de Y).

Na linha 11 temos mais um erro, pois o operador de desigualdade foi usado de maneira incorreta. Onde está X =! Y (atribuir o valor NÃO Y à variável X), deveria ser X != Y (compare se X é diferente de Y)

Na linha 14 o operador de maior igual foi usado de maneira errada. Onde está X => Y; deveria ser X >= Y

Ok, agora todas as operações estão corretas! Porém há um último erro. Quando usamos uma operação relacional dentro do cout devemos colocar esta operação entre parêntesis. Então, na linha 18 devemos colocar (X == Y).

Passo 3

Pronto! Agora é só aplicar as correções, e teremos o seguinte código:

Resposta

Linha 08 falta o ponto e vírgula no fim da linha.

Linha 10 o operador de atribuição = foi usado no lugar do operador de igualdade ==.

Linha 11 o operador de desigualdade foi usado de maneira incorreta.

Linha 14 o operador de maior igual foi usado de maneira errada.

Linha 18 Uma operação relacional dentro do cout deve entre parêntesis.

Exercício Resolvido #3

Observe o código abaixo e diga qual o resultado das variáveis r1, r2, r3

Passo 1

Fala aí, galerinha! Vamos analisar esse código com calma.

A questão pede os resultados das operações booleanas que são armazenadas nas variáveis r1, r2 e r3.

Nessa questão, aparecem três operadores lógicos: E (&&), OU (||) e NÃO (!).

Sempre que você tiver dúvidas sobre operadores lógicos, vale dar uma conferida nas Tabelas Verdade

Passo 2

Vamos analisar primeiro a variável r1:

Aqui temos o operador lógico E (&&). Sabemos que o P e Q armazenam o valor lógico true, ou seja, ambas são verdadeiras.

Pela tabela verdade, sabemos que com dois valores verdadeiros (linha 1), o resultado da operação E (&&) fica na terceira coluna e é verdadeiro.

r 1 = t r u e

Passo 3

Agora, vamos analisar a variável r2:

Agora o operador lógico é o OU (||). Olhando a tabela verdade, com dois valores verdadeiros (linha 1), o resultado da operação OU (||) fica na quarta coluna e é verdadeiro.

r 2 = t r u e

Passo 4

Por fim, vamos analisar a variável r3:

O operador lógico é o NÃO (!). Esse operador é usado com apenas uma variável, e a função dele é inverter o valor lógico da variável. Logo, se a variável é verdadeira, o resultado será falso.

r 3 = f a l s e

Também vemos isso na primeira linha da tabela.

Resposta

r 1 = t r u e

r 2 = t r u e

r 3 = f a l s e

Exercício Resolvido #4

Se eu fizer a comparação 10   = =   ‘ C ’ vou receber algum erro? Explique. OBS: Não se preocupe em dizer se o resultado é verdadeiro ou falso, apenas explique se essa é uma operação válida.

Passo 1

E aí galerinha! Vamos pra mais uma questão.

Antes de irmos pra resposta de fato, vamos falar um pouco sobre os detalhes da questão.

Pra responder, vamos precisar lembrar de um comportamento chamado conversão automática de tipos. Quando o C++ encontra uma operação entre dois tipos diferentes, automaticamente os valores de tipo mais baixo são convertidos pra um tipo mais alto.

Ou seja, no momento em que a gente fizer a comparação 10   = =   ‘ C ’ , o caractere ‘ C ’ será automaticamente convertido para um inteiro, e a comparação ocorrerá normalmente, sem gerar nenhum erro!

E pronto! Respondemos à questão! Mas se você quiser mais detalhes sobre a conversão de tipos, da uma olhadinha no passo 2 onde eu explico os detalhes.

Passo 2

Mas como um caractere, como a letra ‘C’, é convertido para um número? Os caracteres serão convertidos para inteiro de acordo com uma tabela chamada ASCII:

Essa tabela é dada em hexadecimal, e pra saber o número de um caractere é só cruzar a linha com a coluna. Por exemplo, a letra “J” é representada pelo hexadecimal 4 A (ou 72 em decimal). Já a letra " C " é representada pelo hexadecimal 43 , que é equivalente ao decimal 66 !

Ou seja: 10   = =   ‘ C ’   ⇔ E Q U I V A L E N T E 10 = = 66 , e o resultado dessa comparação é f a l s e

E prontinho, agora você sabe os detalhes do que acontece sob o capô do C++.

Resposta

Nenhum erro é levantado pelo compilador. Quando tipos de dados diferentes estão em uma mesma operação, o C++ efetua uma conversão automática de tipos. A letra ‘C’ será convertida para um valor inteiro equivalente de acordo com a tabela ASCII, e a comparação irá seguir o curso natural.

Exercício Resolvido #5

Observe o trecho de código abaixo:

Qual o valor de r1, r2 e r3

Passo 1

E aí pessoal. Nesse código a gente vai analisar três operações booleanas. Então, antes de tudo, vamos dar uma conferida na Tabela Verdade:

Show!

E precisamos lembrar da regra que, do ponto de vista booleano, tudo que for diferente de 0 é considerado t r u e .

Passo 2

Nas primeiras linhas, estamos apenas declarando variáveis. Então, vamos começar calculando o valor de r1, na linha 10.

Aqui temos uma operação lógica E (||), vamos dar uma olhada na tabela verdade:

Show, mas acontece que na linha 10 nós temos uma operação lógica envolvendo uma variável inteira A e uma variável booleana F .

Na variável A está contido o valor 0 , que do ponto de vista booleano é equivalente a f a l s e . Logo o valor lógico da variável A é f a l s e .

Na variável F está contido o valor f a l s e .

Executando a operação lógica E (||) com dois valores falsos, nós temos que olhar pra quarta linha e quarta coluna da tabela, então veremos que o resultado é falso também.

r 1 = f a l s e

Passo 3

Certo! Agora vamos pra linha 11, onde temos uma operação de NÃO (!)

A operação NÃO (!) inverte o valor lógico da variável C . Então nem precisa de tabela pra isso, é só inverter.

Só que a variável C é um valor do tipo f l o a t , e agora?

Você precisa se lembrar que tudo que for diferente de 0 é considerado t r u e !

O valor contido na variável C é 10 . Esse é um valor diferente de zero! Então, o valor lógico da variável C é t r u e

Agora, se a gente aplicar o operador de NÃO (!) o valor lógico de C é invertido e se torna f a l s e

r 2 = f a l s e

Passo 4

Pra terminar, vamos olhar a Linha 12 nela a gente tem uma operação OU (||), dessa forma, basta que um dos valores seja verdadeiro e a operação será verdadeira (última coluna da tabela no passo 1).

O conteúdo da variável B é negativo. Algumas pessoas podem pensar que valores negativos têm valor lógico falso.

Porém, se você lembrar da regra que do ponto de vista booleano tudo que for diferente de 0 é considerado t r u e , podemos afirmar que o valor negativo guardado na variável B têm valor lógico t r u e .

Ou seja, não importa que o valor seja positivo ou negativo, se for diferente de zero, então é considerado verdadeiro! Logo, o valor lógico de B é t r u e

Então, aplicando a tabela verdade do OU (||) com dois valores verdadeiros, o resultado é t r u e .

r 3 = t r u e

Resposta

r 1 = f a l s e

r 2 = f a l s e

r 3 = t r u e

Exercício Resolvido #6

Um programador está simulando o comportamento de circuitos lógicos com C++. Receba dois valores lógicos do usuário e efetue as seguintes operações:

  • AND
  • OR
  • NOT

Passo 1

E aí galerinha, tudo bem?

Tudo que a questão quer é que a gente receba dois valores booleanos do usuário e execute as operações booleanas E , O U e N Ã O sobre esses valores.

Vamos começar então declarando duas variáveis X e Y que irão receber os valores lógicos do usuário. As variáveis devem ser do tipo b o o l , pois iremos realizar operações booleanas.

Passo 2

O passo seguinte é receber os valores do usuário.

Mas antes, vamos imprimir uma mensagem pedindo que seja inserido 1 para t r u e e 0 para f a l s e . Mensagens explicativas sempre ajudam o usuário.

Depois, vamos usar o c o u t e o c i n para solicitar que o usuário insira o valor lógico correspondente em X e em Y .

Passo 3

Belezinha, agora a gente pode executar as operações.

Como somos espertos, vamos executar as operações juntamente com o c o u t , e assim faremos um código menor e mais limpo.

Chamamos a função c o u t e nela escrevemos para o usuário um texto que representa a operação realizada, em seguida, executamos a operação booleana entre parêntesis, e saltamos uma linha.

Veja o caso da operação E . Escrevemos o texto “ X   E   Y ” e usamos o operador & &

Para a operação O U o texto será “ X   O U   Y ” e usamos o operador | |

E para a operação de negação o operador utilizado é o !

E com isso a questão está finalizada!

Resposta

Exercício Resolvido #7

Receba três números do usuário. Imprima 1 se o primeiro for maior que os outros dois.

Passo 1

Essa questão está pedindo pra gente comparar os números inseridos pelo usuário. Porém, não podemos comparar os três números de uma vez só.

Então o que precisaremos fazer é comparar o primeiro e o segundo, em seguida comparar o primeiro e o terceiro.

Parar retornar o valor 1 o primeiro número tem que ser maior que os outros dois, então usamos o operador E   ( & & ) para verificar e unificar o resultado das comparações anteriores.

Então, vamos precisar de seis variáveis, três variáveis numéricas do tipo f l o a t   para receber qualquer número do usuário n u m 1 ,   n u m 2 e n u m 3 . E também três variáveis lógicas do tipo b o o l : a primeira é r e s 12 para armazenar o resultado da comparação entre o primeiro e o segundo número, depois r e s 13 pro resultado da comparação entre o primeiro e o terceiro número, e a r e s F i n a l para guardar o resultado da operação r e s 12   & &   r e s 13

Passo 2

O próximo passo é pedir que o usuário insira os números a serem comparados. Fazemos isso utilizando os comandos c o u t para solicitar os números, e c i n para armazenar cada valor na variável adequada.

Passo 3

Agora vamos efetuar as comparações.

Pra começar, vamos usar o operador > para verificar se n u m 1 é maior que n u m 2 . O resultado dessa comparação deve ser guardado na variável r e s 12

Com o mesmo operador >   a gente compara os valores n u m 1 e n u m 3 , e guardados em r e s 13

Show de bola. Mas o que nos interessa é saber se n u m 1 é maior que n u m 2 E maior que n u m 3 também. Então vamos usar o operador & & para verificar isso. O resultado é guardado em r e s F i n a l

Passo 4

Beleza, com as operações realizadas, tudo que precisamos é imprimir o resultado final das operações. Pra isso utilize o comando c o u t

E é isso. Programa concluindo!

Resposta

Exercício Resolvido #8

Receba quatro números do usuário: a , b , c e d . Some a e b e multiplique c e d . Imprima 1 se o produto for maior do que a soma. Do contrário imprima 0 .

Passo 1

Let’s go, pessoal.

Nessa questão vamos precisar de quatro variáveis do tipo f l o a t chamadas a , b , c e d , onde iremos armazenar os números inseridos pelo usuário.

Também vamos precisar de mais duas variáveis do tipo f l o a t chamadas s o m a e p r o d u t o para armazenar o resultado das operações.

E por último, uma variável do tipo b o o l chamada r e s u l t a d o , que usaremos para guardar o resultado da comparação entre a soma e o produto.

Então vamos declarar as variáveis!

Passo 2

Agora vamos pedir pro usuário colocar os números. Com o comandos c o u t a gente pede pra ele inserir o valor, e com o c i n a gente armazena cada valor na variável adequada.

Passo 3

O passo seguinte é realizar as operações.

Pra começar vamos usar o operador de adição + para somar as variáveis a e b e armazenar o resultado na variável s o m a

Em seguida, com o operador * efetuamos a multiplicação entre c e d e guardamos o resultado na variável p r o d u t o

Belezinha. Com os resultados em mão podemos compará-los. A questão quer saber se o valor do produto é maior que o da soma, então usamos o operador > . O resultado é guardado na variável r e s u l t a d o

Essa pode ser uma nomenclatura meio esquisita, mas é isso mesmo. Valores diferentes são atribuídos à variável r e s u l t a d o , dependendo de se “ p r o d u t o > s o m a ” for verdadeiro ou falso.

Passo 4

E ta quase acabando.

Só falta a gente imprimir o resultado final contido em r e s u l t a d o . Mas para dar um contexto pro usuário, além de imprimir a variável r e s u l t a d o vamos imprimir também a s o m a e o p r o d u t o

E prontinho, questão feita. Agora é só alegria!

Resposta