Simulation de méthodes

Fait partie de la section Programmation Orientée Objet 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 d’un 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 paramètre et ne renvoie 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 fichier d’en-tête et implémentez trois fonctions de communication différentes :
- bark : affiche Woof!
- meow : affiche Meow!
- chirp : affiche Chirp!
Créez ensuite deux instances de Speaker, chacune associée à une fonction différente en fonction de l’entrée, puis appelez leurs méthodes speak pour observer le polymorphisme en action.

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

Créez deux instances de Speaker. Vous pouvez leur donner les noms de votre choix (comme "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 locuteurs 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 gardes d’inclusion 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;
}