Simulation de méthodes

Fait partie de la section Programmation Orientée Objet du Journey C de Coddy. Leçon 39 sur 61.

Tu as vu comment placer un pointeur de fonction dans une structure. La véritable puissance apparaît lorsque tu affectes des fonctions différentes à différentes instances du même type de structure. C’est ainsi que nous simulons des méthodes aux comportements variés.

Considère 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 des instances, tu relies 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 d’un même type de structure peuvent avoir des comportements complètement différents selon la fonction qui leur est associée.

Tu vas créer deux fichiers pour organiser ton code :

speaker.h : définis un type de pointeur de fonction appelé SpeakFunc qui ne prend aucun paramètre et ne renvoie rien. Définis ensuite une structure Speaker contenant un name (un const char*) et un pointeur de fonction speak de type SpeakFunc.
main.c : inclus ton fichier d’en-tête et implémente trois fonctions différentes pour faire parler :
- bark : affiche Woof!
- meow : affiche Meow!
- chirp : affiche Chirp!
Crée ensuite deux instances de Speaker, chacune associée à une fonction différente en fonction de l’entrée, puis appelle leurs méthodes speak pour observer le polymorphisme en action.

Ton programme recevra deux entrées : le type du premier haut-parleur (1 pour bark, 2 pour meow, 3 pour chirp) et le type du second haut-parleur (également 1, 2 ou 3).

Crée deux instances de Speaker. Tu peux les nommer comme tu le souhaites (par exemple, "Dog", "Cat", "Bird", ou simplement "Speaker1", "Speaker2"). Associe chacune à la fonction appropriée selon son code d’entrée, puis appelle 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 haut-parleurs sont du même type Speaker, mais qu’ils produisent des sorties différentes, car chacun a une fonction différente affectée à son membre speak. N’oublie pas d’utiliser des gardes d’inclusion dans ton 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: Associer la fonction speak du premier haut-parleur en fonction de type1
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Associer la fonction speak du deuxième haut-parleur en fonction de type2
    // (1 = bark, 2 = meow, 3 = chirp)
    
    // TODO: Appeler speak sur chaque haut-parleur dans l’ordre
    
    return 0;
}