Comment est la plage base de travail pour la plaine des tableaux?

Il fonctionne pour toute expression dont le type est un tableau. Par exemple:

int (*arraypointer)[4] = new int[1][4]{{1, 2, 3, 4}};
for(int &n : *arraypointer)
  n *= 2;
delete [] arraypointer;

Pour une explication plus détaillée, si le type de l'expression passée à droite de : est de type tableau, puis itération de la boucle de ptr à ptr + size (ptr pointant vers le premier élément du tableau, size étant l'élément le comte de la matrice).

Ceci est en contraste à des types définis par l'utilisateur, qui travaillent en recherche de begin et end en tant que membres si vous passez un objet de classe ou (si il n'y a pas de membres, appelle ainsi), non-membre de fonctions. Ces fonctions donnera le point de début et de fin des itérateurs (pointant directement après le dernier élément et le début de la séquence, respectivement).

Cette question efface pourquoi cette différence existe.

Selon le dernier C++ du Projet de Travail (n3376) à distance pour instruction est équivalente à la suivante:

{
    auto && __range = range-init;
    for (auto __begin = begin-expr,
              __end = end-expr;
            __begin != __end;
            ++__begin) {
        for-range-declaration = *__begin;
        statement
    }
}

Il sait comment arrêter de la même façon régulière for boucle à l'aide des itérateurs ne.

Je pense que vous cherchez peut-être pour quelque chose comme ce qui suit afin de fournir un moyen d'utiliser la syntaxe ci-dessus avec des tableaux qui se composent de seulement un pointeur et de la taille (tableaux dynamiques):

template <typename T>
class Range
{
public:
    Range(T* collection, size_t size) :
        mCollection(collection), mSize(size)
    {
    }

    T* begin() { return &mCollection[0]; }
    T* end () { return &mCollection[mSize]; }

private:
    T* mCollection;
    size_t mSize;
};

Ce modèle de classe peut ensuite être utilisé pour créer une gamme, sur lequel vous pouvez effectuer une itération à l'aide de la nouvelle varié pour de la syntaxe. Je me sers de ce à courir à travers toutes les animations des objets dans une scène qui est importé à l'aide d'une bibliothèque qui ne retourne un pointeur vers un tableau et une taille de valeurs séparées.

for ( auto pAnimation : Range<aiAnimation*>(pScene->mAnimations, pScene->mNumAnimations) )
{
    //Do something with each pAnimation instance here
}

Cette syntaxe est, à mon avis, beaucoup plus claire que ce que vous pourriez obtenir en utilisant std::for_each ou une plaine for boucle.

Comment est la plage base de travail pour la plaine des tableaux?

Est que de lire que, "me Dire ce qu'une attaque à distance pour ne (avec des tableaux)?"

Je vais répondre en supposant que Prendre l'exemple suivant à l'aide de tableaux imbriqués:

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

for (auto &pl : ia)

Version texte:

ia est un tableau de tableaux ("tableau imbriqué"), contenant [3] tableaux, contenant chacune [4] valeurs. L'exemple ci-dessus boucles à travers ia en principal de "gamme" ( [3] ), et, par conséquent, des boucles [3] fois. Chaque boucle produit un des ia's [3] primaire valeurs de départ de la première et se terminant avec le dernier - Un tableau contenant [4] valeurs.

• Première boucle: pl est égal à {1,2,3,4} - Un tableau
• Deuxième boucle: pl est égal à {5,6,7,8} - Un tableau
• Troisième boucle: pl est égal à {9,10,11,12} - Un tableau

Avant de nous expliquer le processus, voici quelques rappels amicaux sur les tableaux:

• Tableaux sont interprétés comme des pointeurs vers leur première valeur à l'Aide d'un tableau sans aucune itération renvoie l'adresse de la première valeur
• pl doit être une référence, car on ne peut pas copier des tableaux
• Avec des tableaux, lorsque vous ajoutez un nombre de l'objet tableau lui-même, il avance vers l'avant que de nombreuses fois et les "points" à l'équivalent d'entrée - Si n est le nombre en question, puis ia[n] est le même que *(ia+n) (Nous faisons référence à l'adresse n entrées vers l'avant), et ia+n est le même que &ia[n] (Nous sommes à recevoir l'adresse de l'entrée dans le tableau).

Voici ce qu'il se passe:

• Sur chaque boucle, pl est défini comme un référence à ia[n], avec n égaler la boucle de courant, compter à partir de 0. Donc, pl est ia[0] sur le premier tour, sur le second, il est ia[1], et ainsi de suite. Il récupère la valeur par itération.
• La boucle continue tant que ia+n est à moins de end(ia).

...Et c'est tout.

C'est vraiment juste une simplifiée pour écrire ce:

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int n = 0; n != 3; ++n)
  auto &pl = ia[n];

---

Si votre tableau n'est pas imbriqué, ce processus devient un peu plus simple qu'une référence est pas nécessaire, parce que l'itération de la valeur n'est pas un tableau mais plutôt "normale" valeur:

 int ib[3] = {1,2,3};

 //short
 for (auto pl : ib)
   cout << pl;

 //long
 for (int n = 0; n != 3; ++n)
   cout << ib[n];

---

Quelques informations supplémentaires

Que si nous ne voulions pas utiliser le auto mot-clé lors de la création de pl? A quoi cela ressemble?

Dans l'exemple suivant, pl se réfère à une array of four integers. Sur chaque boucle pl est donné la valeur ia[n]:

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int (&pl)[4] : ia)

---

Et... c'est comment ça fonctionne, avec des informations supplémentaires afin de repousser toute confusion. C'est juste une "abréviation' for boucle qui compte automatiquement pour vous, mais il lui manque un moyen de récupérer la boucle de courant sans le faire manuellement.