C++ std::ranges custom view

[Vincent H. (vinci)]

Grüß euch

Ich bin gerade dabei meine ersten Zeilen "Ranges" Code zu schreiben. 
Konkret interessiert mich wie man eigene Views erzeugt und diese mit 
anderen Algorithmen kombinierbar macht. Als Beispiel hab ich mir dafür 
einen "toupper_view" überlegt, der eine Range von Buchstaben nimmt und 
diese als Großbuchstaben wieder ausspuckt.

Soweit sogut. Die erste Version die ich geschrieben hab funktioniert 
auch wunderbar. Es gibt einen
- toupper_view

sowie einen nested
- toupper_view::iterator

Um möglichst wenig Code zu duplizieren hab ich in der ersten Fassung vom 
Iterator Typen der übergebenen Range abgeleitet. Das ist im Regelfall 
der __normal_iterator aus der Standardbibliothek.

Hier der Vollständigkeit halber mal der Iterator Code:

template <typename Rng>
struct toupper_view<Rng>::iterator : ranges::iterator_t<Rng> {
  using base = ranges::iterator_t<Rng>;
  using value_type = typename ranges::range_value_t<Rng>;

  iterator() = default;

  iterator(base const& b) : base{b} {}

  iterator operator++(int) { return static_cast<base&>(*this)++; }

  iterator& operator++() {
    ++static_cast<base&>(*this);
    return (*this);
  }

  value_type operator*() const {
    return std::toupper(*static_cast<base>(*this));
  }
};

Nun wollte ich zum Üben die Basisklasse aus der Standardbibliothek 
loswerden und hab einen zweiten Iterator ohne Abhängigkeiten 
geschrieben. Jener Iterator arbeitet jedoch nicht mit Pointern sondern 
nimmt die gesamte Range sowie eine Größe als Eingangsparameter.

template <typename Rng>
struct toupper_view<Rng>::iterator {
  using value_type = typename ranges::range_value_t<Rng>;

  iterator() = default;

  iterator(Rng rng, size_t count) : rng_{rng}, count_{count} {}

  iterator operator++(int) {
    iterator const retval{*this};
    ++count_;
    return retval;
  }

  iterator& operator++() {
    ++count_;
    return *this;
  }

  value_type operator*() const { return std::toupper(rng_[count_]); }

  bool operator==(iterator const& rhs) const { return count_ == rhs.count_; }

  bool operator!=(iterator const& rhs) const { return count_ != rhs.count_; }

 private:
  Rng rng_{};
  size_t count_{};
};

Leider funktioniert der zweite Iterator nur teilweise. Er tut zwar 
prinzipiell wie gewollt, lässt sich jedoch nicht mit anderen 
Range-Algorithmen kombinieren. Er besteht auch weder das Range-, noch 
das View-Concept (siehe https://en.cppreference.com/w/cpp/ranges)...

Konkret dürfte es ihn hierbei aufstellen:

template< class T >
concept __RangeImpl = requires(T&& t) {
  ranges::begin(std::forward<T>(t)); // equality-preserving for forward iterators
  ranges::end  (std::forward<T>(t));
};

// ->
// begin(static_cast<T&&>(t))' would be ill-formed
// end(static_cast<T&&>(t))' would be ill-formed

Ich versteh nur leider überhaupt nicht wieso?


Hier ist der gesamte Code auf godbolt zu finden:
https://godbolt.org/z/BZe6W9

Mit dem Macro "USE_ITERATOR" lässt sich zwischen den beiden Iteratoren 
umschalten.

[M.K. B. (mkbit)]

Ich habe selbst noch nie aktive mit Ranges gearbeitet, aber ein sehr 
gutes Verständnis von C++17.
Wenn etwas unverständlich ist, dann bitte gerne nachfragen.

In C++ wurden die Funktionen std::begin und std::end eingeführt, um 
einen allgemeinen Weg zu haben sich einen Iterator zu besorgen. Damit 
war es möglich z.B. std::vector<char> und char[] beim abholen des 
Iterators gleich zu behandeln. Mit auto ergibt sich damit der Typ aus 
dem Rückgabewert von begin/end. Ich meine, dass auch range based for 
darauf aufbaut.

Das concept beschwert sich in deinem Fall, dass dein Iterator ohne 
Basisklasse nicht bei begin/end als Parameter übergeben werden kann. 
Vermutlich bekommst du dies durch die Ableitung von 
ranges::iterator_t<Rng>. Mir ist dabei aber unklar, ob der Aufruf von 
operator* dann ranges::iterator_t::operator* oder 
toupper_view::operator* aufruft.
Ich habe aber gerade leider keinen Compiler zur Hand, wo ich das testen 
könnte.

Falls es dir darum geht, die Iteratoren für ranges besser zu verstehen 
kann ich dir leider nicht weiterhelfen.

Für deinen konkreten Fall würde ich aber ein transform für die range 
nehmen, weil du ja die Daten transformieren möchtest. std::toupper 
konnte ich aber nicht direkt aufrufen, sondern musste es in ein lambda 
verpacken, aber ich weiß nicht warum.

Dieses Beispiel kompiliert im Compiler Explorer, aber ich weiß nicht, ob 
es auch das tut, was ich erwarte.

#include <stl2/view/transform.hpp>

auto rng = str | ranges::views::transform([](char c){return std::toupper(c);});

[Vincent H. (vinci)]

Mein View besitzt sowohl begin als auch end. Der Iterator selbst 
natürlich nicht, wozu auch?

Und ja, natürlich könnte man transform nutzen, aber das ist nicht Sinn 
der Übung.


Übrigens bestzt Compiler Explorer mittlerweile auch einen Output. Somit 
kann man den auch direkt zum Testen nutzen. ;)

[Vincent H. (vinci)]

Iterator traits haben gefehlt (difference_type, value_type, pointer, 
reference, iterator_category).