Methoden simulieren

Teil des Abschnitts Object Oriented Programming der C-Journey von Coddy. Lektion 39 von 61.

Du hast gesehen, wie man einen Funktionszeiger in einer Struktur platziert. Die eigentliche Stärke zeigt sich, wenn du verschiedene Funktionen verschiedenen Instanzen desselben Strukturtyps zuweist. So simulieren wir Methoden mit unterschiedlichem Verhalten.

Betrachte eine Struktur, die eine Aktion mit anpassbarer Logik darstellt:

typedef void (*ActionFunc)(void);

typedef struct {
    const char* name;
    ActionFunc execute;
} Action;

Beim Erstellen von Instanzen verknüpfst du verschiedene Funktionen mit jeder einzelnen:

void say_hello(void) {
    printf("Hello!\n");
}

void say_goodbye(void) {
    printf("Goodbye!\n");
}

int main() {
    Action greet = { "Greet", say_hello };
    Action farewell = { "Farewell", say_goodbye };
    
    greet.execute();    // Ausgabe: Hello!
    farewell.execute(); // Ausgabe: Goodbye!
    return 0;
}

Sowohl greet als auch farewell sind vom selben Typ (Action), doch der Aufruf von execute für beide erzeugt völlig unterschiedliche Ergebnisse. Die Struktur enthält nicht nur Daten. Sie enthält Verhalten, das je nach Instanz variiert.

Dieses Muster spiegelt wider, wie Objekte in anderen Sprachen funktionieren: Jedes Objekt kann seine eigene Implementierung einer Methode haben, obwohl sie dieselbe Schnittstelle gemeinsam nutzen.

Aufgabe

Einfach

Erstelle ein Speaker-System, das veranschaulicht, wie verschiedene Instanzen desselben Strukturtyps völlig unterschiedliche Verhaltensweisen zeigen können, abhängig davon, welche Funktion mit ihnen verknüpft ist.

Du wirst zwei Dateien erstellen, um deinen Code zu organisieren:

speaker.h: Definiere einen Funktionszeigertyp namens SpeakFunc, der keine parameter entgegennimmt und nichts zurückgibt. Definiere anschließend eine Speaker-Struktur, die einen name (einen const char*) und einen speak-Funktionszeiger vom Typ SpeakFunc enthält.
main.c: Binde deine Header-Datei ein und implementiere drei verschiedene Sprechfunktionen:
- bark: gibt Woof! aus
- meow: gibt Meow! aus
- chirp: gibt Chirp! aus
Erstelle anschließend zwei Speaker-Instanzen, die abhängig von der Eingabe jeweils mit einer anderen Funktion verknüpft werden, und rufe ihre speak-Methoden auf, um polymorphes Verhalten in Aktion zu sehen.

Dein Programm erhält zwei Eingaben: den first speaker type (1 für bark, 2 für meow, 3 für chirp) und den second speaker type (ebenfalls 1, 2 oder 3).

Erstelle zwei Speaker-Instanzen. Du kannst sie beliebig benennen (zum Beispiel "Dog", "Cat", "Bird" oder einfach "Speaker1", "Speaker2"). Verknüpfe jede Instanz anhand ihres Eingabecodes mit der passenden Funktion und rufe anschließend speak für jede Instanz der Reihe nach auf.

Beispielausgabe, wenn der erste Typ 1 und der zweite Typ 2 ist:

Woof!
Meow!

Beispielausgabe, wenn der erste Typ 3 und der zweite Typ 3 ist:

Chirp!
Chirp!

Die wichtigste Erkenntnis hierbei ist, dass beide Sprecher denselben Speaker-Typ haben und dennoch unterschiedliche Ausgaben erzeugen, weil jeder über eine andere Funktion verfügt, die seinem speak-Member zugewiesen ist. Denke daran, Include-Guards in deiner Header-Datei zu verwenden.

Probier es selbst

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

// TODO: Implementiere die bark-Funktion, die "Woof!" ausgibt

// TODO: Implementiere die meow-Funktion, die "Meow!" ausgibt

// TODO: Implementiere die chirp-Funktion, die "Chirp!" ausgibt

int main() {
    int type1, type2;
    scanf("%d", &type1);
    scanf("%d", &type2);
    
    // TODO: Erstelle zwei Speaker-Instanzen
    
    // TODO: Verdrahtе die speak-Funktion des ersten Speakers basierend auf type1
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Verdrahtе die speak-Funktion des zweiten Speakers basierend auf type2
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Rufe speak auf jedem Speaker der Reihe nach auf
    
    return 0;
}