Templates e STL

Declarar um modelo de função

template <typename T>
T maior(T a, T b) { return a < b ? b : a; }

maior(3, 8) deduz int. maior(3, 2.5) não deduz um só tipo. Usa maior<double>(3, 2.5).
O tipo tem de oferecer as operações usadas.
Definições ficam no cabeçalho para a instanciação as ver.

Pilha<int> e Pilha<string> são tipos distintos. Retirar do topo exige confirmar não vazio.

Preciso de	Escolhe
Índice constante, tamanho fixo	`array<T, N>`
Índice constante, crescer no fim	`vector<T>`
Inserir nos dois extremos	`deque<T>`
Inserir com posição conhecida	`list<T>` constante; localizar o elemento custa `O(n)`
Chave ordenada única	`set`, `map`; procura, inserção e remoção em `O(log n)` comparações
Chave sem ordem, média constante	`unordered_map`; média `O(1)` com boa distribuição das chaves e hash/igualdade de custo constante; pior caso linear

size() conta os elementos existentes. capacity() conta a capacidade em elementos. reserve(n) só aumenta a reserva quando n excede a capacidade atual, sem criar elementos, e nunca a diminui.
v[i] não verifica. at(i) verifica. front, back, pop_back exigem não vazio.
m[chave] insere um valor construído por omissão quando a chave falta: int fica 0, string fica vazia. find consulta sem inserir.

[begin(), end()) inclui o início e exclui o fim. Nunca leias end().
vector tem acesso aleatório. list avança e recua. sort exige aleatório.
Realocar vector invalida todos os acessos aos elementos.
No vector, erase invalida os acessos da posição removida em diante. Continua com o iterador devolvido. Na list, só o elemento removido perde validade.

for (auto it = v.begin(); it != v.end(); ) {
    if (*it < 0) it = v.erase(it);
    else ++it;
}

unique junta iguais adjacentes e devolve o fim do prefixo útil. O tamanho continua igual.

std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());

A cauda continua desreferenciável, com estado válido mas não especificado. O resultado lógico termina no iterador devolvido. Usa erase e não contes com esses valores.
Só junta adjacentes. Para todos os repetidos, ordena antes.
lower_bound devolve a primeira posição que não vem antes do alvo, mas exige intervalo particionado pelo mesmo comparador, normalmente ordenado. Confirma it != end() e a igualdade antes de concluir que o valor existe.
Comparador estrito exige comp(x, x) == false. <= não serve. Só esse teste não prova transitividade.

Agregação: resume cada chave num vetor e ordena os resumos. Média das médias pesa igual cada grupo. map<double, string> perde empatados.