Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C

Predicate: pole predikátov v C

Definuj `Predicate` ako alias typu ukazovateľa na funkciu a pomocou poľa takýchto ukazovateľov over, či jedna objednávka spĺňa všetky pravidlá alebo aspoň jedno.

Verzia: ISO C23; implementation support may vary

Syntax

typedef struct Order Order;
typedef int (*Predicate)(const Order *);

/* After declaring two functions with compatible types: */
const Predicate checks[] = {is_large, is_paid};

Predicate je alias typu definovaný programom, nie štandardný názov v C. typedef int (*Predicate)(const Order *); označuje ukazovateľ na funkciu, ktorá prijíma jeden argument typu const Order * a vracia int. Zátvorky okolo *Predicate určujú, že alias označuje typ ukazovateľa. Podľa konvencie znamená 0 nepravdu a každá nenulová hodnota pravdu. Funkcia nemôže cez tento ukazovateľ meniť objednávku, no môže mať iné vedľajšie účinky.

const Predicate checks[] = {is_large, is_paid}; vytvorí pole, ktorého ukazovatele na funkcie nemožno prepísať. Názvy funkcií v inicializátore sa prevedú na ukazovatele. checks[i](order) zavolá predikát na indexe i pre tú istú objednávku. V deklarácii parametra sa const Predicate checks[] upraví na ukazovateľ na prvok, preto počet n odovzdaj samostatne. Výraz sizeof checks / sizeof checks[0] použi tam, kde je checks pole, nie v pomocnej funkcii.

all_match skončí pri prvom nulovom výsledku a any_match pri prvom nenulovom. Obe funkcie prechádzajú pravidlá v poradí poľa, po rozhodnutí zvyšok preskočia a vracajú 0 alebo 1. Pri n == 0 sa žiadny predikát nevolá: all_match vráti 1 a any_match vráti 0. all_of a any_of nie sú funkcie štandardnej knižnice ISO C; príklad definuje vlastné pomocné funkcie.

Pre n > 0 odovzdaj pole aspoň s n prvkami, nenulové ukazovatele na funkcie kompatibilných typov a ukazovateľ na objednávku, ktorej životnosť pokrýva celé volanie. Volanie cez nulový ukazovateľ alebo cez ukazovateľ na funkciu nekompatibilného typu má nedefinované správanie. Tento postup existoval už pred C23; podpora režimu C23 závisí od implementácie.

Príklady

#include <stddef.h>
#include <stdio.h>

typedef struct Order {
    int total;
    int paid;
} Order;

typedef int (*Predicate)(const Order *);

static int is_large(const Order *order)
{
    return order->total >= 100;
}

static int is_paid(const Order *order)
{
    return order->paid;
}

static int all_match(const Predicate checks[], size_t n, const Order *order)
{
    for (size_t i = 0; i < n; ++i) {
        if (!checks[i](order)) {
            return 0;
        }
    }
    return 1;
}

static int any_match(const Predicate checks[], size_t n, const Order *order)
{
    for (size_t i = 0; i < n; ++i) {
        if (checks[i](order)) {
            return 1;
        }
    }
    return 0;
}

int main(void)
{
    const Order order = {40, 2};
    const Predicate checks[] = {is_large, is_paid};
    const size_t n = sizeof checks / sizeof checks[0];

    const int all = all_match(checks, n, &order);
    const int any = any_match(checks, n, &order);
    printf("mixed: all=%d any=%d\n", all, any);
    printf("empty: all=%d any=%d\n",
           all_match(NULL, 0, &order), any_match(NULL, 0, &order));
    return 0;
}

Výsledok

mixed: all=0 any=1
empty: all=1 any=0

Pre `{40, 2}` sa `all_match` zastaví, pretože `is_large` vráti nulu. `any_match` pokračuje funkciou `is_paid` a výsledok `2` vyhodnotí ako pravdu. Volania s `NULL` a počtom `0` z poľa nečítajú.

Súvisiace lekcie

  • C · Lekcia 56 · Stredne pokročilá · Verzia: 3

Zdroje