Search

16.4 — STL algorithms overview

In addition to container classes and iterators, STL also provides a number of generic algorithms for working with the elements of the container classes. These allow you to do things like search, sort, insert, reorder, remove, and copy elements of the container class.

Note that algorithms are implemented as functions that operate using iterators. This means that each algorithm only needs to be implemented once, and it will generally automatically work for all containers that provides a set of iterators (including your custom container classes). While this is very powerful and can lead to the ability to write complex code very quickly, it’s also got a dark side: some combination of algorithms and container types may not work, may cause infinite loops, or may work but be extremely poor performing. So use these at your risk.

STL provides quite a few algorithms -- we will only touch on some of the more common and easy to use ones here. The rest (and the full details) will be saved for a chapter on STL algorithms.

To use any of the STL algorithms, simply include the algorithm header file.

min_element and max_element

The std::min_element and std::max_element algorithms find the min and max element in a container class. std::iota generates a contiguous series of values.

Prints:

0 5

find (and list::insert)

In this example, we’ll use the std::find() algorithm to find a value in the list class, and then use the list::insert() function to add a new value into the list at that point.

This prints the values

0 1 2 8 3 4 5

When a searching algorithm doesn’t find what it was looking for, it returns the end iterator.
If we didn’t know for sure that 3 is an element of li, we’d have to check if std::find found it before we use the returned iterator for anything else.

sort and reverse

In this example, we’ll sort a vector and then reverse it.

This produces the result:

-5 -3 0 2 4 6 7
7 6 4 2 0 -3 -5

Alternatively, we could pass a custom comparison function as the third argument to std::sort. There are several comparison functions in the <functional> header which we can use so we don’t have to write our own. We can pass std::greater to std::sort and remove the call to std::reverse. The vector will be sorted from high to low right away.

Note that std::sort() doesn’t work on list container classes -- the list class provides its own sort() member function, which is much more efficient than the generic version would be.

Conclusion

Although this is just a taste of the algorithms that STL provides, it should suffice to show how easy these are to use in conjunction with iterators and the basic container classes. There are enough other algorithms to fill up a whole chapter!

17.1 -- std::string and std::wstring
Index
16.3 -- STL iterators overview

42 comments to 16.4 — STL algorithms overview

  • masterOfNothing

    Hi,
    regarding the code line

    What kind of type does it return?

    I could only check its returned value by

  • Andrei

    Hi,

    In the last example:

    std::sort(vect.begin(), vect.end()); // sort the list
    std::reverse(vect.begin(), vect.end()); // reverse the list

    Comment should say sort the vector!?

    Thanks for lessons! Keep it up!!!

    • nascardriver

      You can think of a vector as a list, so I wouldn't say to comment is wrong. However in the context of the lesson, I agree that it can be confusing. I'll update the lesson later, thanks for pointing it out :)

      EDIT: Lesson amended, thanks again

  • Atas

    The second paragraph says "algorithms are implemented as global functions", but the examples use `std::sort()` and `std::reverse()`, which one is true?

  • Jörg

    Hi, thanks again for all the tutorials :D They really got me started with programming :D Btw, are there any topics about type traits or metaprogramming coming?

  • lucieon

    where is the chapter on STL algorithms you mentioned in the above tutorial?

  • Pharap

    As others have pointed out, iterators should use pre-increment operators.
    The post-increment version can be more expensive if the iterator is expensive to copy because post-increment implicitly creates a copy.
    The compiler may not be able to elide that copy.

    • Alex

      Lesson updated. This whole chapter is due for a serious revision pass.

      • Pharap

        Thank you, much appreciated.

        Hopefully you'll be pleased to hear that I regularly recommend this tutorial because of its attention to the more modern features of C++ (i.e. from C++11 onwards).

        • Alex

          Thanks! On this note, I'm doing another full pass on the existing lessons to add new stuff and integrate best practices. So even more C++11/14/17 goodness will be coming over the next months and year!

    • Hi Pharap,

      >> "As others have pointed out, iterators should use pre-increment operators."

      I don't see anyone else, at least in this chapter, having pointed out this fact. It would be of great help to fellow learners if you or someone else could explain why pre-increment of iterators is better than post. How are the two any different from each other?

      I know that a = ++b is different from a = b++. But if there's no assignment going on, then how is b++ different from ++b? In both cases, 'b' would become 'b + 1'.

      • Hi Nitin!

        Recap: The ++prefix operator returns the value after incrementing it. The postfix++ operator returns the value before incrementing it.

  • DecSco

    Somehow, the code in the article doesn't look like it's from you, with that using directive and nCount++ instead of ++nCount.
    Maybe you're too busy, so here you go:

    or alternatively

    Same for the next example:

    or

    and here's the last one:

    or

  • Jaideep

    When will be the full chapter on STL algorithm be available online?

  • Hashem Omar

    can't wait for the STL algorithms chapter.

  • Youssef Abdullah

    What's wrong with my code? Please help I'm trying to replace a pair.

    • bouchra

      I corrected your program

      #include <iostream>
      #include <string>
      #include <map>
      #include <algorithm>
      using namespace std;
      int main()
      {
          map<int,string> items;
          items.insert(make_pair(5,".orange"));
          items.insert(make_pair(6,".apple"));
          items.insert(make_pair(1,".grape"));
          
          map<int,string>::iterator counter;
          //counter = find(items.begin(),items.end(),make_pair(1,".grape"));
          counter=items.find(1);  // you have to find value by key
         // map<int,string>::iterator counterx;
          items.insert(counter,make_pair(54,".step"));
          map<int,string>::iterator counterxx;
          for(counterxx = items.begin();counterxx != items.end();counterxx++){ // counterxx not counter
              cout<<counterxx->first<<counterxx->second<<endl;
          }

          return 0;

      }
      Here is the result of the program. I made some remarks about your program.
      Here is the result of the program.
      Output:
      1.grape
      5.orange
      6.apple
      54.step

  • Lokesh

    Section "find (and list::insert)", in code, line-12:
    We cannot use const_iterator because we are changing(both read and write operations are performed) the container class through the iterator. Using const_iterator produces a bunch of error that basically complains about 'not being able to find a suitable insert() for std::list<int>::const_iterator it' and other conversions. Using list<int>::iterator solves the problem:

  • Matt

    Typo ("it's" should be "its"): "...the list class provides it’s own sort() member function..."

  • Matheus

    I'm trying to substitute the for loops for while loops in the last example, but I am having no success. Is there anyone who can help me with this? Thanks!

    -- Edit

    The first one is working, while the second one not! I'm having an assertion error telling me that the vector operator is not dereferencable.

    Code:

    #include
    #include
    #include
    int main()
    {
    using namespace std;

    vector vect;
    vect.push_back(7);
    vect.push_back(-3);
    vect.push_back(6);
    vect.push_back(2);
    vect.push_back(-5);
    vect.push_back(0);
    vect.push_back(4);

    sort(vect.begin(), vect.end()); // sort the list

    vector::const_iterator it; // declare an iterator
    it = vect.begin();
    while (it != vect.end())
    {
    cout << *it << " ";
    it++;
    }
    cout << endl;
    reverse(vect.begin(), vect.end()); // reverse the list
    for (it = vect.begin(); it != vect.end(); it++)
    {
    cout << *it << " ";
    }
    cout << endl;
    }

    • wafflethebunny

      Here's a working implementation:

  • Adi

    These tutorials are Great!!!

    Can you please add tutorials on the new features in c++14.

    Also it would be great to have tutorials on uses of specific header files. Like a tutorial on <i>graphics</i> header file.

  • Jason Li

    Dear Alex,

    I have read through all your tutorials twice already and I still come back frequently for references, just because this is so good for someone who does not have a CS background like me. Now I am really looking forward to your STL algorithm chapters that you mentioned earlier as well as any other materials. However it looks like this site is not updated since about 2 years ago, so I am kinda wondering if you are still going to add in more materials as you said.
    Thank you again and best wishes.

  • Parpwhick

    Just a minor typo, you wrote "provides it’s own sort() member function" instead of "its"

  • vamsi krishna

    Dear Alex,

    Also there is much left in STL.
    Please do provide tutorials on STL in C++ in more detail

  • vamsi krishna

    Dear Alex,

    When are you starting with Data Structures in C++?
    Please provide us tutorials for data structures in c++

  • hylepo

    Hi, man, when I was trying to compile the find code. g++ said "find.cpp: In function ‘int main()’:
    find.cpp:15:20: error: no matching function for call to ‘std::list::insert(std::list::const_iterator&, int)’
    find.cpp:15:20: note: candidates are:
    /usr/include/c++/4.6/bits/list.tcc:99:5: note: std::list::iterator std::list::insert(std::list::iterator, const value_type&) [with _Tp = int, _Alloc = std::allocator, std::list::iterator = std::_List_iterator, std::list::value_type = int]
    /usr/include/c++/4.6/bits/list.tcc:99:5: note: no known conversion for argument 1 from ‘std::list::const_iterator {aka std::_List_const_iterator}’ to ‘std::_List_iterator’
    /usr/include/c++/4.6/bits/stl_list.h:1095:7: note: void std::list::insert(std::list::iterator, std::list::size_type, const value_type&) [with _Tp = int, _Alloc = std::allocator, std::list::iterator = std::_List_iterator, std::list::size_type = unsigned int, std::list::value_type = int]
    /usr/include/c++/4.6/bits/stl_list.h:1095:7: note: candidate expects 3 arguments, 2 provided
    /usr/include/c++/4.6/bits/stl_list.h:1116:9: note: template void std::list::insert(std::list::iterator, _InputIterator, _InputIterator) [with _InputIterator = _InputIterator, _Tp = int, _Alloc = std::allocator, std::list::iterator = std::_List_iterator]

    and I need to

    #include
    #include
    #include

    int main()
    {
    using namespace std;

    list li;
    for (int nCount=0; nCount < 6; nCount++)
    li.push_back(nCount);

    //list::const_iterator it; // declare an iterator
    _List_iterator it; // declare an iterator
    it = find(li.begin(), li.end(), 3); // find the value 3 in the list
    li.insert(it, 8); // use list::insert to insert the value 8 before it

    for (it = li.begin(); it != li.end(); it++) // for loop with iterators
    cout << *it << " ";

    cout << endl;
    }
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    ~
    "find.cpp" 22L, 572C 1,1 All

    "

    to satisfy the compiler,

Leave a Comment

Put all code inside code tags: [code]your code here[/code]