Comment faire pour chaque boucle de la fonction en C++ de travail avec une classe personnalisée

Laisser iterable être de type Iterable.
Puis, afin de faire

for (Type x : iterable)

compiler, il doit être appelé Type et IType et il doit y avoir des fonctions

IType Iterable::begin()
IType Iterable::end()

IType doit fournir les fonctions

Type operator*()
void operator++()
bool operator!=(IType)

---

L'ensemble de la construction est vraiment sophistiqué sucre syntaxique pour quelque chose comme

for (IType it = iterable.begin(); it != iterable.end(); ++it) {
    Type x = *it;
    ...
}

où, au lieu de Type, tout type compatibles (tels que const Type ou Type&) peut être utilisé, ce qui aura des incidences prévisibles (constness de référence au lieu de copier etc.).

Depuis l'ensemble de l'expansion qui se passe du point de vue syntaxique, vous pouvez également modifier la déclaration des opérateurs de bits, par exemple *il renvoyer une référence ou d'avoir != prendre un const IType& rhs en tant que de besoin.

Notez que vous ne pouvez pas utiliser le for (Type& x : iterable) forme si *it ne pas renvoyer une référence (mais si elle renvoie une référence, vous pouvez également utiliser la version de la copie).

Note également que operator++() définit la préfixe version de la ++ opérateur -- toutefois, il sera également utilisé comme la postfix exploitant, à moins que vous définissez explicitement un postfix ++. La distance-pour ne compilera pas si vous ne fournir qu'un postfix ++, qui btw.peut être déclarée comme operator++(int) (dummy argument int).

---

Minimale de travail exemple:

#include <stdio.h>
typedef int Type;

struct IType {
    Type* p;
    IType(Type* p) : p(p) {}
    bool operator!=(IType rhs) {return p != rhs.p;}
    Type& operator*() {return *p;}
    void operator++() {++p;}
};

const int SIZE = 10;
struct Iterable {
    Type data[SIZE];

    IType begin() {return IType(data); }
    IType end() {return IType(data + SIZE);}
};

Iterable iterable;

int main() {
    int i = 0;
    for (Type& x : iterable) {
        x = i++;
    }
    for (Type x : iterable) {
        printf("%d", x);
    }
}

sortie

0123456789

---

Vous pouvez le faux variait pour chaque (par exemple, pour les anciens compilateurs C++) avec la macro suivante:

 #define ln(l, x) x##l //creates unique labels
 #define l(x,y)  ln(x,y)
 #define for_each(T,x,iterable) for (bool _run = true;_run;_run = false) for (auto it = iterable.begin(); it != iterable.end(); ++it)\
     if (1) {\
         _run = true; goto l(__LINE__,body); l(__LINE__,cont): _run = true; continue; l(__LINE__,finish): break;\
         } else\
            while (1)   \
                if (1) {\
                    if (!_run) goto l(__LINE__,cont);/* we reach here if the block terminated normally/via continue */   \
                    goto l(__LINE__,finish);/* we reach here if the block terminated by break */\
                }   \
                else\
                l(__LINE__,body): for (T x = *it;_run;_run=false) /* block following the expanded macro */                         

 int main() {
     int i = 0;
     for_each(Type&, x, iterable) {
         i++;
         if (i > 5) break;
         x = i;
     }
     for_each(Type, x, iterable) {
         printf("%d", x);
     }
     while (1);
 }

(utiliser declspec ou passer IType si votre compilateur ne dispose même pas d'auto).

De sortie:

 1234500000

Comme vous pouvez le voir, continue et break sera de travailler avec cette grâce à sa construction compliquée.
Voir http://www.chiark.greenend.org.uk/~sgtatham/mp/ pour plus de C-préprocesseur de piratage pour créer des structures de contrôle.

C++ n'a pas le for_each fonction de boucle dans sa syntaxe. Vous devez utiliser le c++11 ou utilisez la fonction de modèle std::for_each.

#include <vector>
#include <algorithm>
#include <iostream>

struct Sum {
    Sum() { sum = 0; }
    void operator()(int n) { sum += n; }

    int sum;
};

int main()
{
    std::vector<int> nums{3, 4, 2, 9, 15, 267};

    std::cout << "before: ";
    for (auto n : nums) {
        std::cout << n << " ";
    }
    std::cout << '\n';

    std::for_each(nums.begin(), nums.end(), [](int &n){ n++; });
    Sum s = std::for_each(nums.begin(), nums.end(), Sum());

    std::cout << "after:  ";
    for (auto n : nums) {
        std::cout << n << " ";
    }
    std::cout << '\n';
    std::cout << "sum: " << s.sum << '\n';
}