Stl Algorithms

By the end of this lesson you'll replace hand-written loops with the C++ Standard Library's algorithm and numeric tools — sorting with your own rules, searching, summing, transforming, and safely deleting elements — using one line where you used to write fifteen.

Learn Python, JavaScript, Java and more with free interactive lessons, real projects and AI-powered help. Beginner-friendly.

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Think of STL algorithms as power tools . You could cut every plank with a hand saw (your own for loop), but a builder reaches for the right power tool: a circular saw to cut ( sort ), a stud finder to locate ( find ), a tape measure to total up ( accumulate ). Each tool clamps onto a stretch of work — that's the iterator range , from begin() to end() . You supply the rule (a lambda : "cut here", "keep this one") and the tool does the repetitive work, faster and with fewer mistakes than doing it by hand.

1. Sort, Find & Count

std::sort rearranges a range in place — ascending by default. To sort by your rule, pass a third argument: a comparator . A comparator is a lambda that takes two elements and returns a bool answering one question — "should a come before b ?" Return a b and you've flipped it to descending. find hunts for an exact value and hands back an iterator (compare it to end() to check for a miss), while count and count_if tally matches. Read this worked example, run it, then you'll write your own.

Your turn. The program below is almost complete — fill in the two blanks marked ___ using the hints, then run it and check it against the expected output.

2. Accumulate, Transform & for_each

std::accumulate (from numeric , not algorithm ) folds a whole range into a single value — its third argument is both the starting total and the type of the result. std::transform applies a function to every element and writes the results into another range. std::for_each runs an action on each element without producing a new range. And min_element / max_element return an iterator to the smallest or largest value — remember to dereference it with * to read the value out.

Now you try. Total a list of workout minutes, then convert each one to hours. Fill in the two blanks — watch the type on the accumulate seed and the division:

3. Deleting Elements: the Erase-Remove Idiom

This is the one that surprises everybody. std::remove and std::remove_if do not actually delete anything . An algorithm only sees a pair of iterators — it has no power to resize the container. So remove just shuffles the elements you're keeping to the front and returns an iterator to the new logical end ; the leftover slots are still there. To truly shrink the container you pass that iterator to the container's own erase() method. Doing both together is the famous erase-remove idiom .

No blanks this time — just a brief and an outline to keep you on track. Combine sort , min_element / max_element , accumulate , and count_if into one small report. Build it, run it, and check your output against the example in the comments.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary