Visão geral e filosofia da STL

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 70 de 104.

A Standard Template Library (STL) é uma coleção de classes e funções baseadas em templates que fornecem estruturas de dados e algoritmos comuns. Baseada nos conceitos de templates que você aprendeu, a STL incorpora uma poderosa filosofia de design: separar o armazenamento de dados da manipulação de dados.

A STL é organizada em torno de três componentes principais que trabalham em conjunto:

Componente	Finalidade	Exemplos
Contêineres	Armazenam coleções de objetos	`vector`, `map`, `set`
Iteradores	Fornecem acesso aos elementos do contêiner	Entrada, saída, acesso aleatório
Algoritmos	Realizam operações nos dados	`sort`, `find`, `transform`

A ideia fundamental é que os algoritmos não conhecem diretamente os containers — eles trabalham por meio de iteradores. Isso significa que um único algoritmo sort funciona com vetores, arrays e qualquer container que forneça o tipo de iterador correto:

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

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    
    std::sort(nums.begin(), nums.end());
    
    for (int n : nums) {
        std::cout << n << " ";
    }
    // Saída: 1 2 5 8 9
}

Essa separação significa que você pode combinar livremente — usar qualquer algoritmo com qualquer contêiner compatível sem escrever código novo. A STL fornece implementações testadas e otimizadas, para que você possa se concentrar em resolver problemas em vez de reinventar estruturas de dados comuns.

Desafio

Fácil

Vamos criar um sistema simples de processamento de dados que demonstra a filosofia da STL de separar contêineres, iteradores e algoritmos. Você criará um módulo utilitário que trabalha com componentes da STL e um programa principal que mostra como essas partes se encaixam.

Você criará dois arquivos:

DataProcessor.h: defina funções utilitárias que trabalham com contêineres da STL por meio de iteradores, demonstrando a filosofia de design da STL.
Crie uma função chamada printVector que receba um std::vector<int>& e imprima todos os elementos separados por espaços, seguidos por uma nova linha. Use iteradores (begin() e end()) para percorrer o contêiner.

Crie uma função chamada sortAndPrint que receba um std::vector<int>&, ordene-o usando std::sort e, em seguida, imprima os elementos ordenados separados por espaços, seguidos por uma nova linha.

Crie uma função chamada findElement que receba um std::vector<int>& e um valor int a ser pesquisado. Use std::find para localizar o elemento. Se ele for encontrado, imprima Found: <value>. Se não for encontrado, imprima Not found: <value>.

Crie uma função chamada getSum que receba um std::vector<int>& e retorne a soma de todos os elementos. Você pode usar um loop simples com iteradores para isso.
main.cpp: leia as entradas e demonstre como os componentes da STL trabalham em conjunto.
Leia cinco entradas (cada uma em uma linha separada):
1. Primeiro inteiro
2. Segundo inteiro
3. Terceiro inteiro
4. Quarto inteiro
5. Um valor a ser pesquisado
Crie um std::vector<int> e adicione os quatro primeiros inteiros a ele. Em seguida, demonstre a filosofia da STL:
1. Imprima Original: seguido da chamada de printVector
2. Imprima Sorted: seguido da chamada de sortAndPrint
3. Chame findElement com o valor pesquisado
4. Imprima Sum: <result> usando getSum

Por exemplo, com as entradas 5, 2, 8, 1 e 8:

Original: 5 2 8 1 
Sorted: 1 2 5 8 
Found: 8
Sum: 16

Com as entradas 10, 30, 20, 40 e 15:

Original: 10 30 20 40 
Sorted: 10 20 30 40 
Not found: 15
Sum: 100

Observe como suas funções trabalham com o vetor por meio de iteradores e como std::sort e std::find operam em qualquer contêiner que forneça o tipo correto de iterador. Esse é o poder do design da STL: os algoritmos são desacoplados dos contêineres e conectados apenas por meio de iteradores.

Experimente você mesmo

#include <iostream>
#include <vector>
#include "DataProcessor.h"

using namespace std;

int main() {
    // Leia cinco inteiros da entrada
    int num1, num2, num3, num4, searchValue;
    cin >> num1;
    cin >> num2;
    cin >> num3;
    cin >> num4;
    cin >> searchValue;
    
    // TODO: Crie um vector e adicione os primeiros quatro inteiros a ele
    
    // TODO: Imprima "Original: " e chame printVector
    
    // TODO: Imprima "Sorted: " e chame sortAndPrint
    
    // TODO: Chame findElement com o valor de busca
    
    // TODO: Imprima "Sum: " seguido do resultado de getSum
    
    return 0;
}