C/C++ boucle for Fermé

Question

Bonjour,

est-il possible de parcourir à l'aide d'une boucle for les élements d'un tableau?
Un truc du genre

tableau = {a,b,c,d,e}

Pour i in tableau
   faire 
           ....
   fin faire
fin pour

ray_fab · Accepted Answer

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!

Polux31 · Answer

bonjour,

Oui c'est possible ...

tableau = {a,b,c,d,e} 

Pour i = 0 allant jusqu'à 4
afficher tableau[i]; 
fin pour

;o)

bob · Answer

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

mamiemando · Answer

On peut imaginer que la fonction qui prend en paramètre le tableau fasse un switch en fonction de son contenu. #include #include 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 & actions){ const std::size_t n = actions.size(); for(std::size_t i=0;i actions; actions.push_back('b'); actions.push_back('a'); actions.push_back('b'); actions.push_back('c'); do_actions(actions); return 0; } ce qui donne à l'exécution... b a b c Libre à toi de passer des choses plus compliquées dans le vecteur notamment si tu as besoin de passer des paramètres à tes fonctions. Bonne chance

Mahmah · Answer

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;
}


Ou alors avec des classes et de l'héritage mais ce n'est plus transposable en C.

M.



(Mon compilo est un peu occupé là, je n'ai as pu tester...)

mamiemando · Answer

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

Mahmah · Answer

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.

mamiemando · Answer

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.

Mahmah · Answer

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.

C/C++ boucle for

9 réponses

Discussions similaires