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

CKTIS / C

Puntero a función predicado `int (*pred)(const char *)`

Pasa la regla de selección de cadenas como puntero a función para que el mismo filtro pueda contar primero las coincidencias y después reunirlas en el orden de entrada.

Versión: ISO C23; implementation support may vary

Sintaxis

/* In a function body, with starts_with_a declared and s pointing to a valid C string: */
int (*pred)(const char *) = starts_with_a;
int result = pred(s);

Empieza por pred: los paréntesis de (*pred) agrupan el nombre con *. int (*pred)(const char *) declara un puntero a una función que recibe un argumento de tipo const char * y devuelve un int. Sin esos paréntesis, int *pred(const char *) declara una función que devuelve int *. pred apunta a una función, no a un objeto de datos; const califica los caracteres, no el puntero.

Pasa una función compatible como starts_with_a o &starts_with_a; ambas formas dan el mismo puntero. pred(s) y (*pred)(s) llaman a la misma función. Una llamada mediante un puntero nulo o un tipo de puntero a función incompatible tiene comportamiento indefinido; una conversión explícita no hace compatibles los tipos. El puntero a caracteres no garantiza una cadena válida: el filtro requiere cadenas vigentes terminadas en \0, cuyos caracteres no se pueden modificar a través de s. Esta sintaxis es válida en ISO C23, pero es anterior; la disponibilidad del modo C23 depende de la implementación.

El filtro interpreta 0 como descartar y cualquier valor distinto de cero como conservar. La primera pasada cuenta coincidencias; la segunda guarda sus punteros en el orden de entrada. Los datos y la regla deben dar la misma decisión para cada elemento en ambas pasadas. Las comprobaciones de tamaño protegen el búfer, pero no detectan coincidencias distintas en igual número. El resultado toma prestados los punteros sin copiar las cadenas: quien llama libera el array de resultados y mantiene vivas las cadenas mientras lo usa.

Ejemplos

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

static int starts_with_a(const char *s)
{
    return s[0] == 'a';
}

/* Requires live C strings and a predicate with stable decisions. */
static int filter(const char *const items[], size_t n,
                  int (*pred)(const char *),
                  const char ***out, size_t *out_count)
{
    *out = NULL;
    *out_count = 0;
    if (pred == NULL)
        return 0;

    size_t count = 0;
    for (size_t i = 0; i < n; ++i)
        if (pred(items[i]))
            ++count;
    if (count == 0)
        return 1;

    const char **matches;
    if (count > SIZE_MAX / sizeof *matches)
        return 0;
    matches = malloc(count * sizeof *matches);
    if (matches == NULL)
        return 0;

    size_t used = 0;
    for (size_t i = 0; i < n; ++i) {
        if (pred(items[i])) {
            if (used == count) {
                free(matches);
                return 0;
            }
            matches[used++] = items[i];
        }
    }
    if (used != count) {
        free(matches);
        return 0;
    }
    *out = matches;
    *out_count = used;
    return 1;
}

int main(void)
{
    const char *const items[] = {"apple", "pear", "", "apricot"};
    const char **matches;
    size_t count;
    if (!filter(items, sizeof items / sizeof items[0],
                starts_with_a, &matches, &count)) {
        fputs("filter failed\n", stderr);
        return EXIT_FAILURE;
    }
    printf("matches: %zu\n", count);
    for (size_t i = 0; i < count; ++i)
        puts(matches[i]);
    free(matches);
    return EXIT_SUCCESS;
}

Resultado

matches: 2
apple
apricot

`starts_with_a` selecciona `apple` y `apricot`; la cadena vacía empieza por `\0`. El estado `1` de `filter` indica éxito, incluso sin coincidencias; `0` indica fallo. Ese estado es independiente del resultado del predicado.

Lecciones relacionadas

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

Fuentes