Da trilha de C++ Este conceito ainda não saiu como card do dia. ir para o card de hoje

C++ Coleções Intermediário

Algoritmos da STL

A STL (Standard Template Library) do C++ oferece algoritmos genéricos prontos que operam sobre intervalos de iteradores. Em vez de escrever laços manuais, você usa funções como std::sort, std::find_if, std::transform e std::accumulate para deixar o código mais expressivo, seguro e eficiente. Esses algoritmos são definidos no cabeçalho <algorithm> (e <numeric> para accumulate) e funcionam com qualquer container que exponha iteradores, como std::vector, std::list e arrays nativos.

O poder vem da combinação com lambdas (funções anônimas) e predicados. Por exemplo, std::find_if aceita um predicado que decide se um elemento satisfaz uma condição; std::transform aplica uma função a cada elemento e grava o resultado em outro intervalo; std::accumulate reduz todo o intervalo a um único valor usando uma operação binária. Essas ferramentas evitam bugs comuns de laços, como índices errados ou condições de parada mal definidas.

Neste card, você verá exemplos práticos de cada algoritmo e como encadeá-los para resolver problemas do dia a dia. A ideia é que você passe a pensar em termos de 'o que fazer' com os dados, e não em 'como iterar'. Isso é um passo importante para escrever C++ moderno e idiomático.

Pontos-chave

  • std::sort ordena um intervalo em tempo O(N log N) e aceita um comparador personalizado.
  • std::find_if retorna um iterador para o primeiro elemento que satisfaz um predicado, ou end() se nenhum satisfizer.
  • std::transform aplica uma função a cada elemento de um intervalo e grava o resultado em outro (ou no mesmo).
  • std::accumulate (em <numeric>) reduz um intervalo a um único valor usando uma operação binária e um valor inicial.
  • Lambdas são ideais para passar predicados e funções de transformação de forma concisa.
stl_algorithms.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9, 3};

    // 1. sort: ordena em ordem crescente
    std::sort(nums.begin(), nums.end());
    std::cout << "Ordenado: ";
    for (int n : nums) std::cout << n << ' ';
    std::cout << '\n';

    // 2. find_if: primeiro número maior que 4
    auto it = std::find_if(nums.begin(), nums.end(),
                           [](int n) { return n > 4; });
    if (it != nums.end())
        std::cout << "Primeiro > 4: " << *it << '\n';

    // 3. transform: dobra cada elemento
    std::vector<int> dobrados(nums.size());
    std::transform(nums.begin(), nums.end(), dobrados.begin(),
                   [](int n) { return n * 2; });
    std::cout << "Dobrados: ";
    for (int n : dobrados) std::cout << n << ' ';
    std::cout << '\n';

    // 4. accumulate: soma de todos os elementos
    int soma = std::accumulate(nums.begin(), nums.end(), 0);
    std::cout << "Soma: " << soma << '\n';

    return 0;
}

Exercícios

  1. 1
    Fácil

    Ordenar e encontrar o primeiro par

    Dado um vetor de inteiros, ordene-o em ordem crescente e use std::find_if para encontrar o primeiro número par. Imprima o vetor ordenado e o primeiro par encontrado (ou uma mensagem se não houver).

    Resolver
  2. 2
    Médio

    Transformar e somar quadrados

    Dado um vetor de inteiros, crie um novo vetor com o quadrado de cada elemento usando std::transform e depois use std::accumulate para calcular a soma dos quadrados. Imprima o vetor de quadrados e a soma.

    Resolver
  3. 3
    Desafio

    Filtrar, transformar e acumular em pipeline

    Dado um vetor de inteiros, use std::find_if para localizar o primeiro número maior que 5, depois use std::transform para converter todos os números a partir desse ponto em seus dobros, e finalmente std::accumulate para somar os valores transformados. Imprima o vetor original após a transformação e a soma.

    Resolver

Continue estudando