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

CKTIS / C

Ponteiro para função predicado `int (*pred)(const char *)`

Passe a regra de seleção de cadeias como ponteiro para função, para que o mesmo filtro possa primeiro contar as correspondências e depois recolhê-las pela ordem de entrada.

Versão: ISO C23; implementation support may vary

Sintaxe

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

Comece por pred: os parênteses em (*pred) agrupam o nome com *. int (*pred)(const char *) declara um ponteiro para uma função que recebe um argumento do tipo const char * e devolve um int. Sem esses parênteses, int *pred(const char *) declara uma função que devolve um int *. pred aponta para uma função, não para um objeto de dados; const qualifica os caracteres, não o ponteiro.

Passe uma função compatível como starts_with_a ou &starts_with_a; ambas as formas dão o mesmo ponteiro. pred(s) e (*pred)(s) chamam a mesma função. Uma chamada através de um ponteiro nulo ou de um tipo incompatível de ponteiro para função tem comportamento indefinido; uma conversão explícita não torna os tipos compatíveis. O ponteiro para caracteres não garante uma cadeia válida: o filtro exige cadeias ainda válidas, terminadas em \0, cujos caracteres não podem ser alterados através de s. A sintaxe é válida em ISO C23, mas é anterior a essa revisão; o suporte do modo C23 depende da implementação.

O filtro interpreta 0 como rejeitar e qualquer valor diferente de zero como manter. A primeira passagem conta as correspondências; a segunda guarda os respetivos ponteiros pela ordem de entrada. Os dados e a regra devem dar a mesma decisão para cada elemento em ambas as passagens. As verificações de tamanho protegem o buffer, mas não detetam correspondências diferentes em igual número. O resultado usa ponteiros emprestados sem copiar as cadeias: quem chama liberta o vetor de resultados e mantém as cadeias válidas enquanto o utiliza.

Exemplos

#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` seleciona `apple` e `apricot`; a cadeia vazia começa por `\0`. O estado `1` de `filter` indica sucesso, mesmo sem correspondências; `0` indica falha. Este estado é distinto do resultado do predicado.

Lições relacionadas

  • C · Lição 24 · Intermédio · Versão: 3

Fontes