カスタムタイプを「範囲ベースのforループ」で機能させるにはどうすればよいですか？

最近の多くの人のように、私はC ++ 11がもたらすさまざまな機能を試しています。私のお気に入りの1つは、「範囲ベースのforループ」です。

という事は承知しています：

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

以下と同等です。

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

そして、それはbegin()単にa.begin()標準的なコンテナに戻ります。

しかし、カスタムタイプを「範囲ベースのforループ」に対応させるにはどうすればよいでしょうか。

私はちょうど特化すべきであるbegin()とend()？

カスタムタイプが名前空間xmlに属している場合、定義する必要がありますxml::begin()かstd::begin()？

要するに、それを行うためのガイドラインは何ですか？

質問（およびほとんどの回答）がこの欠陥レポートの解決策に掲載されて以来、標準は変更されています。

for(:)型でループを機能させるX方法は、次の2つの方法のいずれかになります。

• メンバーX::begin()を作成しX::end()、イテレーターのように機能するものを返す

• タイプと同じ名前空間で、フリー関数begin(X&)を作成しend(X&)、イテレータのように機能するものを返しますX。¹

constバリエーションについても同様です。これは、欠陥レポートの変更を実装するコンパイラと実装しないコンパイラの両方で機能します。

返されるオブジェクトは、実際にイテレータである必要はありません。for(:)ループは、C ++標準の大部分とは異なり、されに何か相当に拡大して指定します：

for( range_declaration : range_expression )

になる：

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

ここで始まる変数__は説明のためだけでありbegin_expr、/. ² end_exprを呼び出す魔法ですbeginend

begin / endの戻り値の要件は単純です。pre-をオーバーロードし++、初期化式が有効で!=あること、ブールコンテキストで使用できるバイナリ、*割り当て初期化できるものを返す単項range_declaration、およびパブリックを公開する必要があります。デストラクタ。

イテレータと互換性のない方法でこれを行うことは、おそらく悪い考えです。C++の将来の反復は、コードを壊すことに関して比較的無頓着になる可能性があるためです。

余談ですが、標準の将来の改訂では、とend_exprは異なるタイプを返すことが許可される可能性がかなりありbegin_exprます。これは、手書きのCループと同じくらい効率的に最適化するのが簡単な「遅延終了」評価（ヌル終了の検出など）を許可するという点で役立ちます。

loop for(:)ループは一時auto&&変数を変数に格納し、それを左辺値として渡すことに注意してください。一時（または他の右辺値）を反復処理しているかどうかは検出できません。このようなオーバーロードはfor(:)ループによって呼び出されません。n4527の[stmt.ranged] 1.2-1.3を参照してください。

²呼び出しのどちらかbegin/のend方法を、またはADL専用のルックアップフリー機能のbegin/ end、または Cスタイルの配列をサポートするための魔法。タイプが同じまたは依存しているオブジェクトを返さstd::beginない限り、は呼び出されないことに注意してください。range_expressionnamespace std

に c ++ 17 range-for式が更新されました

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

__beginおよびのタイプで__end分離されています。

これにより、終了反復子がbeginと同じ型にならないようにすることができます。終了反復子タイプは!=、開始反復子タイプでのみサポートされる「センチネル」にすることができます。

これは便利である理由の実用的な例は、反復子は、「あなたをチェック読むことができるあなたの最後ということでchar*、それが指すかどうかを確認するために'0'とき」==とchar*。これにより、C ++のrange-for式は、nullで終了するchar*バッファーを反復処理するときに最適なコードを生成できます。

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

C ++ 17を完全にサポートしていないコンパイラでのライブの例。forループは手動で拡張されました。

一部の人々は、STLインクルードを含まない単純な実際の例に満足している可能性があるため、私の回答を書いています。

なんらかの理由で、独自のプレーンのみのデータ配列の実装があり、範囲ベースのforループを使用したいと考えていました。これが私の解決策です：

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

次に、使用例：

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

標準の関連部分は6.5.4 / 1です。

_RangeTがクラス型の場合、クラスメンバーアクセス検索（3.4.5）の場合と同様に、クラス_RangeTのスコープで修飾されていないIDの開始と終了が検索され、いずれか（または両方）が少なくとも1つの宣言を見つけた場合、開始- exprは、エンドexprがある__range.begin()と__range.end()、それぞれ、

-そうでない場合は、開始-exprは、エンドexprがあるbegin(__range)と end(__range)、それぞれ、引数依存ルックアップ（3.4.2）を用いてルックアップされる開始と終了。この名前の検索のために、名前空間stdは関連付けられた名前空間です。

したがって、次のいずれかを実行できます。

• 定義beginおよびendメンバー関数
• ADLによって検出される関数を定義beginしてend解放します（簡易バージョン：クラスと同じ名前空間に配置します）
• 専門にstd::beginしてstd::end

std::beginbegin()とにかくメンバー関数を呼び出すので、上記の1つだけを実装した場合、どちらを選択しても結果は同じになります。これは、範囲ベースのforループの結果と同じです。また、独自の魔法の名前解決ルールを持たない単なるコードの場合も同じ結果になるためusing std::begin;、への修飾されていない呼び出しが続きbegin(a)ます。

ただし、メンバー関数と ADL関数を実装する場合、範囲ベースのforループはメンバー関数を呼び出す必要がありますが、一般の人はADL関数を呼び出します。その場合、彼らが同じことを確実に行うようにしてください！

作成しているものがコンテナーインターフェイスを実装している場合は、既にコンテナー関数begin()とend()メンバー関数があり、これで十分です。それがコンテナーではない範囲である場合（それが不変であるか、事前にサイズがわからない場合は、これは良い考えです）、自由に選択できます。

レイアウトするオプションのうち、オーバーロードしてはいけないことに注意してくださいstd::begin()。ユーザー定義型の標準テンプレートを特殊化することは許可されていますが、それ以外に、名前空間stdに定義を追加することは未定義の動作です。しかし、とにかく、部分的な関数の特殊化がないために、クラステンプレートではなく単一のクラスに対してのみそれを実行できることを意味する場合に限り、標準関数を特殊化することは適切ではありません。

begin（）とend（）だけを特化する必要がありますか？

私の知る限り、それで十分です。また、ポインタのインクリメントが最初から最後まで確実に行われるようにする必要があります。

次の例（beginとendのconstバージョンがない）はコンパイルして正常に動作します。

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

これは、関数としてbegin / endを使用する別の例です。彼らはする必要があるため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;
    }
}

std::vectorまたはstd::mapメンバーでクラスの反復を直接バックしたい場合は、そのためのコードを次に示します。

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

ここでは、「範囲ベースのforループ」で機能するカスタムタイプを作成する最も簡単な例を紹介します。

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

私のような初心者開発者に役立つことを願っています：p :)
ありがとうございます。

クリス・レッドフォードの答えは、Qtコンテナーでも機能します（もちろん）。これが適応です（私constBegin()はそれぞれconstEnd()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(); }
};

@Steve Jessopの回答の一部を詳しく説明したいのですが、最初はわかりませんでした。それが役に立てば幸い。

std::beginbegin()とにかくメンバー関数を呼び出すので、上記の1つだけを実装した場合、どちらを選択しても結果は同じになります。これは、範囲ベースのforループの結果と同じです。また、独自の魔法の名前解決ルールを持たない単なるコードの場合も同じ結果になるためusing std::begin;、への修飾されていない呼び出しが 続きbegin(a)ます。

ただし、メンバー関数 と ADL関数を実装する場合、範囲ベースのforループはメンバー関数を呼び出す必要がありますが、単なる一般の人はADL関数を呼び出します。その場合、彼らが同じことを確実に行うようにしてください！

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

• もし...
• 場合range_expressionクラス型の式であるCという名前のメンバの両方有するbeginと名付け部材end次いで、（種類に関係なく、またはそのような部材のアクセシビリティのを）begin_exprである __range.begin(）とend_exprです__range.end()。
• それ以外の場合は、begin_expris begin(__range)およびend_exprisですend(__range)。これらは、引数に依存するルックアップによって検出されます（非ADLルックアップは実行されません）。

範囲ベースのforループの場合、メンバー関数が最初に選択されます。

しかし

using std::begin;
begin(instance);

ADL関数が最初に選択されます。

例：

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