dcsimg

C++ Tutorial: 10 New STL Algorithms That Will Make You A More Productive Developer

WEBINAR:
On-Demand

Application Security Testing: An Integral Part of DevOps


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:

  1. All of the elements within the range (all_of()).
  2. At least one element within the range (any_of()).
  3. 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.

Related Articles





Comments

  • programming

    Posted by asad on 08/11/2016 10:36am

    This blog awesome and i learn a lot about programming from here.The best thing about this blog is that you doing from beginning to experts level. Love from Pprogramming

    Reply
  • You must have javascript enabled in order to post comments.

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • A CRM solution holds a wealth of information and document generation tools allow users to take that information and create documents with both visual appeal and function. Document generation is the process of automatically producing a file and document generation applications save companies time, mistakes, and money. You bought Salesforce to be more efficient — why are you still manually creating proposals, contracts, invoices, and account plans? Read this eBook to learn how you can automate virtually …

  • The Internet of Things (IoT), a growing network of physical devices with Internet connectivity, can collect and exchange rich data. Organizations utilizing the Enterprise of Things (EoT) are also at a greater risk for data breaches and cybersecurity threats. Healthcare organizations striving to realize the full potential of the EoT must also be able to confidentially and reliably transmit highly sensitive data between connected devices. Read this white paper to discover the best cybersecurity strategies to get …

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date
×
We have made updates to our Privacy Policy to reflect the implementation of the General Data Protection Regulation.