Administrace komentářů

Začal bych od jednoduchého příkladu — implicitní iterace po slovech. To se zařídí třeba takhle:

#include <fstream>
#include <iostream>
#include <iterator>
#include <string>

namespace {

template<typename C>
struct ifstream_iterable {
  ifstream_iterable(const std::string &path) : stream_{path} {}
  auto begin() { return iterator{stream_}; }
  auto end() { return iterator{}; }
 private:
  typedef std::istream_iterator<std::basic_string<C>, C> iterator;
  std::basic_ifstream<C> stream_;
};

}  // namespace

int main() {
  for (auto &w : ifstream_iterable<wchar_t>{"/proc/cpuinfo"})
    std::wcout << w << std::endl;
}

To bychom měli. Teď je otázka, jak z toho^^^ udělat iteraci po řádcích. Předně pár poznámek k tématu:

• Tvůj příklad s operátorem >> je mírně špatně v mezích zákona, protože deklarace je hodně podobná této deklaraci v headeru <string>, což sice na první pohled nevadí, ale na druhý pohled tam hraje roli až příliš mnoho složitých detailů kolem pravidel pro hledání identifikátorů. Drobná změna standardu a/nebo (kni)hovny může vést k tomu, že operátor se buď vůbec nepoužije, nebo začne být v konfliktu s operátory z (kni)hovny. Drobnou modifikací se mi podařilo vyrobit (proti)příklad, kdy clang++ i g++ kód přeloží bez varování, ale g++ „přetížený“ operátor použije, zatímco clang++ nikoliv.
• Jedno (nechvalně) známé řešení ze Zásobníkovéhopřetečení sice vypadá na první pohled hezky a jednoduše, ale vyskytují se v něm tři poněkud nepříjemné a sporné nápady:

  • soukromá dědičnost (která se tu a tam hodí, ale tenhle případ není ani tu, ani tam)
  • kámoši (kterým je ideální se vyhnout, protože všeho všudy ukazují na chybu v návrhu (zapouzdření atd.))
  • dědění od std::string (což je sice technicky možné, ale z hlediska kompatibility a udržovatelnosti kódu je vhodné se takových nápadů vyvarovat)

Co tedy podniknout? Třeba tohle:

#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <utility>

namespace {

template <typename C>
struct line {
  std::basic_istream<C>& operator <<(std::basic_istream<C> &stream) {
    std::getline(stream, str_);
    return stream;
  }
  operator const std::basic_string<C>&() const & { return str_; }
  operator std::basic_string<C>&() & { return str_; }  // zde se nepoužije
  operator std::basic_string<C>() && { return std::move(str_); }  // -dtto-
 private:
  std::basic_string<C> str_;
};

template <typename C>
std::basic_istream<C>& operator >>(std::basic_istream<C> &stream,
                                   line<C> &str) {
  str << stream;
  return stream;
}

template<typename C>
struct ifstream_iterable {
  ifstream_iterable(const std::string &path) : stream_{path} {}
  auto begin() { return iterator{stream_}; }
  auto end() { return iterator{}; }
 private:
  typedef std::istream_iterator<line<C>, C> iterator;
  std::basic_ifstream<C> stream_;
};

}  // namespace

int main() {
  for (const std::wstring &l : ifstream_iterable<wchar_t>{"/proc/cpuinfo"})
    std::wcout << l << std::endl;
}

Tohle^^^ nedědí od základních typů, nevyvolává příliš mnoho nespecifikovaných rohových případů, nepoužívá kámoše a vystačí si s jednou třídou (dělnickou), kterou lze konvertovat na odpovídající string. (Pro složitější konverze do jiného API si lze napsat deduction guides, ale to už je jiné téma. V této podobě se kód přeloží s C++ 14, 17 i 20, zatímco s deduction guides by vyžadoval minimálně C++17.)

Ještě závěrem dodám (a předejdu tak, doufám, některým komentářům), že někteří lidé mají utkvělou špatnou představu o sousloví return std::move(...); — myslí si, že něco takového nedává smysl a že by to nemělo existovat. Samozřejmě se mýlí, jak jinak; tady jsou k tomu předdrobnosti i podrobnosti.