Vorbereitung für veraltete std :: iterator

Am 21. März ^st stimmte der Normenausschuss der deprecation von genehmigen std::iteratorvorgeschlagen in P0174 :

Die lange Folge von ungültigen Argumenten ist für den Leser viel weniger klar als die bloße typedefAngabe der erwarteten s in der Klassendefinition selbst. Dies ist der Ansatz des aktuellen Arbeitsentwurfs nach dem festgelegten Musterc ++ 14

Vor c ++ 17Die Vererbung von std::iteratorwurde ermutigt, die Langeweile bei der Implementierung des Iterator-Boilerplates zu beseitigen. Die Abwertung erfordert jedoch eines der folgenden Dinge:

1. Ein Iterator-Boilerplate muss nun alle erforderlichen typedefs enthalten
2. Algorithmen, die mit Iteratoren arbeiten, müssen jetzt verwendet werden, autoanstatt vom Iterator abhängig zu sein, um Typen zu deklarieren
3. Loki Astari hat vorgeschlagen , std::iterator_traitsdass aktualisiert werden kann, um zu funktionieren, ohne von zu erbenstd::iterator

Kann mir jemand erklären, welche dieser Optionen ich erwarten sollte, wenn ich benutzerdefinierte Iteratoren mit Blick auf entwerfe c ++ 17 Kompatibilität?

Die besprochenen Alternativen sind klar, aber ich bin der Meinung, dass ein Codebeispiel benötigt wird.

Da es keinen Sprachersatz gibt und Sie sich nicht auf Boost oder Ihre eigene Version der Iterator-Basisklasse verlassen müssen, wird der folgende verwendete Code std::iteratorauf den darunter liegenden Code festgelegt.

Mit std::iterator

template<long FROM, long TO>
class Range {
public:
    // member typedefs provided through inheriting from std::iterator
    class iterator: public std::iterator<
                        std::forward_iterator_tag, // iterator_category
                        long,                      // value_type
                        long,                      // difference_type
                        const long*,               // pointer
                        const long&                // reference
                                      >{
        long num = FROM;
    public:
        iterator(long _num = 0) : num(_num) {}
        iterator& operator++() {num = TO >= FROM ? num + 1: num - 1; return *this;}
        iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
        bool operator==(iterator other) const {return num == other.num;}
        bool operator!=(iterator other) const {return !(*this == other);}
        long operator*() {return num;}
    };
    iterator begin() {return FROM;}
    iterator end() {return TO >= FROM? TO+1 : TO-1;}
};

(Code von http://en.cppreference.com/w/cpp/iterator/iterator mit Genehmigung des ursprünglichen Autors).

Ohne std::iterator

template<long FROM, long TO>
class Range {
public:
    class iterator {
        long num = FROM;
    public:
        iterator(long _num = 0) : num(_num) {}
        iterator& operator++() {num = TO >= FROM ? num + 1: num - 1; return *this;}
        iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
        bool operator==(iterator other) const {return num == other.num;}
        bool operator!=(iterator other) const {return !(*this == other);}
        long operator*() {return num;}
        // iterator traits
        using difference_type = long;
        using value_type = long;
        using pointer = const long*;
        using reference = const long&;
        using iterator_category = std::forward_iterator_tag;
    };
    iterator begin() {return FROM;}
    iterator end() {return TO >= FROM? TO+1 : TO-1;}
};

Option 3 ist eine streng typisierende Version von Option 1, da Sie alle gleich schreiben müssen, typedefsaber zusätzlich umbrechen müssen iterator_traits<X>.

Option 2 ist als Lösung unrentabel. Sie können einige Typen ableiten (z. B. referenceist nur decltype(*it)), aber Sie können nicht ableiten iterator_category. Sie können nicht zwischen input_iterator_tagund forward_iterator_tageinfach durch das Vorhandensein von Operationen unterscheiden, da Sie nicht reflexartig prüfen können, ob der Iterator die Multipass-Garantie erfüllt. Außerdem können Sie nicht wirklich zwischen diesen unterscheiden und output_iterator_tagob der Iterator eine veränderbare Referenz liefert. Sie müssen explizit irgendwo angegeben werden.

Damit bleibt Option 1. Ich denke, wir sollten uns nur daran gewöhnen, die gesamte Boilerplate zu schreiben. Zum einen begrüße ich unsere neuen Karpaltunnel-Oberherren.