Simulation de méthodes

Fait partie de la section Object Oriented Programming du Journey C de Coddy. Leçon 39 sur 61.

Vous avez vu comment placer un pointeur de fonction dans une structure. Le véritable pouvoir apparaît lorsque vous affectez des fonctions différentes à différentes instances du même type de structure. C’est ainsi que nous simulons des méthodes au comportement variable.

Considérez une structure qui représente une action avec une logique personnalisable :

typedef void (*ActionFunc)(void);

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

Lors de la création d’instances, vous reliez différentes fonctions à chacune d’elles :

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();    // Sortie : Hello!
    farewell.execute(); // Sortie : Goodbye!
    return 0;
}

greet et farewell sont du même type (Action), pourtant appeler execute sur chacun produit des résultats complètement différents. La structure ne contient pas seulement des données. Elle contient un comportement qui varie selon l’instance.

Ce modèle reflète le fonctionnement des objets dans d’autres langages : chaque objet peut avoir sa propre implémentation d’une méthode, même s’ils partagent la même interface.

Défi

Facile

Construisons un système Speaker qui montre comment différentes instances du même type de structure peuvent présenter des comportements complètement différents selon la fonction qui leur est associée.

Vous allez créer deux fichiers pour organiser votre code :

speaker.h : définissez un type de pointeur de fonction appelé SpeakFunc qui ne prend aucun parameters et ne returns rien. Définissez ensuite une structure Speaker contenant un name (un const char*) et un pointeur de fonction speak de type SpeakFunc.
main.c : incluez votre en-tête et implémentez trois fonctions speaking différentes :
- bark : prints Woof!
- meow : prints Meow!
- chirp : prints Chirp!
Créez ensuite deux instances de Speaker, chacune associée à une fonction différente en fonction de l'entrée, et appelez leurs méthodes speak pour observer le comportement polymorphe en action.

Votre programme recevra deux entrées : le first speaker type (1 pour bark, 2 pour meow, 3 pour chirp) et le second speaker type (également 1, 2 ou 3).

Créez deux instances de Speaker. Vous pouvez les nommer comme vous le souhaitez (par exemple "Dog", "Cat", "Bird", ou simplement "Speaker1", "Speaker2"). Associez chacune à la fonction appropriée en fonction de son code d'entrée, puis appelez speak sur chaque instance dans l'ordre.

Exemple de sortie lorsque le premier type est 1 et le second type est 2 :

Woof!
Meow!

Exemple de sortie lorsque le premier type est 3 et le second type est 3 :

Chirp!
Chirp!

L'idée essentielle est que les deux speakers sont du même type Speaker, et produisent pourtant des sorties différentes, car chacun possède une fonction différente affectée à son membre speak. N'oubliez pas d'utiliser des include guards dans votre fichier d'en-tête.

Essayez vous-même

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

// TODO: Implémenter la fonction bark qui affiche "Woof!"

// TODO: Implémenter la fonction meow qui affiche "Meow!"

// TODO: Implémenter la fonction chirp qui affiche "Chirp!"

int main() {
    int type1, type2;
    scanf("%d", &type1);
    scanf("%d", &type2);
    
    // TODO: Créer deux instances de Speaker
    
    // TODO: Connecter la fonction speak du premier speaker en fonction de type1
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Connecter la fonction speak du second speaker en fonction de type2
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Appeler speak sur chaque speaker dans l'ordre
    
    return 0;
}