CKTIS / C
Menos unario en C
El menos unario calcula el opuesto de un operando aritmético tras las promociones enteras. Si el tipo resultante es sin signo, se usa aritmética modular. Si es un tipo entero con signo, que el opuesto sea representable depende del valor del operando y del rango de ese tipo.
Versión: ISO C23; implementation support may vary
Sintaxis
-operand
-(expression)-x usa el menos unario, un operador prefijo con un solo operando aritmético. No modifica x. En cambio, a - b resta un operando de otro. En -1, - es un operador aplicado a la constante entera 1, no parte de ella.
Se aplican las promociones enteras y el resultado tiene el tipo obtenido tras la promoción. unsigned char se promociona a int si int puede representar todos sus valores; de lo contrario, a unsigned int. Los valores ordinarios de tipo _BitInt quedan exentos de estas promociones; los campos de bits _BitInt tienen una regla propia. Si el tipo resultante es sin signo, la negación se calcula módulo su máximo más uno: -1u == UINT_MAX. En C23, -INT_MIN tiene comportamiento indefinido porque el opuesto de INT_MIN no cabe en int. INT_MIN, INT_MAX y UINT_MAX proceden de <limits.h>.
qsort, de <stdlib.h>, recibe un puntero a una función de comparación de tipo int (*)(const void *, const void *). Sus argumentos apuntan a los elementos comparados; para un array de int, se leen mediante const int *. Devuelve un valor negativo, cero o un valor positivo si el primer elemento es menor, igual o mayor que el segundo, respectivamente. a - b puede desbordar int, por ejemplo con INT_MAX e INT_MIN; usar comparaciones que devuelvan -1, 0 o 1 evita el desbordamiento. C no garantiza que qsort sea estable: el orden de los elementos que se comparan como iguales no está especificado.
La búsqueda devuelve un índice no negativo, o -1 si no encuentra la clave. NULL marca el final del array de punteros a cadenas. Comprobar i < INT_MAX antes del acceso acota la búsqueda y evita desbordar el contador de tipo int. El array debe contener un terminador NULL accesible o al menos INT_MAX entradas accesibles.
Ejemplos
#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
Comparar los extremos devuelve `-1` sin restar. `sorted: 1` confirma el orden esperado. `blue` está en el índice `1`; como `green` no aparece, se obtiene `-1`.
Lecciones relacionadas
- C · Lección 88 · Avanzado · Versión: 3
- C · Lección 90 · Avanzado · Versión: 3