像许多人一样，这些天我一直在尝试c++ 11带来的不同特性。我最喜欢的是“基于范围的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() ?
简而言之，这样做的指导方针是什么?
当前回答
受到BitTickler关于如何使它适用于非“容器”类型的评论的启发，这里有一个适用于双精度对象的最小示例:
class dranged {
double start, stop, step, cur;
int index;
public:
dranged(double start, double stop, double step) :
start(start), stop(stop), step(step),
cur(start), index(0) {}
auto begin() { return *this; }
auto end() { return *this; }
double operator*() const { return cur; }
auto& operator++() {
index += 1;
cur = start + step * index;
return *this;
}
bool operator!=(const dranged &rhs) const {
return cur < rhs.stop;
}
};
注意，在!=操作符中使用<保持了正确的不变量，但显然假设step是正的，并且不适用于更一般的范围。我使用整数索引来防止浮点错误的传播，但在其他方面力求简单。
这可以用于:
double sum() {
double accum = 0;
for (auto val : dranged(0, 6.28, 0.1)) {
accum += val;
}
return accum;
}
GCC和Clang在进行优化编译时都能生成非常合理的代码(例如，GCC的-Os或高于-O1, Clang的-O2)。
其他回答
如果你想直接用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;
}
Chris Redford的答案当然也适用于Qt容器。下面是一个调整(注意我返回了constBegin()，分别从const_iterator方法返回constEnd()):
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(); }
};
标准的相关部分为6.5.4/1:
if _RangeT is a class type, the unqualified-ids begin and end are looked up in the scope of class _RangeT as if by class member access lookup (3.4.5), and if either (or both) finds at least one declaration, begin- expr and end-expr are __range.begin() and __range.end(), respectively; — otherwise, begin-expr and end-expr are begin(__range) and end(__range), respectively, where begin and end are looked up with argument-dependent lookup (3.4.2). For the purposes of this name lookup, namespace std is an associated namespace.
所以，你可以做以下任何一件事:
定义开始和结束成员函数 定义ADL可以找到的开始和结束自由函数(简化版本:将它们放在与类相同的命名空间中) 专门化std::begin和std::end
Std::begin调用begin()成员函数，所以如果你只实现了上面的一个，那么无论你选择哪一个，结果都应该是一样的。这对于基于范围的for循环也是一样的结果，对于没有自己神奇的名称解析规则的普通代码也是一样的结果，所以只使用std::begin;接着是开始(a)的不合格调用。
如果你实现了成员函数和ADL函数，那么基于范围的for循环应该调用成员函数，而凡人将调用ADL函数。最好确保他们在这种情况下做同样的事情!
如果您正在编写的东西实现了容器接口，那么它将已经有begin()和end()成员函数，这应该足够了。如果它是一个不是容器的范围(如果它是不可变的，或者如果你不知道前面的大小，这将是一个好主意)，你可以自由选择。
对于所布局的选项，请注意不能重载std::begin()。允许为用户定义的类型专门化标准模板，但除此之外，向名称空间std添加定义是未定义的行为。但无论如何，专门化标准函数是一个糟糕的选择，因为缺乏部分函数专门化意味着您只能为单个类而不是类模板这样做。
受到BitTickler关于如何使它适用于非“容器”类型的评论的启发，这里有一个适用于双精度对象的最小示例:
class dranged {
double start, stop, step, cur;
int index;
public:
dranged(double start, double stop, double step) :
start(start), stop(stop), step(step),
cur(start), index(0) {}
auto begin() { return *this; }
auto end() { return *this; }
double operator*() const { return cur; }
auto& operator++() {
index += 1;
cur = start + step * index;
return *this;
}
bool operator!=(const dranged &rhs) const {
return cur < rhs.stop;
}
};
注意，在!=操作符中使用<保持了正确的不变量，但显然假设step是正的，并且不适用于更一般的范围。我使用整数索引来防止浮点错误的传播，但在其他方面力求简单。
这可以用于:
double sum() {
double accum = 0;
for (auto val : dranged(0, 6.28, 0.1)) {
accum += val;
}
return accum;
}
GCC和Clang在进行优化编译时都能生成非常合理的代码(例如，GCC的-Os或高于-O1, Clang的-O2)。
在这里，我将分享一个创建自定义类型的最简单的例子，它将与“基于范围的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:) 谢谢你！
