Introduction
C++0x was recently furnished with new algorithms. Some of them fill in gaps in the C++03 Standard Library whereas others are convenience algorithms that simplify recurrent programming tasks by using more intuitive parameter lists and a cleaner interface. In the following sections I will demonstrate 10 such algorithms, all of which save one are brand new.
New Copy Algorithms
The classic copy algorithms, e.g., copy(), uninitialized_copy() etc., take two iterators indicating the beginning and the end of a range, and a single output iterator marking the beginning of the output range. However, in many programming tasks, it’s more convenient to define the copy operation by specifying a starting point and a count instead of using starting and ending points. C++0x introduces a new family of copy_n() algorithms that copy n elements. Suppose you want to copy an array of 5 elements to another array. Using copy_n(), it’s simple:
#include <algorithm>
int source[5]={0,12,34,50,80};
int target[5];
//copy 5 elements from source to target
copy_n(source,5,target);
C++0x also provides a new version of uninitialized_copy() that takes a count. uninitialized_copy_n() is chiefly useful in low-level memory management operations where you want to separate the allocation of raw memory from the construction operation. The following uninitialized_copy_n() call copies a POD array to another array:
#include <algorithm>
const int n=4;
int first[n]={0,1,2,3};
int result[n];
uninitialized_copy_n(first, n, result);
Finally, copy_if() is a new convenience algorithm that selectively copies every element that satisfies the predicate p within the range [first,last). In the following example, copy_if() copies only the positive numbers from the range [first, last) to result:
#include <algorithm>
struct ispositive //predicate
{
bool operator()(int val) const {return val>=0;}
};
int first[n]={0,-1,-2,3};
int result[n]={0};
copy_if(first, first+n, result, ispositive());
All of, Any of and None of
The Standard Library now defines algorithms that mimic the set theory operations all_of(), any_of() and none_of(). Given a range and a predicate p, the algorithm determines whether p is true for:
- All of the elements within the range (all_of()).
- At least one element within the range (any_of()).
- No elements within the range (none_of()).
The following examples apply the predicate ispositive() to the range [first, first+n) and uses all_of(), any_of() and none_of() to examine the range’s properties:
#include <algorithm>
//are all of the elements positive?
all_of(first, first+n, ispositive()); //false
//is there at least one positive element?
any_of(first, first+n, ispositive());//true
// are none of the elements positive?
none_of(first, first+n, ispositive()); //false
Partition
A range whose elements that satisfy a certain predicate precede the elements that fail to satisfy it is a partition. C++03 defines the partition() algorithms for partitioning a range. C++0x introduced the new algorithm is_partitioned() that examines whether a given range makes a valid partition. The following listing examines whether a given range is a partition. If it’s not, it calls partition() and examines the range again:
if(!is_partitioned(first, first+n, ispositive()));
partition(first, first+n, ispositive());
bool b=
is_partitioned(first, first+n, ispositive());//now true
To detect the partition point in a partitioned range, use the new algorithm partition_point(). partition_point() returns an iterator to the first element that doesn't satisfy the specified predicate:
int firstnegative=
*(partition_point(first, first+n, ispositive()));
Iota
The new algorithm iota() was inspired by an APL operator with the same name. iota() creates a range of sequentially increasing values, as if by assigning an initial value to *first, then incrementing that value using prefix ++. iota() takes two iterators marking a range, and an initial value. This algorithm is particularly useful for testing since permutations of {1, 2,…N} are frequently used as test input. In the following example, iota() assigns the consecutive values {10,11,12,13,14} to the array arr, and {‘a’, ‘b’, ‘c’} to the char array c. Notice that you need to #include <numeric> to use iota():
include <numeric>
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}
Conclusion
Technically speaking, some of the algorithms that I’ve presented seem redundant since you can achieve the same result by using a different algorithm and a different list of arguments. For example, copy_if() is the inverse of remove_copy_if(). That is, copying all elements that satisfy a predicate p is the same as not copying all elements that satisfy !p. However, it’s more convenient and certainly less confusing to use copy_if() directly. A complete list of the new Standard Library algorithms is available here. With respect to vendors’ support, Microsoft’s Visual Studio 2010 already supports all of the algorithms exemplified above. Other implementations support these algorithms partially so you should check the documentation of your implementation’s Standard Library.