Polymorphismus (in C) [duplicate]

Mögliches Duplikat:

Wie kann ich Polymorphismus im OO-Stil in C simulieren?

Ich versuche, die Idee des Polymorphismus mit Beispielen aus Sprachen, die ich kenne, besser zu verstehen. Gibt es Polymorphismus in C?

Dies ist Nekuromentos zweites Beispiel, das so berücksichtigt wird, wie ich es für objektorientiertes C als idiomatisch betrachte:

tier.h

#ifndef ANIMAL_H_
#define ANIMAL_H_

struct animal
{
    // make vtable_ a pointer so they can be shared between instances
    // use _ to mark private members
    const struct animal_vtable_ *vtable_;
    const char *name;
};

struct animal_vtable_
{
    const char *(*sound)(void);
};

// wrapper function
static inline const char *animal_sound(struct animal *animal)
{
    return animal->vtable_->sound();
}

// make the vtables arrays so they can be used as pointers
extern const struct animal_vtable_ CAT[], DOG[];

#endif

Kat.c

#include "animal.h"

static const char *sound(void)
{
    return "meow!";
}

const struct animal_vtable_ CAT[] = { { sound } };

Hund.c

#include "animal.h"

static const char *sound(void)
{
    return "arf!";
}

const struct animal_vtable_ DOG[] = { { sound } };

Haupt c

#include "animal.h"
#include <stdio.h>

int main(void)
{
    struct animal kitty = { CAT, "Kitty" };
    struct animal lassie = { DOG, "Lassie" };

    printf("%s says %s\n", kitty.name, animal_sound(&kitty));
    printf("%s says %s\n", lassie.name, animal_sound(&lassie));

    return 0;
}

Dies ist ein Beispiel für Laufzeitpolymorphismus, da zu diesem Zeitpunkt die Methodenauflösung erfolgt.

C1x fügte generische Auswahlen hinzu, die Polymorphismus zur Kompilierzeit über Makros ermöglichen. Das folgende Beispiel stammt aus dem C1x-April-Entwurf, Abschnitt 6.5.1.1 §5:

#define cbrt(X) _Generic((X), \
    long double: cbrtl, \
    default: cbrt, \
    float: cbrtf \
)(X)

Typgenerische Makros für mathematische Funktionen waren bereits in C99 über den Header verfügbar tgmath.haber es gab keine Möglichkeit für Benutzer, ihre eigenen Makros zu definieren, ohne Compiler-Erweiterungen zu verwenden.

Fast alle Implementierungen des Laufzeitpolymorphismus in C verwenden Funktionszeiger, also ist dies der Grundbaustein.

Hier ist ein einfaches Beispiel, wenn sich das Laufzeitverhalten einer Prozedur abhängig von ihrem Argument ändert.

#include <stdio.h>

int tripple(int a) {
    return 3 * a;
}

int square(int a) {
    return a * a;
}

void transform(int array[], size_t len, int (*fun)(int)) {
    size_t i = 0;
    for(; i < len; ++i)
        array[i] = fun(array[i]);
}

int main() {
    int array[3] = {1, 2, 3};
    transform(array, 3, &tripple);
    transform(array, 3, &square);

    size_t i = 0;
    for (; i < 3; ++i)
        printf("%d ", array[i]);

    return 0;
}

Mit Funktionszeigern können Sie erstellen Virtuelle Tische und verwenden Sie es, um “Objekte” zu erstellen, die einheitlich behandelt werden, sich aber zur Laufzeit unterschiedlich verhalten.

#include <stdio.h>

struct animal_vtable {
    const char* (*sound)();
};

struct animal {
    struct animal_vtable methods;
    const char* name;
};

const char* cat_sound() {
    return "meow!";
}

const char* dog_sound() {
    return "bark!";
}

void describe(struct animal *a) {
    printf("%s makes \"%s\" sound.\n", a->name, a->methods.sound());
}

struct animal cat = {{&cat_sound}, "cat"};
struct animal dog = {{&dog_sound}, "dog"};

int main() {
    describe(&cat);
    describe(&dog);

    return 0;
}

Es gibt keine intrinsische Unterstützung für Polymorphismus in C, aber es gibt Entwurfsmuster, die Funktionszeiger, Umwandlungen von Basisklassen (Strukturen) usw. verwenden, die ein logisches Äquivalent zum dynamischen Dispatch bieten können. Das GTK-Bibliothek ist gutes Beispiel.

Ich denke, Sie haben bereits den Wikipedia-Artikel überprüft Polymorphismus.

In der Informatik ist Polymorphismus ein Merkmal einer Programmiersprache, das es ermöglicht, Werte unterschiedlicher Datentypen über eine einheitliche Oberfläche zu behandeln.

Gemäß dieser Definition unterstützt C nativ keinen Polymorphismus. Beispielsweise gibt es keine allgemeine Funktion zum Ermitteln des Absolutwerts einer Zahl (abs und fabs sind für ganze Zahlen bzw. Doubles).

Wenn Sie auch mit C++ vertraut sind, werfen Sie einen Blick auf OOP-Vererbung und Vorlagen – das sind dort Mechanismen für Polymorphie.