Utilisation de nombreux arguments sans code de duplication

Question

Existe-t-il un moyen d'utiliser successivement chacun des arguments de cette fonction sans dupliquer le code? Par exemple, la première fois que j'utilise la boucle, je souhaite utiliser R, la prochaine fois que j'utiliserai L, etc. valuestruct est configuré dans le même ordre que les arguments, donc la méthode du bouton retournera l'équivalent. bool j'ai besoin de currentbutton selon int i. S'il y a une meilleure méthode pour accomplir la même chose, c'est bien aussi.

int valuex=0; 

void SetValue(bool &R,bool &L,bool &D,bool &U,bool &T,bool &S,bool &B,bool &A,bool &Y,bool &X,bool &W,bool &E,bool &G, bool &F) { 

     bool value[4] = {true, false, true, false}; 
     bool currentbutton; 

     for (int i=0; i < 12; i++) { 
      currentbutton=valuestruct.button(i); 

      if(currentbutton) { 
       "I want to grab each argument in sequence here"=value[valuex]; 
       valuex++; 
       if(valuex>ARRAYSIZE(value)) 
        valuex=0; 
      } 
     } 
    } 

Answer 1

Avez-vous envisagé d'utiliser un réseau bool? :) Une collection est définitivement le chemin à parcourir. Si vous devez conserver des métadonnées pour filtrer ou saisir certaines valeurs, pensez à utiliser une carte.

Answer 2

Vous pouvez placer les arguments dans un tableau et passer le tableau à la place. En fonction de ce que le code appelant est, cela pourrait conduire à moins de code.

Answer 3

Vous pouvez utiliser le support d'argument variable, puisque vous avez un nombre fixe d'arguments dont vous connaissez le nombre de boucles. IIRC il n'exige pas réellement que la fonction ait des arguments variables.

va_list args;                          
va_start(args,R); 
// your code here... 
va_end(); 

Pardonnez-moi si cela est hors de la base ... il a été quelques années depuis que je activement C. codé

Answer 4

Ou un bit field? Rapide & Version sale:

int field = FLAG_R | FLAG_L 

void SetValue(int fields) { 
    for (int i = 0; i < FLAG_COUNT; i++) { 
     if (fields & (1 << i)) { 
      // Flag #i is set 
     } 
    } 
} 

EDIT

BTW, en passant bools comme référence ne sert à rien si vous ne changez pas la valeur. Le pointeur utilisé pour la référence est peut-être plus long que le type qui contient le booléen lui-même.

Answer 5

Si vraiment vous n'insistez sur ce prototype de fonction (et non après les autres suggestions ici de passer un tableau ou une liste - qui sont mieux), vous pouvez utiliser quelque chose comme ça -

void SetValue(bool &R,bool &L,bool &D,bool &U,bool &T,bool &S,bool &B,bool &A,bool &Y,bool &X,bool &W,bool &E,bool &G, bool &F) 
{ 
    bool* Bools[] = { &R, &L, &D, &U, &T, &S, &B, &A, &Y, &X, &W, &E, &G, &F }; 

    // *Bools[i] can be used to access the ith element. 

    // Print the 4th element. 
    std::cout << *Bools[3]; 

    // Change the value of the 5th. 
    *Bools[4] = true; 
} 

Par Ainsi, si vous n'avez pas vraiment besoin de changer les valeurs passées, vous ne devriez pas les transmettre par référence. Passer un bool par référence ne fait que gaspiller du temps et de l'espace. Cela rendrait également le code un peu moins encombré.

Answer 6

J'ajouterais ceci à la réponse d'hexagone mais je ne peux pas éditer des publications encore.

int valuex=0; 

void SetValue(bool &R,bool &L,bool &D,bool &U,bool &T,bool &S,bool &B,bool &A 
      ,bool &Y,bool &X,bool &W,bool &E,bool &G, bool &F) 
{ 
    bool* bools[] = { &R, &L, &D, &U, &T, &S, &B, &A, &Y, &X, &W, &E, &G, &F }; 
    bool value[4] = {true, false, true, false}; 
    bool currentbutton; 

    for (int i=0; i<12 && i < ARRAYSIZE(bools); i++) { 
      currentbutton=valuestruct.button(i); 

      if(currentbutton) { 
        *bools[i]=value[valuex]; 
        valuex++; 
        if(valuex>ARRAYSIZE(value)) 
          valuex=0; 
      } 
    } 
} 

Bien que je ne comprends pas où il est pensé que vous ne lirons la valeur des bools, vous ne peut pas mettre tous.