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 mit jeder davon eine andere Funktion:

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 haben denselben Typ (Action), doch der Aufruf von execute bei jedem von ihnen führt zu völlig unterschiedlichen Ergebnissen. Die Struktur enthält nicht nur Daten. Sie enthält ein Verhalten, das je nach Instanz variiert.

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

Aufgabe

Einfach

Lass uns ein Speaker-System erstellen, das zeigt, wie verschiedene Instanzen desselben Strukturtyps völlig unterschiedliches Verhalten zeigen können, je nachdem, welche Funktion ihnen zugewiesen ist.

Du erstellst zwei Dateien, 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 mit einem name (einem const char*) und einem Funktionszeiger speak vom Typ SpeakFunc.
main.c: Binde deine Headerdatei ein und implementiere drei verschiedene Sprechfunktionen:
- bark: gibt Woof! aus
- meow: gibt Meow! aus
- chirp: gibt Chirp! aus
Erstelle dann zwei Speaker-Instanzen, weise jeder abhängig von der Eingabe eine andere Funktion zu und rufe ihre speak-Methoden auf, um Polymorphie in Aktion zu erleben.

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

Erstelle zwei Speaker-Instanzen. Du kannst sie beliebig benennen (zum Beispiel „Dog“, „Cat“, „Bird“ oder einfach „Speaker1“, „Speaker2“). Weise jeder Instanz anhand ihres Eingabecodes die passende Funktion zu und rufe dann 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 entscheidende Erkenntnis ist, dass beide Sprecher denselben Typ Speaker haben, aber dennoch unterschiedliche Ausgaben erzeugen, weil jeder eine andere Funktion seinem Element speak zugewiesen hat. Denk daran, Include-Guards in deiner Headerdatei zu verwenden.

Probier es selbst

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

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

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

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

int main() {
    int type1, type2;
    scanf("%d", &type1);
    scanf("%d", &type2);
    
    // TODO: Erstelle zwei Instanzen von Speaker
    
    // TODO: Weise der Funktion speak des ersten Speaker anhand von type1 die passende Funktion zu
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Weise der Funktion speak des zweiten Speaker anhand von type2 die passende Funktion zu
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Rufe speak für jeden Speaker der Reihe nach auf
    
    return 0;
}