Salut

J'ai continué à chercher pour pouvoir mettre en place ce que j'aurais voulu faire.

J'utilise une classe "statique", donc ça simplifie la mise en place, je donne cet exemple,

ça aidera peut-être quelqu'un :

#include <iostream>

enum TYPE { HELLO, SALUT, HOLA };

// displayPtr devient un type de pointeur sur fonctions
typedef void (*displayPtr)(void);

class Test
{

public :
    
    // On crée un pointeur de fonctions de ce type
    static displayPtr  display;
    
    // On change l'adresse de la fonction
    static void setType(const TYPE type)
    {
        switch(type)
        {
            case(HELLO) :
            {
                display = &displayHello;

                break;
            }

            case(SALUT) :
            {
                display = &displaySalut;

                break;
            }

            case(HOLA) :
            {
                display = &displayHola;

                break;
            }

            default :
            {
                break;
            }
        }
    }

private :

    static void displayHello(void)
    {
        std::cout<<"Hello"<<std::endl;
    }

    static void displaySalut(void)
    {
        std::cout<<"Salut"<<std::endl;
    }

    static void displayHola(void)
    {
        std::cout<<"Hola"<<std::endl;
    }
};

// Initialise les variables statiques
displayPtr Test::display = 0;

int main(void)
{
    // On ne peut pas faire ça car la fonction ne pointe sur rien ( 0 )
    // Test::display(); // segmentation fault
    
    // Il faut donc donner une adresse valide au pointeur de fonctions
    Test::setType(HELLO);

    Test::display();

    Test::setType(SALUT);

    Test::display();

    Test::setType(HOLA);

    Test::display();
    
    return 0;
}

C'est vrai que c'est puissant.

Voici deux liens qui m'ont aidé, sans oublier l'explication précédente de tmyke

The Function Pointer Tutorials

Pointers to C++ Member Functions

J'ai par contre encore du mal à comprendre le principe de "CallBack" mais ça viendra lol.

A plus !

Salut

J'ai continué à chercher pour pouvoir mettre en place ce que j'aurais voulu faire.

J'utilise une classe "statique", donc ça simplifie la mise en place, je donne cet exemple,

ça aidera peut-être quelqu'un :

#include <iostream>

enum TYPE { HELLO, SALUT, HOLA };

// displayPtr devient un type de pointeur sur fonctions
typedef void (*displayPtr)(void);

class Test
{

public :
    
    // On crée un pointeur de fonctions de ce type
    static displayPtr  display;
    
    // On change l'adresse de la fonction
    static void setType(const TYPE type)
    {
        switch(type)
        {
            case(HELLO) :
            {
                display = &displayHello;

                break;
            }

            case(SALUT) :
            {
                display = &displaySalut;

                break;
            }

            case(HOLA) :
            {
                display = &displayHola;

                break;
            }

            default :
            {
                break;
            }
        }
    }

private :

    static void displayHello(void)
    {
        std::cout<<"Hello"<<std::endl;
    }

    static void displaySalut(void)
    {
        std::cout<<"Salut"<<std::endl;
    }

    static void displayHola(void)
    {
        std::cout<<"Hola"<<std::endl;
    }
};

// Initialise les variables statiques
displayPtr Test::display = 0;

int main(void)
{
    // On ne peut pas faire ça car la fonction ne pointe sur rien ( 0 )
    // Test::display(); // segmentation fault
    
    // Il faut donc donner une adresse valide au pointeur de fonctions
    Test::setType(HELLO);

    Test::display();

    Test::setType(SALUT);

    Test::display();

    Test::setType(HOLA);

    Test::display();
    
    return 0;
}

C'est vrai que c'est puissant.

Voici deux liens qui m'ont aidé, sans oublier l'explication précédente de tmyke

The Function Pointer Tutorials

Pointers to C++ Member Functions

J'ai par contre encore du mal à comprendre le principe de "CallBack" mais ça viendra lol.

A plus !