Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

Operador menos unário em C

O menos unário calcula o simétrico de um operando aritmético após as promoções de inteiros. Se o tipo resultante não tiver sinal, usa-se aritmética modular. Se for um tipo inteiro com sinal, a possibilidade de representar o simétrico depende do valor do operando e do intervalo de valores do tipo.

Versão: ISO C23; implementation support may vary

Sintaxe

-operand
-(expression)

-x usa o menos unário, um operador prefixo com um único operando aritmético. Não modifica x. Já a - b subtrai um operando a outro. Em -1, - é um operador aplicado à constante inteira 1, e não parte da constante.

Aplicam-se as promoções de inteiros e o resultado tem o tipo obtido após a promoção. unsigned char é promovido a int se int puder representar todos os seus valores; caso contrário, a unsigned int. Os valores comuns de tipo _BitInt estão isentos destas promoções; os campos de bits _BitInt seguem uma regra própria. Se o tipo resultante não tiver sinal, a negação é calculada módulo o seu máximo mais um: -1u == UINT_MAX. Em C23, -INT_MIN tem comportamento indefinido porque o simétrico de INT_MIN não cabe em int. INT_MIN, INT_MAX e UINT_MAX vêm de <limits.h>.

qsort, de <stdlib.h>, recebe um apontador para uma função de comparação de tipo int (*)(const void *, const void *). Os argumentos apontam para os elementos comparados; num vetor de int, lê-os através de const int *. A função devolve um valor negativo, zero ou um valor positivo se o primeiro elemento for, respetivamente, menor, igual ou maior do que o segundo. a - b pode causar um transbordo de int, por exemplo com INT_MAX e INT_MIN; usar comparações para devolver -1, 0 ou 1 evita-o. C não garante que qsort seja estável: a ordem dos elementos considerados iguais não é especificada.

A pesquisa devolve um índice não negativo, ou -1 caso não encontre a chave. NULL termina o vetor de apontadores para cadeias de caracteres. Testar i < INT_MAX antes do acesso limita a pesquisa e evita o transbordo do contador de tipo int. O vetor tem de conter um terminador NULL acessível ou pelo menos INT_MAX elementos acessíveis.

Exemplos

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int compare_int(const void *left, const void *right)
{
    const int a = *(const int *)left;
    const int b = *(const int *)right;
    return a < b ? -1 : a > b ? 1 : 0;
}

static int find_token(const char *const tokens[], const char *key)
{
    for (int i = 0; i < INT_MAX && tokens[i] != NULL; ++i) {
        if (strcmp(tokens[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

int main(void)
{
    int values[] = {INT_MAX, 0, INT_MIN};
    const char *const tokens[] = {"red", "blue", NULL};

    printf("extremes: %d\n", compare_int(&values[2], &values[0]));
    qsort(values, sizeof values / sizeof values[0], sizeof values[0],
          compare_int);
    printf("sorted: %d\n",
           values[0] == INT_MIN && values[1] == 0 && values[2] == INT_MAX);
    printf("found: %d\n", find_token(tokens, "blue"));
    printf("missing: %d\n", find_token(tokens, "green"));
    return 0;
}

Resultado

extremes: -1
sorted: 1
found: 1
missing: -1

A comparação dos extremos devolve `-1` sem usar subtração. `sorted: 1` confirma a ordem esperada. `blue` está no índice `1`; como `green` não existe, obtém-se `-1`.

Lições relacionadas

  • C · Lição 88 · Avançado · Versão: 3
  • C · Lição 90 · Avançado · Versão: 3

Fontes