Methoden simulieren

Teil des Abschnitts Objektorientierte Programmierung 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 unterschiedliches Verhalten zeigen können, abhängig davon, welche Funktion mit ihnen verbunden ist.

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

speaker.h: Definiere einen Funktionszeigertyp namens SpeakFunc, der keine Parameter übernimmt und nichts zurückgibt. Definiere anschließend eine Speaker-Struktur, die einen name (einen const char*) und einen Funktionszeiger speak 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 jeweils abhängig von der Eingabe mit einer anderen Funktion verbunden werden, und rufe ihre speak-Methoden auf, um Polymorphismus in Aktion zu sehen.

Dein Programm erhält zwei Eingaben: den Typ des ersten Speakers (1 für bark, 2 für meow, 3 für chirp) und den Typ des zweiten Speakers (ebenfalls 1, 2 oder 3).

Erstelle zwei Speaker-Instanzen. Du kannst sie beliebig benennen (zum Beispiel "Dog", "Cat", "Bird" oder einfach "Speaker1", "Speaker2"). Verbinde jede Instanz anhand ihres Eingabecodes mit der passenden Funktion und rufe anschließend bei jeder Instanz der Reihe nach speak 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 zentrale Erkenntnis ist, dass beide Speaker vom selben Speaker-Typ sind und dennoch unterschiedliche Ausgaben erzeugen, weil jedem ihr speak-Member eine andere Funktion 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;
}