Les algorithmes servent soit à lire / parcourir / modifier / obtenir une information d'un conteneur.

std::for_each (lecture) et std::transform (écriture).

std::vector<int> vector{ 10, 20, 30, 40 };
std::vector<int>::const_iterator it;
std::vector<int>::iterator itc;
 
// Lecture / écriture
std::transform(
  vector.begin(),
  vector.end(),
  vector.begin(),
  [](int i)
  {
    return i + 1;
  }
);
 
// Lecture seule
std::for_each(
  vector.cbegin(),
  vector.cend(),
  [](int i)
  {
    std::cout << i << std::endl;
  }
);

Comparer deux classes itérables.

Ici, comparaison de deux string insensible à la casse.

#include <algorithm>
#include <string>
#include <utility>
 
std::string un = "texte";
std::string deux = "Texte";
 
std::tuple<std::string::const_iterator, std::string::const_iterator> retval =
  std::mismatch(
    un.cbegin(),
    un.cend(),
    deux.cbegin(),
    deux.cend(),
    [](char un, char deux)
    {
      return std::tolower(un) == std::tolower(deux);
    });
 
if (retval == std::make_tuple(un.cend(), deux.cend()))
  std::cout << "Identique" << std::endl;
else
  std::cout << "Différent" << std::endl;

Via l'include <execution>, il est possible d'utiliser la totalité des fonctions de <algorithm> en parallèle.

int x = 0;
int a[] = { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2 };
std::for_each(std::execution::par, std::begin(a), std::end(a), [&x](int) {
  ++x; // Pas thread-safe.
  });
std::cout << x << std::endl;