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

CKTIS / C

Predicate: arrays de predicados en C

Define `Predicate` como alias de un tipo de puntero a función y usa un array de estos punteros para comprobar si un pedido cumple todas las reglas o al menos una.

Versión: ISO C23; implementation support may vary

Sintaxis

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

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

Predicate es un alias de tipo definido por el programa, no un nombre estándar de C. typedef int (*Predicate)(const Order *); designa un puntero a una función que recibe un argumento de tipo const Order * y devuelve un int. Los paréntesis alrededor de *Predicate hacen que el alias sea de un tipo de puntero. Por convenio, 0 significa falso y cualquier valor distinto de cero significa verdadero. La función no puede modificar el pedido a través de ese puntero, pero puede tener otros efectos secundarios.

const Predicate checks[] = {is_large, is_paid}; crea un array cuyos punteros a función no se pueden reasignar. Los nombres de función del inicializador se convierten en punteros. checks[i](order) llama al predicado del índice i para el mismo pedido. Como parámetro, const Predicate checks[] se ajusta a un puntero a un elemento, así que pasa el número n por separado. Calcula sizeof checks / sizeof checks[0] donde checks es un array, no dentro de la función auxiliar.

all_match se detiene con el primer resultado cero y any_match con el primero distinto de cero. Ambas funciones recorren las reglas en el orden del array, omiten las restantes cuando conocen el resultado y devuelven 0 o 1. Si n == 0, no se llama a ningún predicado: all_match devuelve 1 y any_match devuelve 0. all_of y any_of no son funciones de la biblioteca de ISO C; el ejemplo define sus propias funciones auxiliares.

Para n > 0, pasa un array con al menos n elementos, punteros no nulos a funciones de tipo compatible y un puntero a un pedido que siga existiendo durante toda la llamada. Llamar mediante un puntero nulo o un puntero a una función de tipo incompatible provoca comportamiento indefinido. Esta técnica es anterior a C23; la compatibilidad con el modo C23 depende de la implementación.

Ejemplos

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

Resultado

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

Para `{40, 2}`, `all_match` se detiene al fallar `is_large`. `any_match` continúa con `is_paid` y considera verdadero su resultado `2`. Las llamadas con `NULL` y un número de elementos de `0` no leen el array.

Lecciones relacionadas

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

Fuentes