Operadores de comparação em C++: o que e inferior e superior
Se você está chegando agora em C++ e se deparou com isso num código, a coisa é mais simples do que parece. Os operadores inferior (<) e superior (>) servem para comparar dois valores e determinar uma relação de ordem entre eles. Retornam um booleano: verdadeiro ou falso. É isso, basicamente. O que eu vejo todo mundo errar na hora é confundir a direção do operador. A seta "olha" para o valor menor. Então a b significa "a é menor que b", não o contrário. Eu levei uns dias pra parar de ler isso como "maior que" por hábito de outras linguagens. Só anotar isso numa folha e colar na parede se precisar.
O que e inferior e superior na prática
A diferença entre inferior e superior é puramente direcional. O operador inferior (<) verifica se o valor da esquerda é estritamente menor que o da direita. O operador superior (>) faz o oposto, verificando se o da esquerda é estritamente maior. Se você precisa incluir a igualdade, aí entram o inferior_ou_igual (<=) e superior_ou_igual (>=). São quatro operadores no total, mas na rotina do dia a dia você usa dois deles o tempo todo. Exemplo direto:
int x = 5; int y = 10; bool resultado = x y; Nesse caso, resultado será true porque 5 é de fato menor que 10. Inverter a ordem, x > y, retorna false. Sem mágica.
O que poucas pessoas explicam de cara é que esses operadores funcionam com tipos que vão além de inteiros. Float, double, char, até strings (que comparam lexicograficamente) e tipos definidos pelo usuário, desde que você sobrescreva o operador no código. Isso última parte é importante. Se você criar uma classe e quiser comparar objetos dela com < e >, precisa implementar isso manualmente. Caso contrário, o compilador simplesmente rejeita. Um exemplo real que eu tive: estava fazendo uma comparação de objetos de temperatura entre Celsius e Fahrenheit. Criei uma classe Temperatura com construtores que aceitavam ambas as escalas. Quando fui fazer ordenação de lista, o código não compilava. A solução foi sobrescrever o operador
para converter internamente para Kelvin e comparar a partir dali. Se você tiver um problema parecido, esse é o caminho. Não tente comparar string diretamente, isso só gera dor de cabeça.
O que também é comum e vale anotar: operadores de comparação encadeados. Em C++, a < b c funciona, mas o comportamento pode não ser o que você espera. O operador tem associatividade da esquerda para a direita, então o compilador avalia (a < b) c. O resultado da primeira comparação é um bool (0 ou 1), que depois é comparado com c. Na maioria das vezes isso retorna algo inesperado. Se quer verificar se b está entre a e c, escreva a < b && b c. Sem ambiguidade.
Quando usar inferior e superior em estruturas de dados
Esses operadores são a base de ordenação. Qualquer estrutura que precise ordenar elementos — vetores, map, set — usa o operador < por padrão. O std::sort de uma biblioteca padrão, por exemplo, depende exclusivamente dele. Se você passar objetos de uma classe própria pra um sort sem ter definido o operador
, o código não compila. Ponto. Outro uso comum é em árvores binárias de busca e heaps. A lógica de inserção e remoção depende de saber se um nó é inferior ou superior a outro. Aqui entra uma nuance que muitos ignoram: a relação deve ser estrita e irreflexiva. Ou seja, estava mal implementado, permitindo que um elemento fosse considerado menor que ele mesmo em certas condições de contorno. O que também vale saber: o operador superior (>) não é obrigatório pra nada. Na prática, . Se sua classe só implementa o inferior, tudo que precisa de ordenação funciona normalmente. Definir o superior também é útil pra legibilidade do código quem vai ler, mas é opcional. Vou falar de um que eu encontrei na prática e que me custou horas. Comparei valores em ponto flutuante usando < e > diretamente. O problema é que floats têm precisão limitada. Duas grandezas que deveriam ser iguais podem diferir por um valor na casa dos 1e-7 devido a acúmulo de erro de arredondamento. O operador < retorna false, o > também retorna false, e sobra o == que também falha. O resultado é que seu programa entra num loop infinito ou toma uma decisão errada silenciosamente. A workaround que eu uso agora é evitar comparação direta com floats. Em vez de Também tem o caso de tipos customizados com conversão implícita. Se sua classe tem um construtor que recebe um int, o operador pode ser aplicado com um int de qualquer lado. Às vezes isso é útil, mas pode gerar comparações que não fazem sentido no domínio do seu problema. Eu vi código onde um objeto personalizado era comparado com um inteiro aleatório e o compilador nem reclamar. Vale a marcação do operador como explicit quando for o caso, pro compilador exigir conversão explícita. Operadores de comparação não resolvem tudo. Se você precisa de ordenação complexa — por exemplo, ordenar strings ignorando acentos e case sensitivity — o operador < padrão não vai servir. Nesse cenário, o ideal é usar um comparator personalizado, passando uma função lambda ou um funtor como terceiro argumento pra funções como std::sort. O operador continua existindo, mas você o ignora nesse contexto. Outro ponto fraco: em códigos concorrentes, comparações simples não são atômicas por si só. Se dois threads estão lendo e escrevendo variáveis que você usa nos operadores, o resultado pode ser inconsistente. Nesse caso, a solução não é mudar o operador, mas sim proteger o acesso com mutex ou usar tipos atômicos da biblioteca padrão. O operador em si continua correto, o problema é o acesso concorrente aos dados comparados. 👉 Clique no botão abaixo para saber mais sobre o assunto! E tem ainda o caso de comparações com NaN em floats. Qualquer comparação com NaN retorna false, inclusive Se você está implementando o operador inferior pra uma classe própria, a assinatura mais comum é: O const no final indica que a função não modifica o objeto atual. O parâmetro é passado por referência constante pra evitar cópia desnecessária. Isso é importante porque em loops de ordenação com milhares de elementos, cópias desnecessárias podem transformar um sort rápido num gargalo real. Eu tive um caso onde um sort de 50 mil objetos levava 8 segundos com cópia e 0,4 segundos com referência constante. A diferença é bruta. Se quiser garantir a simetria correta, também é boa prática implementar o operador superior como inversão do inferior, ou simplesmente não implementar e deixar pra quem lê o código usar a versão invertida. Depende do estilo da equipe e do projeto. O que fica claro depois de um tempo é que inferior e superior são ferramentas básicas, mas que escondem armadilhas que só aparecem em cenários reais. Float, concorrência, NaN, classes customizadas, ordenação complexa. Conhecer esses pontos evita dor de cabeça futura. O resto é questão de prática e de escrever o código direto, sem tentar escapar das regras da linguagem.a a sempre deve ser false. Se isso não valer, estruturas como std::set podem travar ou retornar resultados inconsistentes. Eu já perdi meia tarde debugando um set que parecia duplicar elementos porque meu operador a > b é exatamente o mesmo que b a. Muita gente define ambos, mas não é necessário. A biblioteca padrão só exige o Edge case que custa caro se você não souber
if (a b), eu uso uma tolerância: if (a < b - epsilon), onde epsilon é algo como 1e-9 para double. Isso elimina os falsos negativos causados por imprecisão numérica. Não é bonito, mas funciona e evita bugs difíceis de rastrear.Limitações e quando essa abordagem falha
NaN == NaN. Isso significa que x 5, x > 5 e x == 5 todos retornam false se x for NaN. Se seu código lida com dados numéricos que podem ter NaN, você precisa tratar isso explicitamente antes de chegar aos operadores de comparação.Dica rápida de implementação
bool operator(const OutraClasse& outro) const;
