Operadores relacionais e de igualdade C

Os operadores relacionais binários e de igualdade comparam o primeiro operando ao segundo operando para testar a validade da relação especificada. O resultado de uma expressão relacional será 1 se a relação testada for verdadeira e 0 se for falsa. O tipo de resultado é int.

Sintaxe

relational-expression:
 shift-expression
 relational-expression < shift-expression
 relational-expression > shift-expression
 relational-expression <= shift-expression
 relational-expression >= shift-expression

equality-expression:
 relational-expression
 equality-expression == relational-expression
 equality-expression != relational-expression

Os operadores relacionais e de igualdade testam as seguintes relações:

Operador	Relação testada
<	Primeiro operando menor que o segundo operando
>	Primeiro operando maior que o segundo operando
<=	Primeiro operando menor ou igual ao segundo operando
>=	Primeiro operando maior ou igual ao segundo operando
==	Primeiro operando igual ao segundo operando
!=	Primeiro operando não é igual ao segundo operando

Os quatro primeiros operadores da lista têm uma precedência maior do que os operadores de igualdade (== e !=). Consulte as informações de precedência na tabela Precedência e associatividade dos operadores de C.

Os operandos podem ter o tipo integral, flutuação ou ponteiro. Os tipos dos operandos podem ser diferentes. Os operadores relacionais executam as conversões aritméticas comuns em operandos do tipo integral ou flutuação. Além disso, você pode usar as seguintes combinações de tipos de operando com os operadores relacionais e de igualdade:

• Ambos os operandos de qualquer operador relacional ou de igualdade podem ser ponteiros para o mesmo tipo. Para os operadores de igualdade (==) e de desigualdade (!=), o resultado da comparação indica se os dois ponteiros endereçam o mesmo local da memória. Para os outros operadores relacionais (<, >, <=e >=), o resultado da comparação indica a posição relativa dos dois endereços de memória dos objetos apontados. Os operadores relacionais são apenas deslocamentos.

  A comparação do ponteiro é definida apenas para partes do mesmo objeto. Se os ponteiros fizerem referência aos membros de uma matriz, uma comparação é equivalente à comparação dos subscritos correspondentes. O endereço do primeiro elemento da matriz é "menor que" o endereço do último elemento. Para estruturas, os ponteiros para membros da estrutura declarados posteriormente são ponteiros "maiores que" para os membros declarados anteriormente na estrutura. Os ponteiros para os membros da mesma união são iguais.

• Um valor de ponteiro pode ser comparado ao valor da constante 0 para igualdade (==) ou desigualdade (!=). Um ponteiro com o valor 0 é chamado de ponteiro "nulo", ou seja, ele não aponta para um local de memória válido.

• Os operadores de igualdade seguem as mesmas regras que os operadores relacionais, mas oferecem mais possibilidades: um ponteiro pode ser comparado a uma expressão integral constante com o valor 0 ou a um ponteiro para void. Se os dois ponteiros forem nulos, eles serão comparados como iguais. Os operadores de igualdade comparam o segmento e o deslocamento.

Exemplos

Estes exemplos ilustram operadores relacionais e de igualdade.

int x = 0, y = 0;
if ( x < y )

Como x e y são iguais, a expressão neste exemplo gera o valor 0.

char array[10];
char *p;

for ( p = array; p < &array[10]; p++ )
    *p = '\0';

O fragmento neste exemplo define cada elemento de array como uma constante de caractere nulo.

enum color { red, white, green } col;
   .
   .
   .
   if ( col == red )
   .
   .
   .

Essas instruções declaram uma variável de enumeração chamada col com a marca color. A qualquer momento, a variável pode conter o valor inteiro 0, 1 ou 2, que representa um dos elementos do conjunto de enumeração color: a cor red, white ou green, respectivamente. Se col contiver 0 quando a instrução if for executada, todas as instruções dependentes de if serão executadas.

Confira também

Operadores relacionais: <, >, <= e >=
Operadores de igualdade: == e !=