Tenha cuidado ao comparar números em C++

C++ é uma linguagem de programação amplamente utilizada, mas também aquela na qual os erros de programação são mais comuns. Muitos desses erros são devidos a erros lógicos. Em particular, os erros cometidos durante as operações de comparação podem afetar a precisão e a confiabilidade do seu código.

A linguagem C++ tem um erro de comparação específico que muitos novos desenvolvedores ignoram. Esse erro resulta de um entendimento incorreto de como os operadores funcionam ao realizar comparações múltiplas. Descubra como evitar esse erro comum e por que ele ocorre em primeiro lugar.

Comparações em C++

A linguagem de programação C++ oferece muitos recursos e ferramentas diferentes, juntamente com operações básicas, como operadores de comparação. Operadores de comparação são operações especiais em linguagens de programação que você pode usar para comparar dados uns com os outros. Os desenvolvedores usam esses operadores com bastante frequência, especialmente ao criar algoritmos.

Você pode ver os operadores de comparação em muitos exemplos diferentes da vida diária. Por exemplo, quando você faz compras no supermercado, usa esses operadores em mente para comparar preços. Se o preço de um produto for menor que o outro, você escolhe esse produto.

Você pode ver os operadores de comparação em declarações if-else com bastante frequência. Os operadores de comparação são o local para verificar se um valor é maior, menor ou igual a outro valor. Há um detalhe muito pequeno, mas importante, que você não deve ignorar. Os resultados das expressões de comparação retornam verdadeiro ou falso, que são valores booleanos. Esses valores são um dos componentes básicos da estrutura de controle na programação.

Por exemplo, na linguagem de programação C++, o "==" o operador verifica se dois valores são iguais. Se os valores forem iguais, o resultado retorna true. Caso contrário, o resultado será falso.

se (a == b)
{
retornarverdadeiro;
} 
outro
{
retornarfalso;
}

Um Exemplo de um Problema de Comparação

Um dos erros comuns que os iniciantes em C++ cometem é o uso de operadores de comparação. Esses operadores permitem que os programadores comparem dois valores e executem diferentes operações com base no resultado dessa comparação. No entanto, usar esses operadores incorretamente pode causar erros inesperados.

Por exemplo, embora a expressão 3 < 15 < 10 seja matematicamente incorreta, C++ considera seu resultado verdadeiro. Você pode demonstrar isso escrevendo o seguinte programa de teste simples.

Primeiro, crie um arquivo chamado teste.cpp. Abra este arquivo usando seu editor de código favorito e adicione o seguinte código a ele.

#incluir
int um = 15;
intprincipal()
{
se (3 10)
 {
std::cout << "foo" << std::fim;
 }
outro
 {
std::cout << "vaia" << std::fim;
 }
retornar0;
}

Você pode usar este comando para compilar e executar o código:

g++ test.cpp -o Test

Agora você tem um programa chamado Teste. Execute o programa e examine sua saída.

C++ considerou 3 < 15 < 10 verdadeiro ao executar este programa. Por que o resultado pode vir dessa forma, mesmo sendo uma afirmação matematicamente incorreta?

Causas do problema de comparação em C++

Como a maioria das linguagens de programação, C++ lê o código da esquerda para a direita. Cada operador de comparação produz um valor booleano. Valores booleanos não significam apenas verdadeiro e falso; eles têm um equivalente matemático.

O princípio de funcionamento de um computador depende de uns e zeros. Para um computador, o resultado de algo é verdadeiro ou falso. Os programas de computador geralmente tratam o número 1 como verdadeiro e o número 0 como falso.

Examine o problema de comparação novamente e leia a declaração da esquerda para a direita; você verá que há duas comparações diferentes. A primeira comparação é entre os números 3 e 15. Este é um valor verdadeiro porque 3 é menor que 15.

A segunda comparação é entre esse resultado e o número 10. Como precisa realizar uma comparação numérica, C++ silenciosamente converte o valor verdadeiro booleano para 1. 1 é menor que 10, então o resultado geral é verdadeiro.

Em conclusão, embora pareça uma falácia matemática, esta afirmação é verdadeira para C++ e computadores.

Como resolver problemas de comparação em C++

C++, juntamente com a maioria das outras linguagens de programação, usa uma sintaxe diferente para comparação lógica da matemática tradicional. A expressão matemática 3 < a < 15 significa “3 é menor que a e a é menor que 15.” No entanto, como você viu, C++ interpreta essa expressão de maneira diferente.

Para representar e em C++, use o operador &&. Você pode então encadear expressões booleanas e construir lógica usando operadores como && para representar E, || para representar OU, e ! para representar NÃO. idiomas como Java usa os mesmos operadores lógicos.

Usando o operador lógico correto, você pode corrigir o bug no exemplo anterior:

#incluir
int um = 15;
intprincipal()
{
se (3 < a && a < 10)
 {
std::cout << "foo" << std::fim;
 }
outro
 {
std::cout << "vaia" << std::fim;
 }
retornar0;
}

Agora este código testará se o valor a é maior que 3 e se o valor a é menor que 10. Compile e execute o programa e observe o resultado.

O exemplo anterior imprimia “foo”, mas o programa agora imprime “boo”, como pretendido. O valor booleano do lado esquerdo da comparação (3 < a) é verdadeiro. O valor do lado direito (a < 10) é falso. Desde verdadeiro e falso é sempre falso, a expressão geral é avaliada como falsa, de modo que a condição falha e o outro corridas de blocos.

Tente trocar o AND (&&) para um operador OR (||) e observando o resultado diferente.

A importância das verificações lógicas em C++

Comparações lógicas em C++ envolvem o uso de valores booleanos e operadores de comparação. Certifique-se de usar os valores booleanos e operadores de comparação corretos para controlar a operação de seus programas. Pode ser difícil identificar expressões mal formadas porque o C++ geralmente executa um comportamento diferente em vez de falhar completamente.

Agora você sabe como os compiladores ignoram esse problema e tratam cada comparação como um booleano ao ler da esquerda para a direita. Fique atento a esse problema em qualquer idioma que você usar e aprenda a reconhecer seus efeitos para ficar um passo à frente.