C ++ répéter N itérations

Non, il n'y a pas d'algorithme dans la bibliothèque standard pour faire cela (du moins rien qui ne nécessiterait pas d'écrire un passe-partout inutile). Comme d'autres l'ont déjà mentionné, une boucle est le moyen le plus lisible et le moins obscur de faire "quelque chose" n fois.

Cela étant dit, si vous le prenez comme un exercice pour obtenir une syntaxe plus concise, vous pourriez écrivez ceci:

#include <iostream>
struct my_counter {    
    int stop;
    struct iterator {
        int count;    
        iterator& operator++() { ++count; return *this; }
        int operator*() { return count;}
        bool operator!=(const iterator& other) { return count != other.count; }
    };
    iterator begin() { return {0}; }
    iterator end() { return {stop};}    
};

void print() { std::cout << "x"; }

int main() {
     for (auto x : my_counter{5}) print();
}

Cependant, je déconseille fortement d'utiliser quelque chose comme ça. Tout le monde sait comment fonctionne une boucle et ce qu'elle fait. Étant habitué aux boucles for, vous pouvez lire une boucle for en un clin d'œil, alors que tout le reste est inhabituel, surprenant et obscur, à moins qu'il n'y ait un algorithme standard bien sûr (bien que je doute qu'un algorithme pour ce cas particulier soit d'une grande utilité) . Pourquoi réinventer la roue quand vous pouvez utiliser une boucle?

Dans la norme proposée pour C ++ 20 , il y a un exemple pour iota_view :

for (int _ : view::iota{0, 10})
    testIteration();            // calls testIteration 10 times.

Mais pour l'instant, range- La bibliothèque v3 peut être utilisée:

for (int i : iota_view{1, 10})
  cout << i << ' '; // prints: 1 2 3 4 5 6 7 8 9

Personnellement, j'aime utiliser une petite fonction d'aide pour faire cela.

template <typename F>
void repeat(size_t n, F f) {
  while (n--) f();
}

int main() {

   repeat(1000, [&] {
      testIteration();
   });
}

Cela évite d'avoir à épeler le nom d'une variable. Je préfère utiliser view :: iota quand j'ai besoin d'un nom.

Cela étant dit, on me dit que c'est déroutant à lire, et que tout le monde peut lire une boucle for, donc c'est probablement la voie à suivre. (À moins que la fonction ne soit placée dans std :: bien sûr).

Qu'en est-il simplement de la définition d'une macro? #define FOR (N, foo, ...) for (int _i = 0; _i

Par exemple.

hello 18
hello 18
hello 18
hello 18
hello 18

Sortie :

#include <iostream>

#define FOR(N, foo, ...) for (int _i = 0; _i < N; _i++) foo(__VA_ARGS__);

void bar(int a, int b)
{
    std::cout << "hello " << a+b << std::endl;
}

int main()
{
    FOR(5, bar, 12, 6);
    return 0;
}

Juste pour référence, il y a std :: generate et std :: generate_n qui peuvent être utilisés, mais uniquement pour l'initialisation du tableau en faisant quelque chose comme ceci: < pré> XXX