WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C

Funktionszeiger für ein Prädikat: `int (*pred)(const char *)`

Übergib die Auswahlregel für Zeichenketten als Funktionszeiger, damit derselbe Filter Treffer zuerst zählen und anschließend in Eingabereihenfolge sammeln kann.

Version: ISO C23; implementation support may vary

Syntax

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

Lies die Deklaration von pred aus: Die Klammern in (*pred) gruppieren den Namen mit *. int (*pred)(const char *) deklariert einen Zeiger auf eine Funktion mit einem Argument vom Typ const char * und dem Rückgabetyp int. Ohne diese Klammern deklariert int *pred(const char *) eine Funktion, die int * zurückgibt. pred zeigt auf eine Funktion, nicht auf ein Datenobjekt; const qualifiziert die Zeichen, nicht den Zeiger.

Übergib eine kompatible Funktion als starts_with_a oder &starts_with_a; beides ergibt denselben Zeiger. pred(s) und (*pred)(s) rufen dieselbe Funktion auf. Ein Aufruf über einen Nullzeiger oder einen inkompatiblen Funktionszeigertyp hat undefiniertes Verhalten; eine Typumwandlung stellt keine Kompatibilität her. Der Zeichenzeiger allein garantiert keine gültige Zeichenkette: Der Filter verlangt noch gültige, mit \0 abgeschlossene Zeichenketten. Über s dürfen die Zeichen nicht verändert werden. Die Syntax gilt in ISO C23, ist aber älter; die Unterstützung des C23-Modus hängt von der Implementierung ab.

Für den Filter bedeutet 0 verwerfen, jeder andere Wert behalten. Der erste Durchlauf zählt die Treffer, der zweite speichert ihre Zeiger in Eingabereihenfolge. Eingabe und Auswahlregel müssen für jedes Element in beiden Durchläufen dieselbe Entscheidung ergeben. Die Größenprüfungen schützen den Puffer, erkennen aber keine anderen Treffer bei gleicher Anzahl. Das Ergebnis enthält geliehene Zeiger statt Kopien: Der Aufrufer gibt das Ergebnisarray frei, und die Zeichenketten müssen während seiner Nutzung gültig bleiben.

Beispiele

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

Ergebnis

matches: 2
apple
apricot

`starts_with_a` wählt `apple` und `apricot`; die leere Zeichenkette beginnt mit `\0`. Der Status `1` von `filter` bedeutet Erfolg, auch ohne Treffer; `0` bedeutet Fehler. Dieser Status ist vom Prädikatsergebnis zu unterscheiden.

Zugehörige Lektionen

  • C · Lektion 24 · Mittlere Stufe · Version: 3

Quellen