Как сделать мой пользовательский тип для работы с"диапазоном на основе циклов"?

соответствующая часть стандарта составляет 6.5.4 / 1:

если _RangeT является типом класса, то безусловные идентификаторы begin и end являются посмотрел в области класса _RangeT, как будто по доступу к члену класса поиск (3.4.5), и если один (или оба) находит хотя бы одно объявление, начать - и конца выражение-выражение-это:__range.begin() и __range.end(), соответственно;

- в противном случае, начать-и конца выражение-выражение-это:begin(__range) и end(__range), соответственно, где начало и конец посмотрел с поиск, зависящий от аргумента (3.4.2). Для целей настоящего названия lookup, namespace std-это связанное пространство имен.

Итак, вы можете сделать любое из следующих действий:

• определение begin и end функции-члены
• определение begin и end свободные функции, которые будут найдены ADL (упрощенная версия: поместите их в то же пространство имен, что и класс)
• специализация std::begin и std::end

std::begin называет begin() функция-член в любом случае, так что если вы реализуете только один из вышеперечисленных, то результаты должны быть одинаковыми независимо от того, какой из них вы выберете. Это те же результаты для циклов for на основе ranged, а также тот же результат для простого смертного кода, который не имеет собственных правил разрешения магических имен, поэтому просто делает using std::begin; после чего следует безусловный вызов begin(a).

если вы реализуете функции-члены и функции ADL, однако, тогда основанные на диапазоне для циклов должны вызывать функции-члены, тогда как простые смертные будут вызывать функции ADL. Лучше убедиться, что они делают то же самое в этом случае!

если вещь, которую вы пишете реализует интерфейс контейнера, то он будет иметь begin() и end() функции-члены уже должно быть достаточно. Если это диапазон, который не является контейнером (что было бы хорошей идеей, если это невозможно или если вы не знаете, размер спереди), вы можете выбрать.

из вариантов, которые вы выкладываете, обратите внимание, что вы не должен перегрузка std::begin(). Вам разрешено специализировать стандартные шаблоны для пользовательского типа, но помимо этого добавление определений в пространство имен std является неопределенным поведением. Но в любом случае, специализация стандартных функций является плохим выбором хотя бы потому, что отсутствие частичной специализации функций означает, что вы можете сделать это только для одного класса, а не для класса шаблон.

должен ли я просто специализироваться begin() и end() ?

насколько я знаю, этого достаточно. Вы также должны убедиться, что приращение указателя от начала до конца.

следующий пример (отсутствует const версия begin и end) компилируется и работает нормально.

#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 as. Они обязательно находиться в том же пространстве имен, что и класс, из-за 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;
    }
}

Я пишу свой ответ, потому что некоторые люди могут быть более счастливы с простым примером реальной жизни без STL включает.

у меня есть моя собственная простая реализация массива данных по какой-то причине, и я хотел использовать диапазон, основанный на цикле. Вот мое решение:

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

в случае, если вы хотите поддержать итерацию класса непосредственно с его 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;
}

здесь я делюсь самым простым примером создания пользовательского типа, который будет работать с " диапазон на основе цикла":

#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 (конечно). Вот адаптация (обратите внимание, что я возвращаю a 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(); }
};