RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX


To Iterate Is Human, to Range Is Divine-2 : Page 2

You can construct a range from a pair of iterators, by copying an existing range object or by default constructing an empty range whose iterators are singular. A singular iterator is similar to a NULL pointer; the only safe operation that you can perform on a singular iterator is assigning a new value to it.

Author's Note: There are currently two range libraries. The Boost range library is ready for immediate download and use with any existing C++ compiler. However, this 10 Minute Solution will exclusively use the range library that is currently being incorporated into the C++09 standard. The differences between these two libraries aren't great anyway. I prefer the standard version because that's what most C++ users will have at their disposal in the near future.

The range classes and functions are declared in the augmented standard header <iterator>. All range functions are preceded by range_ to make them distinct from the traditional iterator-based functions. A complete list of the range library functions is available in the official C++09 proposal. For the sake of brevity, I will show only a few illustrative examples here.

The range_make() helper function creates a range from a pair of iterators:

std::vector <double> results;
//...populate the vector
std::range results_range=std::make_range(myvec.begin(), myvec.end());
To copy a range object you can use a copy constructor as usual, or the copy_range() helper function:

template<class CopyableRange, class Range>      
 CopyableRange copy_range(const Range& r);
std::range another_range=std::copy_range(results_range);
//copy ctor version:
std::range yet_another_range(another_range); 
Finally, creating an empty range is trivial:

std::range empty_range; //fill it later
Accessing a Range
The range library defines functions for accessing a range's iterators and modifying them. In addition, it includes a set of overloaded operators such as ==, != for comparing ranges and sub-ranges.

The beginning of a range is equivalent to the first of the two iterators of a range. To extract that iterator, use range_begin(). Notice that this function assumes two other C++09 proposals, namely rvalue-references, and auto and decltype:.

template< class Range > auto range_begin( Range&& r ) -> decltype( r.begin() );
This C++09 syntax is a bit unfamiliar yet but the meaning is self-evident: range_begin() takes an rvalue reference to a range object r (recall that Range in this context is a template parameter). It returns an object whose type is that of the expression r.begin(). In simpler words, it returns an iterator that designates the beginning of the range.

In a similar vein, call range_end() to extract the end of the range:

template< class Range > auto range_end( Range&& r ) -> decltype( r.end());

vector::iterator vbeg=range_begin(results_range), 

Close Icon
Thanks for your registration, follow us on our social networks to keep up-to-date