Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Puntatore a funzione predicato `int (*pred)(const char *)`

Passa la regola di selezione delle stringhe come puntatore a funzione, così lo stesso filtro può prima contare le corrispondenze e poi raccoglierle nell’ordine di ingresso.

Versione: ISO C23; implementation support may vary

Sintassi

/* 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);

Parti da pred: le parentesi di (*pred) raggruppano il nome con *. int (*pred)(const char *) dichiara un puntatore a una funzione che accetta un argomento di tipo const char * e restituisce un int. Senza quelle parentesi, int *pred(const char *) dichiara una funzione che restituisce un int *. pred punta a una funzione, non a un oggetto dati; const qualifica i caratteri, non il puntatore.

Passa una funzione compatibile come starts_with_a o &starts_with_a: entrambe le forme danno lo stesso puntatore. pred(s) e (*pred)(s) chiamano la stessa funzione. Chiamare tramite un puntatore nullo o un tipo di puntatore a funzione incompatibile ha comportamento indefinito; una conversione esplicita non rende compatibili i tipi. Il puntatore a caratteri non garantisce una stringa valida: il filtro richiede stringhe ancora in vita, terminate da \0, i cui caratteri non si possono modificare tramite s. La sintassi è valida in ISO C23 ma è precedente; il supporto della modalità C23 dipende dall’implementazione.

Il filtro interpreta 0 come scarta e ogni valore diverso da zero come conserva. Il primo passaggio conta le corrispondenze; il secondo ne salva i puntatori nell’ordine di ingresso. I dati e la regola devono dare la stessa decisione per ogni elemento in entrambi i passaggi. I controlli delle dimensioni proteggono il buffer ma non rilevano corrispondenze diverse in pari numero. Il risultato prende in prestito i puntatori senza copiare le stringhe: il chiamante libera l’array risultante e mantiene in vita le stringhe mentre lo usa.

Esempi

#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;
}

Risultato

matches: 2
apple
apricot

`starts_with_a` seleziona `apple` e `apricot`; la stringa vuota inizia con `\0`. Lo stato `1` di `filter` indica successo, anche senza corrispondenze; `0` indica errore. Lo stato è distinto dal risultato del predicato.

Lezioni correlate

  • C · Lezione 24 · Intermedio · Versione: 3

Fonti