C++ Iterators and Standard Algorithms

An iterator refers to a position in a sequence. begin() refers to the first element and end() to the sentinel after the last. Algorithms use the half-open range [begin, end), which naturally represents empty sequences and adjoining subranges.

Iterators have capabilities. Vector iterators support random access; other containers may support only forward movement. Choose algorithms whose requirements match the range rather than assuming every iterator behaves like an index.

#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
  std::vector<int> values{8, 3, 12, 3};
  auto found = std::find(values.begin(), values.end(), 12);

  if (found != values.end())
  {
      std::cout << "Found: " << *found << '\n';
  }
}

std::find searches for a value, std::count_if counts predicate matches, std::sort reorders a range, std::transform maps values, and std::accumulate folds a range into a result. Their names make intent searchable and their contracts have known complexity.

Check return contracts. A failed find returns the supplied end iterator, which must not be dereferenced. Sorting mutates the range; copy first when original order is part of the requirement.

A lambda creates a callable object near the use site. Parameters describe each element, the body computes the decision or result, and captures provide surrounding context. [threshold] copies one value; [&threshold] borrows it and requires the original to remain alive.

Keep a lambda focused. When behavior has a domain name, substantial branches, or reuse, move it into a named function or function object. Local syntax should not hide an important policy.

Algorithms do not make costs disappear. Sorting is generally O(n log n), searching an unsorted vector is linear, and transformation writes a result. Repeatedly sorting inside a loop is still expensive even when each call is concise.

Container mutations can invalidate iterators. Do not erase or append casually while an algorithm or loop holds positions into the same vector. Use erase-remove patterns or newer range-aware facilities only after understanding the underlying ownership and validity.