Bonjour,

Oui c'est possible ...

tableau = {a,b,c,d,e}

Pour i = 0 allant jusqu'à 4
afficher tableau[i];
fin pour

;o)

Bonjour,
cela est bel et bien possible voici un exemple qui initialise les les valeurs d'unt tableau à 1:
int test(int n){
int tab[n];//un tableau de n entiers.
int i;
for(i=0;i<n;i++){
tab[i]=1;
}
}
int main(){
test(int);//prototype de fonction
test(10);//test sur 10 entiers
return 0;
}
Bon courage!

Bonjour,

ce n'est pas exactement ce que je demandais, mais merci quand même.

Ma question était plus du genre :

pour éviter d'écrire en dure une série d'opération :

actionA->doSomething();
actionB->doSomething();
actionC->doSomething();
actionD->doSomething();
actionE->doSomething();

tableau = {A,B,C,D,E}
pour G in tableau

actionG->doSomething();

finpour

On peut imaginer que la fonction qui prend en paramètre le tableau fasse un switch en fonction de son contenu.

#include <vector>
#include <iostream>

void a(){ std::cout << 'a' << std::endl;}
void b(){ std::cout << 'b' << std::endl;}
void c(){ std::cout << 'c' << std::endl;}
void unk(){ std::cout << "???" << std::endl;}

void do_actions(const std::vector<char> & actions){
    const std::size_t n = actions.size();
    for(std::size_t i=0;i<n;++i){
        switch(actions[i]){
            case 'a': a(); break;
            case 'b': b(); break;
            case 'c': c(); break;
            default: unk();break;
        }
    }
}

int main(){
    std::vector<char> actions;
    actions.push_back('b');
    actions.push_back('a');
    actions.push_back('b');
    actions.push_back('c');
    do_actions(actions);
    return 0;
}

b
a
b
c

Bonjour,

Ou plus "simplement":
(en tout cas cela retire le switch)

#include <iostream>

typedef void funct_t();

void a(){ std::cout << 'a' << std::endl;}
void b(){ std::cout << 'b' << std::endl;}
void c(){ std::cout << 'c' << std::endl;}


void do_actions( funct_t **tableau, unsigned int uNbElements )
{
    for ( unsigned int u = 0 ; u != uNbElements ; u++ )
        tableau[u]();
}

int main()
{
    funct_t *tableau[] = { b, a, b, c };
    
    do_actions( tableau, 4 );

    return 0;
}

Ta méthode marche et compile, mais à condition que tes fonctions aient toutes le même prototype ;-)

Oui, en effet.

On peut s'arranger avec un void * comme paramètre pour passer une structure contenant des paramètres spécifiques pour chaque fonction. Peut être que "..." et leurs var args marchent aussi mais je n'ai jamais eu l'occasion d'essayer, je ne vois pas trop ce qui empêcherait... (Je suis toujours passé par le paramètre en void * pour ma part)

Le problème ici c'est qu'on risque de remettre un switch à moins de faire à côté du tableau des fonctions, un tableau de leurs paramètres. On pourrait d'ailleurs regrouper la fonction et ses paramètres dans une même structure. (Une classe à la C donc)

M.

Oui le void * c'est une solution pour le passage de paramètre. Par contre je ne vois pas trop pourquoi c'est un problème de mettre un switch, d'autant plus qu'on peut avoir envie pour deux valeurs différentes dans le tableau d'appeler une même fonction avec des paramètres différents. On peut certes s'en sortir avec ta méthode mais ça nécessite de passer par une fonction intermédiaire.

En effet pour appeler une fonction deux fois avec des paramètres différents il faut non plus faire un tableau de fonctions mais de la structure que je suggérais à la fin: struct { fonction, ses paramètres }. Après on se la joue propre ou non. A savoir directement les paramètres après la fonction ou alors un void * vers une structure contenant les paramètres. Je ferais la méthode "sale" avec les paramètres directement.

Là où j'ai tendance à bouder le switch pour le coup (à part le fait qu'il soit un poil plus lent mais c'est pas primordial ici) c'est qu'il n'est pas évolutif. Avec mon tableau je ne touche plus à la fonction d'exécution, juste au tableau. C'est surtout cela qui m'intéresse. Ensuite pour peu qu'on rende le tableau dynamique, on peut rajouter des actions à la liste dynamiquement. (voire un système de plugin avec des fonctions ajoutées par l'utilisateur) Je ne connais pas le contexte d'utilisation ici. Point de vue moins important, on n'a pas non plus besoin de nommer deux opérations différentes pour appeler une fonction avec des paramètres différents.

Pour moi le switch est intéressant pour faire des fonctions de dispatch qui auraient un nombre d'éléments figés, ici je ne lui trouve pas d'avantage, on ne dispatch pas on parcours tous les cas.

Je ferais un petit code d'illustration ce soir.

M.


EDIT.
Ah si, un bon point pour le switch: Il prend moins de mémoire (au sens "exécutable moins volumineux") qu'un tableau d'indirection.