0. 形式

for ( declaration : expression ) statement

0.1 根据标准将会扩展成这样的形式：

1   {
2     auto&& __range = expression;
3     for (auto __begin = begin-expression,
4               __end = end-expression;
5          __begin != __end;
6          ++__begin)
7     {
8       declaration = *__begin;
9       statement
10    }
11  }

0.1.1 行3,4 ，begin 和 end 的判断规则：

The begin-expression and end-expression (lines 3 and 4) are determined as follows:

A. If expression is an array, then begin-expression and end-expressionare __range and __range + __bound, respectively, where __bound is the array bound.
B. If expression is of a class type that declares begin() and end()member functions, then begin-expression and end-expression are__range.begin() and __range.end(), respectively.
C. Otherwise, begin-expression and end-expression are begin(__range)and end(__range), respectively, where the begin() and end()functions are looked up using the argument-dependent lookup (ADL) which also includes the std namespace.

With arrays taken care of by the first rule, the second rule makes sure that all the standard containers as well as all the user-defined ones that follow the standard sequence interface will work with range-based for out of the box. For example, in ODB (an ORM for C++), we have the container-like result class template which allows iteration over the query result. Because it has the standard sequence interface with a forward iterator, we didn’t have to do anything extra to make it work with range-based for.

The last rule (the fallback to the free-standing begin()and end()functions) allows us to non-invasively adapt an existing container to the range-based for loop interface.

0.2 类型推断

std::vector<int> v = {1, 2, 3, 5, 7, 11};
const std::vector<int> cv = {1, 2, 3, 5, 7, 11};
 
for (auto x: v) // x is int
  ...;
 
for (auto x: cv) // x is int
  ...;
 
for (auto& x: v) // x is int&
  ...;
 
for (auto& x: cv) // x is const int&

1. 例子

[cpp] view plain copy

#include <iostream>
#include <vector>
int main ()
{
std::vector<int> data = { 1, 2, 3, 4 };
for ( int datum : data )
{
std::cout << datum << std::endl;
}
}

[cpp] view plain copy

/*output
1
2
3
4
*/

2. 性能上的考虑
2.1 每次循环会创建一份 a 的拷贝

for ( auto a : a_vec)

{

}

2.2 避免拷贝

for (const auto& a : a_vec)

{

}

3. 一个实现了 container semantics 的例子：

3.1 simple iterator

[cpp] view plain copy

#include <iostream>
using namespace std;
// forward-declaration to allow use in Iter
class IntVector;
class Iter
{
public:
Iter(const IntVector* p_vec, int pos)
: _pos(pos)
, _p_vec(p_vec)
{ }
// these three methods form the basis of an iterator for use with
// a range-based for loop
bool
operator!= (const Iter& other) const
{
return _pos != other._pos;
}
// this method must be defined after the definition of IntVector
// since it needs to use it
int operator* () const;
const Iter& operator++ ()
{
++_pos;
// although not strictly necessary for a range-based for loop
// following the normal convention of returning a value from
// operator++ is a good idea.
return *this;
}
private:
int _pos;
const IntVector *_p_vec;
};
class IntVector
{
public:
IntVector()
{
}
int get(int col) const
{
return _data[col];
}
Iter begin() const
{
return Iter(this, 0);
}
Iter end() const
{
return Iter(this, 100);
}
void set(int index, int val)
{
_data[index] = val;
}
private:
int _data[100];
};
int
Iter::operator* () const
{
return _p_vec->get(_pos);
}
// sample usage of the range-based for loop on IntVector
int main()
{
IntVector v;
for (int i = 0; i < 100; i++)
{
v.set(i, i);
}
for (int i : v) { cout << i << endl; }
}

3.2 reverse iterator

template <typename T>
struct reverse_range
{
private:
  T& x_;
 
public:
  reverse_range (T& x): x_ (x) {}
 
  auto begin () const -> decltype (this->x_.rbegin ())
  {
    return x_.rbegin ();
  }
 
  auto end () const -> decltype (this->x_.rend ())
  {
    return x_.rend ();
  }
};
 
template <typename T>
reverse_range<T> reverse_iterate (T& x)
{
  return reverse_range<T> (x);
}
 
std::vector<int> v = {1, 2, 3, 5, 7, 11};
 
for (auto x: reverse_iterate (v))

4. 一个完整的例子 (编译出错，说找不到容器 begin end 实现)

[cpp] view plain copy

#include <iostream>
#include <fstream>
#include <string>
#include <iterator>
#include <algorithm>
#include <unordered_map>
template<classITERATOR>
ITERATOR begin( std::pair<ITERATOR,ITERATOR> &range )
{
returnrange.first;
}
template<classITERATOR>
ITERATOR end( std::pair<ITERATOR,ITERATOR> &range )
{
returnrange.second;
}
template<classT>
std::istream_iterator<T> begin(std::istream_iterator<T> &ii_stream)
{
returnii_stream;
}
template<classT>
std::istream_iterator<T> end(std::istream_iterator<T> &ii_stream)
{
returnstd::istream_iterator<T>();
}
intmain(intargc, char* argv[])
{
std::ifstream data( "sowpods.txt");
std::unordered_map<std::string,int> counts;
std::unordered_multimap<std::string,std::string> words;
for( conststd::string &s : std::istream_iterator<std::string>( data ) )
{
std::string temp = s;
std::sort(temp.begin(), temp.end() );
counts[temp]++;
words.insert( std::make_pair(temp,s) );
}
auto ii = std::max_element( counts.begin(),
counts.end(),
[](conststd::pair<std::string,int> &v1,
conststd::pair<std::string,int> &v2)
{
returnv1.second < v2.second;
}
);
std::cout << "The maximum anagram family has " << ii->second << " members:\n";
for( constauto &map_entry : words.equal_range( ii->first ) )
std::cout << map_entry.second << " ";
std::cout << std::endl;
return0;
}

//z 2014-06-12 13:26:11 L.202'38029 BG57IV3@XCL T2508411853.K.F636940351 [T11,L175,R6,V152]
5. 一些 wrapper 或 iterator 例子

#include <memory> #include <iterator> /* Only provides the bare minimum to support range-based for loops. Since the internal iterator of a range-based for is inaccessible, there is no point in more functionality here. */ template< typename iter > struct range_iterator_reference_wrapper : std::reference_wrapper< iter > { iter &operator++() { return ++ this->get(); } decltype( * std::declval< iter >() ) operator*() { return * this->get(); } range_iterator_reference_wrapper( iter &in ) : std::reference_wrapper< iter >( in ) {} friend bool operator!= ( range_iterator_reference_wrapper const &l, range_iterator_reference_wrapper const &r ) { return l.get() != r.get(); } }; namespace unpolluted { /* Cannot call unqualified free functions begin() and end() from within a class with members begin() and end() without this hack. */ template< typename u > auto b( u &c ) -> decltype( begin( c ) ) { return begin( c ); } template< typename u > auto e( u &c ) -> decltype( end( c ) ) { return end( c ); } } template< typename iter > struct range_proxy { range_proxy( iter &in_first, iter in_last ) : first( in_first ), last( in_last ) {} template< typename

秒客网

c++11 : range-based for loop

0. 形式

相关文章