Wie kann ich meinen benutzerdefinierten Typ so gestalten, dass er mit "bereichsbasiert für Schleifen" funktioniert?

Wie viele Leute in diesen Tagen habe ich die verschiedenen Funktionen von C ++ 11 ausprobiert. Einer meiner Favoriten ist der "Range-Based for Loops".

Ich verstehe das:

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

Ist äquivalent zu:

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

Und das begin()kehrt einfach a.begin()für Standardcontainer zurück.

Aber was ist, wenn ich meinen benutzerdefinierten Typ "bereichsbasiert für Schleife" aktivieren möchte ?

Soll ich mich nur spezialisieren begin()und end()?

Wenn mein benutzerdefinierter Typ zum Namespace gehört xml, sollte ich xml::begin()oder definieren std::begin()?

Kurz gesagt, was sind die Richtlinien, um das zu tun?

Der Standard wurde geändert, seit die Frage (und die meisten Antworten) in der Lösung dieses Fehlerberichts veröffentlicht wurden .

Es gibt zwei Möglichkeiten, wie Sie eine for(:)Schleife für Ihren Typ verwenden Xkönnen:

• Erstellen Sie Mitglied X::begin()und X::end()dass die Rückkehr etwas , das wie ein Iterator wirkt

• Erstellen Sie eine freie Funktion begin(X&)und end(X&)dass die Rückkehr etwas , das wie ein Iterator fungiert, im gleichen Namensraum wie Ihre Art X.¹

Und ähnlich für constVariationen. Dies funktioniert sowohl bei Compilern, die die Änderungen des Fehlerberichts implementieren, als auch bei Compilern, die dies nicht tun.

Die zurückgegebenen Objekte müssen keine Iteratoren sein. Die for(:)Schleife wird im Gegensatz zu den meisten Teilen des C ++ - Standards so spezifiziert , dass sie wie folgt erweitert wird :

for( range_declaration : range_expression )

wird:

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

wobei die Variablen, die mit beginnen, __nur zur Darstellung dienen begin_exprund end_exprdie Magie ist, die begin/ end.² aufruft

Die Anforderungen an den Rückgabewert für Anfang / Ende sind einfach: Sie müssen vorab überladen ++, sicherstellen, dass die Initialisierungsausdrücke gültig sind, binär !=, die in einem booleschen Kontext verwendet werden können, unär *, was etwas zurückgibt, mit dem Sie initialisieren können range_declaration, und eine Öffentlichkeit verfügbar machen Zerstörer.

Dies auf eine Weise zu tun, die nicht mit einem Iterator kompatibel ist, ist wahrscheinlich eine schlechte Idee, da zukünftige Iterationen von C ++ möglicherweise relativ unbekümmert sind, wenn Sie Ihren Code brechen, wenn Sie dies tun.

Abgesehen davon ist es ziemlich wahrscheinlich, dass eine zukünftige Überarbeitung des Standards die end_exprRückgabe eines anderen Typs als ermöglicht begin_expr. Dies ist insofern nützlich, als es eine "Lazy-End" -Auswertung (wie das Erkennen einer Nullterminierung) ermöglicht, die leicht zu optimieren ist, um so effizient wie eine handgeschriebene C-Schleife zu sein, und andere ähnliche Vorteile.

¹ Beachten Sie, dass for(:)Schleifen alle temporären auto&&Elemente in einer Variablen speichern und als l-Wert an Sie übergeben. Sie können nicht erkennen, ob Sie über einen temporären (oder einen anderen Wert) iterieren. Eine solche Überlastung wird von einer for(:)Schleife nicht aufgerufen . Siehe [stmt.ranged] 1.2-1.3 von n4527.

² entweder den Anruf begin/ eine endMethode oder ADL-only lookup freier Funktion begin/ end, oder Magie für C-style - Array - Unterstützung. Beachten Sie, dass dies std::beginnur aufgerufen wird, wenn range_expressionein Objekt vom Typ in namespace stddasselbe zurückgegeben wird oder von diesem abhängig ist.

Im c ++ 17 Der Range-for-Ausdruck wurde aktualisiert

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

mit den Arten von __beginund __endwurden entkoppelt.

Dadurch kann der Enditerator nicht vom selben Typ wie begin sein. Ihr Enditeratortyp kann ein "Sentinel" sein, der nur !=mit dem Anfangsiteratortyp unterstützt wird.

Ein praktisches Beispiel dafür , warum dies nützlich ist , dass Ihr Ende kann Iterator „überprüfen Sie Ihre lesen , char*um zu sehen , ob es weist auf '0'“ , wenn ==mit ein char*. Auf diese Weise kann ein C ++ - Bereichsausdruck optimalen Code generieren, wenn er über einen nullterminierten char*Puffer iteriert .

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;
  }
};

Live-Beispiel in einem Compiler ohne vollständige C ++ 17-Unterstützung; forSchleife manuell erweitert.

Ich schreibe meine Antwort, weil einige Leute mit einfachen Beispielen aus dem wirklichen Leben ohne STL-Includes zufriedener sein könnten.

Ich habe aus irgendeinem Grund meine eigene einfache Datenarray-Implementierung und wollte den Bereich verwenden, der auf der Schleife basiert. Hier ist meine Lösung:

 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 ...
 };

Dann das Anwendungsbeispiel:

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

Der relevante Teil der Norm ist 6.5.4 / 1:

Wenn _RangeT ein Klassentyp ist, werden die nicht qualifizierten IDs begin und end im Bereich der Klasse _RangeT nachgeschlagen, als ob nach der Suche nach Zugriff auf Klassenmitglieder (3.4.5), und wenn einer (oder beide) mindestens eine Deklaration findet, beginnen Sie - expr und Endausdruck sind __range.begin()und __range.end()verbunden sind;

- sonst beginnen-ausdr und Endausdruck sind begin(__range)und end(__range)jeweils wo beginnen und enden mit Argument abhängigen Lookup (3.4.2) nachgeschlagen. Für die Zwecke dieser Namenssuche ist der Namespace std ein zugeordneter Namespace.

Sie können also Folgendes tun:

• Definieren beginund endElementfunktionen
• Definieren beginund geben Sie endFunktionen frei, die von ADL gefunden werden (vereinfachte Version: Fügen Sie sie in denselben Namespace wie die Klasse ein).
• spezialisieren std::beginundstd::end

std::beginRuft die begin()Member-Funktion trotzdem auf. Wenn Sie also nur eine der oben genannten Funktionen implementieren, sollten die Ergebnisse unabhängig von der gewählten Funktion gleich sein. Das sind die gleichen Ergebnisse für Fernkampf-basierte for-Schleifen und das gleiche Ergebnis für bloßen Sterblichen Code, der keine eigenen Regeln für die Auflösung magischer Namen hat, also nur using std::begin;gefolgt von einem unqualifizierten Aufruf von begin(a).

Wenn Sie jedoch die Elementfunktionen und die ADL-Funktionen implementieren , sollten bereichsbasierte for-Schleifen die Elementfunktionen aufrufen, während bloße Sterbliche die ADL-Funktionen aufrufen. Stellen Sie am besten sicher, dass sie in diesem Fall dasselbe tun!

Wenn das , was Sie implementiert die Container - Schnittstelle schreiben, dann wird es haben begin()und end()Elementfunktionen bereits, was ausreichend sein sollte. Wenn es sich um einen Bereich handelt, der kein Container ist (was eine gute Idee wäre, wenn er unveränderlich ist oder wenn Sie die Größe im Voraus nicht kennen), können Sie frei wählen.

Beachten Sie, dass Sie bei den von Ihnen bereitgestellten Optionen nicht überladen dürfen std::begin(). Sie können Standardvorlagen für einen benutzerdefinierten Typ spezialisieren. Abgesehen davon ist das Hinzufügen von Definitionen zum Namespace std ein undefiniertes Verhalten. Die Spezialisierung von Standardfunktionen ist jedoch schon deshalb eine schlechte Wahl, da Sie aufgrund der fehlenden Spezialisierung auf Teilfunktionen nur für eine einzelne Klasse und nicht für eine Klassenvorlage arbeiten können.

Sollte ich mich nur auf begin () und end () spezialisieren?

Soweit ich weiß, ist das genug. Sie müssen auch sicherstellen, dass das Inkrementieren des Zeigers vom Anfang bis zum Ende erfolgt.

Das nächste Beispiel (es fehlt die const-Version von Anfang und Ende) wird kompiliert und funktioniert einwandfrei.

#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;
    }
}

Hier ist ein weiteres Beispiel mit Anfang / Ende als Funktionen. Sie müssen sich aufgrund von ADL im selben Namespace wie die Klasse befinden:

#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;
    }
}

Falls Sie die Iteration einer Klasse direkt mit ihrem std::vectoroder unterstützen möchtenstd::map Mitglied unterstützen , finden Sie hier den Code dafür:

#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;
}

Hier teile ich das einfachste Beispiel für das Erstellen eines benutzerdefinierten Typs, der mit " bereichsbasierter for-Schleife " funktioniert :

#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;
}

Hoffe, es wird für einige unerfahrene Entwickler wie mich hilfreich sein: p :)
Danke.

Chris Redfords Antwort funktioniert (natürlich) auch für Qt-Container. Hier ist eine Anpassung (beachten Sie, dass ich constBegin()jeweils a constEnd()von den const_iterator-Methoden zurückgebe):

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(); }
};

Ich möchte einige Teile der Antwort von @Steve Jessop näher erläutern, für die ich zunächst nichts verstanden habe. Ich hoffe es hilft.

std::beginRuft die begin()Member-Funktion trotzdem auf. Wenn Sie also nur eine der oben genannten Funktionen implementieren, sollten die Ergebnisse unabhängig von der gewählten Funktion gleich sein. Das ist das gleiche Ergebnis für Fernkampf-basierte for-Schleifen und das gleiche Ergebnis für bloßen Sterblichen Code, der keine eigenen Regeln für die Auflösung magischer Namen hat, also nur using std::begin;gefolgt von einem unqualifizierten Aufruf von begin(a).

Wenn Sie die Mitgliedsfunktionen implementieren und die ADL-Funktionen , sollten bereichsbasierte for-Schleifen die Elementfunktionen aufrufen, während bloße Sterbliche die ADL-Funktionen aufrufen. Stellen Sie am besten sicher, dass sie in diesem Fall dasselbe tun!

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

• Wenn ...
• Wenn range_expressiones sich um einen Ausdruck eines Klassentyps handelt C, bei dem sowohl ein Mitglied als auch beginein Mitglied benannt sind end(unabhängig vom Typ oder der Zugänglichkeit eines solchen Mitglieds), begin_exprist dies der Fall __range.begin( ) und end_exprist __range.end();
• Ansonsten begin_exprist begin(__range)und end_expristend(__range) , die über eine argumentabhängige Suche gefunden werden (eine Nicht-ADL-Suche wird nicht durchgeführt).

Bei einer bereichsbasierten for-Schleife werden zuerst Elementfunktionen ausgewählt.

Aber für

using std::begin;
begin(instance);

ADL-Funktionen werden zuerst ausgewählt.

Beispiel:

#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.
//      }
}