Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C

Declarador de puntero a función y función que devuelve un puntero a función

Lee la declaración desde el nombre para distinguir una variable que guarda un puntero a un comparador de una función que devuelve ese puntero.

Versión: ISO C23; implementation support may vary

Sintaxis

int (*cmp)(const void *, const void *);
int (*get_comparator(const char *))(const void *, const void *);

/* Equivalent declaration of get_comparator using a pointer type alias: */
typedef int (*comparator_fn)(const void *, const void *);
comparator_fn get_comparator(const char *);

En int (*cmp)(const void *, const void *);, empieza por el nombre: (*cmp) indica que cmp es un puntero. La lista de la derecha describe la función apuntada: recibe dos argumentos de tipo const void * y devuelve int. Sin los paréntesis de agrupación, int *cmp(const void *, const void *); declararía una función que devuelve int *, no una variable que guarda un puntero a función.

En int (*get_comparator(const char *))(const void *, const void *);, lee primero get_comparator(const char *): es una función que recibe un const char *. Devuelve un puntero a una función que recibe dos const void * y devuelve int. En C no se puede devolver directamente una función, pero sí un puntero a ella. El typedef mostrado da al tipo de puntero el nombre comparator_fn, así que comparator_fn get_comparator(const char *); declara la misma función. Esta sintaxis es anterior a ISO C23; la compatibilidad con el modo C23 depende de la implementación.

En return descending;, el nombre de la función se convierte en un puntero a ella; return &descending; devuelve el mismo puntero. Si la función de selección puede devolver NULL, comprueba el resultado antes de pasarlo a qsort o de llamar al comparador mediante cmp(a, b) o (*cmp)(a, b). El tipo de la función apuntada debe ser compatible con el tipo de función usado para la llamada. Una conversión explícita del puntero no valida una llamada incompatible: su comportamiento es indefinido.

qsort, declarado en <stdlib.h>, pasa al comparador las direcciones de los elementos del array. Un resultado negativo, cero o positivo indica que el primer elemento va antes que el segundo, es equivalente en el orden de clasificación o va después. Aquí los argumentos const void * apuntan a objetos int cuyo tiempo de vida no ha terminado. Convertirlos a const int * permite leer los valores sin modificarlos. (a > b) - (a < b) da el signo correcto sin el riesgo de desbordamiento con signo que tiene a - b.

Ejemplos

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

static int ascending(const void *lhs, const void *rhs)
{
    int a = *(const int *)lhs;
    int b = *(const int *)rhs;
    return (a > b) - (a < b);
}

static int descending(const void *lhs, const void *rhs)
{
    return ascending(rhs, lhs);
}

static int (*get_comparator(const char *order))(const void *, const void *)
{
    if (strcmp(order, "asc") == 0)
        return ascending;
    if (strcmp(order, "desc") == 0)
        return descending;
    return NULL;
}

int main(void)
{
    int values[] = {4, 1, 3};
    int (*cmp)(const void *, const void *) = get_comparator("desc");
    if (cmp == NULL)
        return EXIT_FAILURE;

    qsort(values, sizeof values / sizeof values[0], sizeof values[0], cmp);
    printf("%d %d %d\n", values[0], values[1], values[2]);
    return 0;
}

Resultado

4 3 1

`get_comparator("desc")` elige `descending`, que invierte el orden al intercambiar los argumentos que pasa a `ascending`. Un nombre desconocido da `NULL`; la comprobación antes de `qsort` cubre ese caso. La salida esperada es `4 3 1`.

Lecciones relacionadas

  • C · Lección 14 · Intermedio · Versión: 3

Fuentes