Comment faire fonctionner mon type personnalisé avec «basé sur la plage pour les boucles»?

Comme beaucoup de gens ces jours-ci, j'ai essayé les différentes fonctionnalités qu'apporte C ++ 11. Un de mes favoris est le "basé sur la gamme pour les boucles".

Je comprends que:

for(Type& v : a) { ... }

Est équivalent à:

for(auto iv = begin(a); iv != end(a); ++iv)
{
  Type& v = *iv;
  ...
}

Et cela begin()revient simplement a.begin()pour des conteneurs standard.

Mais que se passe-t-il si je veux rendre mon type personnalisé "basé sur une plage pour la boucle" ?

Dois-je juste me spécialiser begin()et end()?

Si mon type personnalisé appartient à l'espace de noms xml, dois-je définir xml::begin()ou std::begin()?

En bref, quelles sont les lignes directrices pour ce faire?

La norme a été modifiée depuis que la question (et la plupart des réponses) ont été publiées dans la résolution de ce rapport d'anomalie .

La façon de faire fonctionner une for(:)boucle sur votre type Xest désormais l'une des deux façons suivantes:

• Créer un membre X::begin()et X::end()renvoyer quelque chose qui agit comme un itérateur

• Créez une fonction gratuite begin(X&)et end(X&)qui retourne quelque chose qui agit comme un itérateur, dans le même espace de nom que votre type X.¹

Et similaire pour les constvariations. Cela fonctionnera à la fois sur les compilateurs qui implémentent les modifications de rapport de défaut et sur les compilateurs qui ne le font pas.

Les objets retournés ne doivent pas nécessairement être des itérateurs. La for(:)boucle, contrairement à la plupart des parties de la norme C ++, est spécifiée pour s'étendre à quelque chose d'équivalent à :

for( range_declaration : range_expression )

devient:

{
  auto && __range = range_expression ;
  for (auto __begin = begin_expr,
            __end = end_expr;
            __begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

où les variables commençant par __sont uniquement destinées à l'exposition, et begin_expret end_exprest la magie qui appelle begin/ end.²

Les exigences sur la valeur de retour de début / fin sont simples: vous devez surcharger la pré- ++, vous assurer que les expressions d'initialisation sont valides, binaires !=qui peuvent être utilisés dans un contexte booléen, unaire *qui renvoie quelque chose que vous pouvez assigner-initialiserrange_declaration et exposer un public destructeur.

Le faire d'une manière qui n'est pas compatible avec un itérateur est probablement une mauvaise idée, car les futures itérations de C ++ pourraient être relativement cavalières sur la rupture de votre code si vous le faites.

Soit dit en passant, il est raisonnablement probable qu'une future révision de la norme permettra end_exprde renvoyer un type différent de celui begin_expr. Ceci est utile car il permet une évaluation "paresseuse" (comme la détection de terminaison nulle) qui est facile à optimiser pour être aussi efficace qu'une boucle C manuscrite, et d'autres avantages similaires.

¹ Notez que les for(:)boucles stockent tout temporaire dans une auto&&variable et vous le transmettent en tant que valeur l. Vous ne pouvez pas détecter si vous parcourez une valeur temporaire (ou une autre valeur); une telle surcharge ne sera pas appelée par unfor(:) boucle. Voir [stmt.ranged] 1.2-1.3 de n4527.

² Appelez la méthode begin/ end, ou la recherche ADL uniquement de la fonction gratuite begin/ end, ou magic pour la prise en charge des tableaux de style C. Notez qu'il std::beginn'est pas appelé sauf s'il range_expressionrenvoie un objet de type dans namespace stdou dépendant de celui-ci.

Dans c ++ 17 l'expression range-for a été mise à jour

{
  auto && __range = range_expression ;
  auto __begin = begin_expr;
  auto __end = end_expr;
  for (;__begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

avec les types de __beginet __endont été découplés.

Cela permet à l'itérateur final de ne pas être du même type que begin. Votre type d'itérateur de fin peut être une "sentinelle" qui ne prend !=en charge qu'avec le type d'itérateur de début.

Un exemple pratique de la raison pour laquelle cela est utile est que votre itérateur final peut lire "vérifiez votre char*pour voir s'il pointe vers '0'" lorsqu'il est ==avec un char*. Cela permet à une expression d'intervalle C ++ de générer du code optimal lors de l'itération sur un char*tampon terminé par null .

struct null_sentinal_t {
  template<class Rhs,
    std::enable_if_t<!std::is_same<Rhs, null_sentinal_t>{},int> =0
  >
  friend bool operator==(Rhs const& ptr, null_sentinal_t) {
    return !*ptr;
  }
  template<class Rhs,
    std::enable_if_t<!std::is_same<Rhs, null_sentinal_t>{},int> =0
  >
  friend bool operator!=(Rhs const& ptr, null_sentinal_t) {
    return !(ptr==null_sentinal_t{});
  }
  template<class Lhs,
    std::enable_if_t<!std::is_same<Lhs, null_sentinal_t>{},int> =0
  >
  friend bool operator==(null_sentinal_t, Lhs const& ptr) {
    return !*ptr;
  }
  template<class Lhs,
    std::enable_if_t<!std::is_same<Lhs, null_sentinal_t>{},int> =0
  >
  friend bool operator!=(null_sentinal_t, Lhs const& ptr) {
    return !(null_sentinal_t{}==ptr);
  }
  friend bool operator==(null_sentinal_t, null_sentinal_t) {
    return true;
  }
  friend bool operator!=(null_sentinal_t, null_sentinal_t) {
    return false;
  }
};

exemple en direct dans un compilateur sans prise en charge complète de C ++ 17; forboucle développée manuellement.

J'écris ma réponse parce que certaines personnes pourraient être plus satisfaites d'un simple exemple de la vie réelle sans STL inclus.

J'ai ma propre implémentation de tableau de données uniquement pour une raison quelconque, et je voulais utiliser la plage basée sur la boucle. Voici ma solution:

 template <typename DataType>
 class PodArray {
 public:
   class iterator {
   public:
     iterator(DataType * ptr): ptr(ptr){}
     iterator operator++() { ++ptr; return *this; }
     bool operator!=(const iterator & other) const { return ptr != other.ptr; }
     const DataType& operator*() const { return *ptr; }
   private:
     DataType* ptr;
   };
 private:
   unsigned len;
   DataType *val;
 public:
   iterator begin() const { return iterator(val); }
   iterator end() const { return iterator(val + len); }

   // rest of the container definition not related to the question ...
 };

Ensuite, l'exemple d'utilisation:

PodArray<char> array;
// fill up array in some way
for(auto& c : array)
  printf("char: %c\n", c);

La partie pertinente de la norme est 6.5.4 / 1:

si _RangeT est un type de classe, les identifiants non définis commencent et finissent dans la portée de la classe _RangeT comme si par la recherche d'accès des membres de la classe (3.4.5), et si l'un (ou les deux) trouve au moins une déclaration, commencez - expr et expr-fin sont __range.begin()et __range.end(), respectivement;

- sinon, begin-expr et end-expr sont begin(__range)et end(__range), respectivement, où début et fin sont recherchés avec une recherche dépendante de l'argument (3.4.2). Aux fins de cette recherche de nom, l'espace de noms std est un espace de noms associé.

Vous pouvez donc effectuer l'une des opérations suivantes:

• définir beginet endmembres fonctions
• définir beginet endlibérer des fonctions qui seront trouvées par ADL (version simplifiée: les mettre dans le même espace de noms que la classe)
• se spécialiser std::beginetstd::end

std::beginappelle de begin()toute façon la fonction membre, donc si vous implémentez uniquement l'une des options ci-dessus, les résultats devraient être les mêmes, peu importe celui que vous choisissez. Ce sont les mêmes résultats pour les boucles à distance, et aussi le même résultat pour le simple code mortel qui n'a pas ses propres règles de résolution de noms magiques, juste using std::begin;suivi d'un appel sans réserve à begin(a).

Si vous implémentez les fonctions membres et les fonctions ADL, les boucles for basées sur la plage doivent appeler les fonctions membres, tandis que les simples mortels appellent les fonctions ADL. Assurez-vous qu'ils font la même chose dans ce cas!

Si la chose que vous écrivez implémente l'interface de conteneur, il aura begin()et end()fonctions membres déjà, ce qui devrait être suffisant. S'il s'agit d'une gamme qui n'est pas un conteneur (ce qui serait une bonne idée si elle est immuable ou si vous ne connaissez pas la taille à l'avance), vous êtes libre de choisir.

Parmi les options que vous disposez, notez que vous ne devez pas surcharger std::begin(). Vous êtes autorisé à spécialiser les modèles standard pour un type défini par l'utilisateur, mais à part cela, l'ajout de définitions à l'espace de noms std est un comportement non défini. Mais de toute façon, la spécialisation des fonctions standard est un mauvais choix, ne serait-ce que parce que le manque de spécialisation partielle des fonctions signifie que vous ne pouvez le faire que pour une seule classe, pas pour un modèle de classe.

Dois-je juste spécialiser begin () et end ()?

Pour autant que je sache, cela suffit. Vous devez également vous assurer que l'incrémentation du pointeur se produira du début à la fin.

L'exemple suivant (il manque la version const de début et de fin) se compile et fonctionne correctement.

#include <iostream>
#include <algorithm>

int i=0;

struct A
{
    A()
    {
        std::generate(&v[0], &v[10], [&i](){  return ++i;} );
    }
    int * begin()
    {
        return &v[0];
    }
    int * end()
    {
        return &v[10];
    }

    int v[10];
};

int main()
{
    A a;
    for( auto it : a )
    {
        std::cout << it << std::endl;
    }
}

Voici un autre exemple avec des fonctions de début / fin. Ils doivent être dans le même espace de noms que la classe, à cause d'ADL:

#include <iostream>
#include <algorithm>


namespace foo{
int i=0;

struct A
{
    A()
    {
        std::generate(&v[0], &v[10], [&i](){  return ++i;} );
    }

    int v[10];
};

int *begin( A &v )
{
    return &v.v[0];
}
int *end( A &v )
{
    return &v.v[10];
}
} // namespace foo

int main()
{
    foo::A a;
    for( auto it : a )
    {
        std::cout << it << std::endl;
    }
}

Dans le cas où vous souhaitez sauvegarder l'itération d'une classe directement avec son membre std::vectorou std::map, voici le code pour cela:

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;
#include <vector>
using std::vector;
#include <map>
using std::map;


/////////////////////////////////////////////////////
/// classes
/////////////////////////////////////////////////////

class VectorValues {
private:
    vector<int> v = vector<int>(10);

public:
    vector<int>::iterator begin(){
        return v.begin();
    }
    vector<int>::iterator end(){
        return v.end();
    }
    vector<int>::const_iterator begin() const {
        return v.begin();
    }
    vector<int>::const_iterator end() const {
        return v.end();
    }
};

class MapValues {
private:
    map<string,int> v;

public:
    map<string,int>::iterator begin(){
        return v.begin();
    }
    map<string,int>::iterator end(){
        return v.end();
    }
    map<string,int>::const_iterator begin() const {
        return v.begin();
    }
    map<string,int>::const_iterator end() const {
        return v.end();
    }

    const int& operator[](string key) const {
        return v.at(key);
    }
    int& operator[](string key) {
        return v[key];
    } 
};


/////////////////////////////////////////////////////
/// main
/////////////////////////////////////////////////////

int main() {
    // VectorValues
    VectorValues items;
    int i = 0;
    for(int& item : items) {
        item = i;
        i++;
    }
    for(int& item : items)
        cout << item << " ";
    cout << endl << endl;

    // MapValues
    MapValues m;
    m["a"] = 1;
    m["b"] = 2;
    m["c"] = 3;
    for(auto pair: m)
        cout << pair.first << " " << pair.second << endl;
}

Ici, je partage l'exemple le plus simple de création de type personnalisé, qui fonctionnera avec " boucle basée sur une plage ":

#include<iostream>
using namespace std;

template<typename T, int sizeOfArray>
class MyCustomType
{
private:
    T *data;
    int indx;
public:
    MyCustomType(){
        data = new T[sizeOfArray];
        indx = -1;
    }
    ~MyCustomType(){
        delete []data;
    }
    void addData(T newVal){
        data[++indx] = newVal;
    }

    //write definition for begin() and end()
    //these two method will be used for "ranged based loop idiom"
    T* begin(){
        return &data[0];
    }
    T* end(){
        return  &data[sizeOfArray];
    }
};
int main()
{
    MyCustomType<double, 2> numberList;
    numberList.addData(20.25);
    numberList.addData(50.12);
    for(auto val: numberList){
        cout<<val<<endl;
    }
    return 0;
}

J'espère que ce sera utile pour un développeur novice comme moi: p :)
Merci.

La réponse de Chris Redford fonctionne également pour les conteneurs Qt (bien sûr). Voici une adaptation (remarquez que je retourne a constBegin(), respectivement à constEnd()partir des méthodes const_iterator):

class MyCustomClass{
    QList<MyCustomDatatype> data_;
public:    
    // ctors,dtor, methods here...

    QList<MyCustomDatatype>::iterator begin() { return data_.begin(); }
    QList<MyCustomDatatype>::iterator end() { return data_.end(); }
    QList<MyCustomDatatype>::const_iterator begin() const{ return data_.constBegin(); }
    QList<MyCustomDatatype>::const_iterator end() const{ return data_.constEnd(); }
};

Je voudrais élaborer certaines parties de la réponse de @Steve Jessop, pour lesquelles au début je ne comprenais pas. J'espère que ça aide.

std::beginappelle de begin()toute façon la fonction membre, donc si vous implémentez uniquement l'une des options ci-dessus, les résultats devraient être les mêmes, peu importe celui que vous choisissez. Ce sont les mêmes résultats pour les boucles à distance, et aussi le même résultat pour le simple code mortel qui n'a pas ses propres règles de résolution de noms magiques, juste using std::begin;suivi d'un appel non qualifié àbegin(a) .

Si vous implémentez les fonctions membres et les fonctions ADL , les boucles for basées sur la plage doivent appeler les fonctions membres, tandis que les simples mortels appellent les fonctions ADL. Assurez-vous qu'ils font la même chose dans ce cas!

https://en.cppreference.com/w/cpp/language/range-for :

• Si ...
• Si range_expressionest une expression d'un type de classe Cqui a à la fois un membre nommé beginet un membre nommé end(quel que soit le type ou l'accessibilité de ce membre), alors begin_exprest __range.begin() et end_exprest __range.end();
• Sinon, begin_expris begin(__range)et end_expris end(__range), qui sont trouvés via la recherche dépendante de l'argument (la recherche non ADL n'est pas effectuée).

Pour une boucle basée sur une plage, les fonctions membres sont sélectionnées en premier.

Mais pour

using std::begin;
begin(instance);

Les fonctions ADL sont sélectionnées en premier.

Exemple:

#include <iostream>
#include <string>
using std::cout;
using std::endl;

namespace Foo{
    struct A{
        //member function version
        int* begin(){
            cout << "111";
            int* p = new int(3);  //leak I know, for simplicity
            return p;
        }
        int *end(){
            cout << "111";
            int* p = new int(4);
            return p;
        }
    };

    //ADL version

    int* begin(A a){
        cout << "222";
        int* p = new int(5);
        return p;
    }

    int* end(A a){
        cout << "222";
        int* p = new int(6);
        return p;
    }

}

int main(int argc, char *args[]){
//    Uncomment only one of two code sections below for each trial

//    Foo::A a;
//    using std::begin;
//    begin(a);  //ADL version are selected. If comment out ADL version, then member functions are called.


//      Foo::A a;
//      for(auto s: a){  //member functions are selected. If comment out member functions, then ADL are called.
//      }
}