variable imbriquée pour des boucles

Vous pouvez l'écrire comme ça, mais ... je ne le ferais pas. C'est un code déroutant et ne vous donne aucun avantage. Si vous le souhaitez, votre véritable cas d'utilisation a un grand nombre de boucles imbriquées, envisagez simplement de ne pas le faire, à la place; C'est une odeur de conception sérieuse.

void nested_loop(const int levels, const int comparator, const int level = 0, const int accumulator = 0)
{
   if (level < levels) {
      for (int i = 0; i < 6; i++) {
         nested_loop(levels, comparator, level + 1, accumulator + i);
      }
   }
   else {
      if (accumulator == comparator) {   // your if (z+y+x==f)
         //do something
      }
   }
}

int main() {
   const int levels = 3;
   const int f = 42;

   nested_loop(levels, f);
}

La structure de base d'un algorithme récursif avec plusieurs boucles est la suivante: xxx pré>

la configuration pour appeler récursivingoops code> du niveau supérieur nécessite deux vecteurs - un pour les index et un pour le nombre d'itérations à chaque niveau. L'exemple ci-dessous définit trois boucles imbriquées, itérant 5, 6 et 9 fois à chaque niveau: P>

vector<int> indexes(3, 0);
vector<int> endPerIndex;
endPerIndex.push_back(5);
endPerIndex.push_back(6);
endPerIndex.push_back(9);
recursiveLoops(indexes, endPerIndex, 0);

Vous êtes très vague sur pourquoi vous voulez cela. Pour un démarreur, une solution possible est de remplacer chaque boucle avec une fonction récursive.

void recursiveX(int zVal, int yVal, int xVal)
{
    if(zVal+yVal+xVal == f)...
    if(xVal != 0)
        recursiveX(zVal, yVal, xVal -1);
}

void recursiveY(int zVal, int yVal)
{
    recursiveX(zVal, yVal, 6);
    if(yVal != 0)
        recursiveY(zVal, yVal-1);
}

void recursiveZ(int val)
{
    recursiveY(val, 6);
    if(val != 0)
        recursiveZ(val-1);
}
...
recursiveZ(6);

Voici un exemple dans l'ancien clair C ++. D'abord, je fais un vecteur des gammes pour chaque dimension appelée maxes code>. Si la somme de tous les indices est 2, j'imprime quelque chose. Dans l'exemple, je loop z de 0 à 1, y de 0 à 2, x de 0 à 3

Vous pouvez certes rendre cela plus propre. P>

Voici: P>

values are 0 0 0 
values are 1 0 0 
values are 2 0 0  did something! 
values are 3 0 0 
values are 0 1 0 
values are 1 1 0  did something! 
values are 2 1 0 
values are 3 1 0 
values are 0 2 0  did something! 
values are 1 2 0 
values are 2 2 0 
values are 3 2 0 
values are 0 0 1 
values are 1 0 1  did something! 
values are 2 0 1 
values are 3 0 1 
values are 0 1 1  did something! 
values are 1 1 1 
values are 2 1 1 
values are 3 1 1 
values are 0 2 1 
values are 1 2 1 
values are 2 2 1 
values are 3 2 1 

Je suis tombé à travers cela plus tôt aujourd'hui et j'ai pensé que je pourrais partager la solution que j'ai finalement proposé. Je ne suis pas sûr de ce que la politique est ici en ce qui concerne la réponse à de vieux postes. Je vais juste par le fait que je suis tombé sur cette question ce matin, et ce genre de chose aurait été utile pour moi.

Pour l'efficacité, j'ai évité la récursivité. En outre, il n'utilise aucune chose spécifique C ++ - cela fonctionnera également sur C aussi. P>

Nous essayons de créer N nichés "pour" boucles. Au lieu d'utiliser P>

const int n = /*Insert N here: how many loops do you need?*/;
int i[n+1]; // if "n" is not known before hand, then this array will need to be created dynamically.
//Note: there is an extra element at the end of the array, in order to keep track of whether to exit the array.

for (int a=0; a<n+1; a++) {
  i[a]=0;
}

int MAX = 79; //That's just an example, if all of the loops are identical: e.g. "for(int i=0; i<79; i++)". If the value of MAX changes for each loop, then make MAX an array instead: (new) int MAX [n]; MAX[0]=10; MAX[1]=20;...;MAX[n-1]=whatever.

int p = 0; //Used to increment all of the indicies correctly, at the end of each loop.
while (i[n]==0) {//Remember, you're only using indicies i[0], ..., i[n-1]. The (n+1)th index, i[n], is just to check whether to the nested loop stuff has finished.

  //DO STUFF HERE. Pretend you're inside your nested for loops. The more usual i,j,k,... have been replaced here with i[0], i[1], ..., i[n-1].


  //Now, after you've done your stuff, we need to increment all of the indicies correctly.
  i[0]++;
  // p = 0;//Commented out, because it's replaced by a more efficient alternative below.
  while(i[p]==MAX) {//(or "MAX[p]" if each "for" loop is different. Note that from an English point of view, this is more like "if(i[p]==MAX". (Initially i[0]) If this is true, then i[p] is reset to 0, and i[p+1] is incremented.
    i[p]=0;
    i[++p]++; //increase p by 1, and increase the next (p+1)th index
    if(i[p]!=MAX)
      p=0;//Alternatively, "p=0" can be inserted above (currently commented-out). This one's more efficient though, since it only resets p when it actually needs to be reset!
  }
}