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. Construída sobre os conceitos de templates que você aprendeu, a STL incorpora uma filosofia de design poderosa: separar o armazenamento de dados da manipulação de dados.

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

Componente	Propósito	Exemplos
Containers	Armazenam coleções de objetos	`vector`, `map`, `set`
Iteradores	Fornecem acesso aos elementos do container	Entrada, saída, acesso aleatório
Algoritmos	Realizam operações nos dados	`sort`, `find`, `transform`

A percepção fundamental é que os algoritmos não conhecem os containers diretamente - eles funcionam 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 misturar e combinar - use qualquer algoritmo com qualquer contêiner compatível sem escrever código novo. A STL fornece implementações otimizadas e testadas em batalha para que você possa se concentrar em resolver problemas em vez de reinventar estruturas de dados comuns.

Desafio

Fácil

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

Você criará dois arquivos:

DataProcessor.h: Defina funções utilitárias que trabalham com containers STL através de iteradores, demonstrando a filosofia de design da STL.
Crie uma função chamada printVector que recebe um std::vector<int>& e imprime todos os elementos separados por espaços, seguidos por uma nova linha. Use iteradores (begin() e end()) para percorrer o container.

Crie uma função chamada sortAndPrint que recebe um std::vector<int>&, ordena-o usando std::sort, e então imprime os elementos ordenados separados por espaços seguidos por uma nova linha.

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

Crie uma função chamada getSum que recebe um std::vector<int>& e retorna 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 juntos.
Leia cinco entradas (cada uma em uma linha separada):
1. Primeiro número inteiro
2. Segundo número inteiro
3. Terceiro número inteiro
4. Quarto número inteiro
5. Um valor para pesquisar
Crie um std::vector<int> e adicione os quatro primeiros números inteiros a ele. Em seguida, demonstre a filosofia da STL ao:
1. Imprimir Original: seguido pela chamada de printVector
2. Imprimir Sorted: seguido pela chamada de sortAndPrint
3. Chamar findElement com o valor de busca
4. Imprimir 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 através de iteradores, e como std::sort e std::find operam em qualquer container que forneça o tipo de iterador correto. Este é o poder do design da STL — os algoritmos são desacoplados dos containers, conectados apenas através de iteradores.

Folha de consulta

A Standard Template Library (STL) é uma coleção de classes e funções baseadas em templates que fornecem estruturas de dados e algoritmos comuns. Ela separa o armazenamento de dados da manipulação de dados.

A STL possui três componentes principais:

Componente	Propósito	Exemplos
Containers	Armazenam coleções de objetos	`vector`, `map`, `set`
Iteradores	Fornecem acesso aos elementos do container	Entrada, saída, acesso aleatório
Algoritmos	Realizam operações nos dados	`sort`, `find`, `transform`

Os algoritmos funcionam por meio de iteradores, não diretamente com os containers. Isso permite que um único algoritmo funcione com qualquer container compatível:

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

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

Métodos comuns de iteradores:

begin() - retorna o iterador para o primeiro elemento
end() - retorna o iterador para a posição após o último elemento

Algoritmos comuns da STL:

std::sort(begin, end) - ordena os elementos no intervalo
std::find(begin, end, value) - procura por um valor no intervalo

Experimente você mesmo

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

using namespace std;

int main() {
    // Lê cinco números 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 quatro primeiros números 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 pelo resultado de getSum
    
    return 0;
}