C++ Academy · Aula

Comparadores personalizados

Controle a ordenação

Comparadores personalizados é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Por que usar comparadores personalizados

Por padrão, os contêineres ordenados usam std::less para ordenar em ordem crescente. Um comparador personalizado permite alterar essa ordem, por exemplo, para decrescente ou com base em um campo específico.

#include <iostream>
#include <set>

int main() {
    std::set<int> ascending{3, 1, 2};
    for (int x : ascending) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Ordem decrescente com std::greater

O comparador personalizado mais simples é o objeto de função padrão std::greater, que ordena em ordem decrescente.

#include <iostream>
#include <set>
#include <functional>

int main() {
    std::set<int, std::greater<int>> s{3, 1, 2};
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Comparador em um map

O comparador é o terceiro parâmetro de modelo de std::map. Aqui, as chaves são ordenadas da maior para a menor.

#include <iostream>
#include <map>
#include <functional>

int main() {
    std::map<int, std::string, std::greater<int>> m{
        {1, "one"}, {3, "three"}, {2, "two"}
    };
    for (const auto& [k, v] : m) std::cout << k << ':' << v << ' ';
    std::cout << '\n';
    return 0;
}

Como os comparadores funcionam

Um comparador é uma função que recebe dois argumentos e retorna true se o primeiro deve vir antes do segundo. Ele deve definir uma ordenação fraca estrita.

#include <iostream>

struct Less {
    bool operator()(int a, int b) const { return a < b; }
};

int main() {
    Less cmp;
    std::cout << std::boolalpha << cmp(2, 5) << '\n';
    std::cout << cmp(5, 2) << '\n';
    return 0;
}

Um comparador de estrutura personalizado

Defina sua própria estrutura de objeto de função com operator() e passe o tipo dela como comparador.

#include <iostream>
#include <set>

struct ByAbs {
    bool operator()(int a, int b) const {
        return (a < 0 ? -a : a) < (b < 0 ? -b : b);
    }
};

int main() {
    std::set<int, ByAbs> s{-5, 3, -1, 4};
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Ordenar cadeias de caracteres por comprimento

Os comparadores podem comparar qualquer propriedade. Aqui, as cadeias de caracteres são ordenadas por comprimento e, depois, alfabeticamente como critério de desempate.

#include <iostream>
#include <set>
#include <string>

struct ByLen {
    bool operator()(const std::string& a, const std::string& b) const {
        if (a.size() != b.size()) return a.size() < b.size();
        return a < b;
    }
};

int main() {
    std::set<std::string, ByLen> s{"bbb", "a", "cc", "dd"};
    for (const auto& x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Por que os critérios de desempate são importantes

Se o seu comparador disser que nenhum dos elementos vem antes do outro, o contêiner os tratará como iguais. Em um set, isso significa que um deles será descartado como duplicata.

#include <iostream>
#include <set>
#include <string>

struct LenOnly {
    bool operator()(const std::string& a, const std::string& b) const {
        return a.size() < b.size();
    }
};

int main() {
    std::set<std::string, LenOnly> s{"ab", "cd", "x"};
    std::cout << s.size() << " elements\n";
    return 0;
}

Lambdas como comparadores

Você pode usar uma lambda passando o tipo dela por meio de decltype e a própria lambda para o construtor.

#include <iostream>
#include <set>

int main() {
    auto cmp = [](int a, int b) { return a > b; };
    std::set<int, decltype(cmp)> s(cmp);
    s.insert(1);
    s.insert(3);
    s.insert(2);
    for (int x : s) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Comparadores em priority_queue

Os comparadores também configuram std::priority_queue. Com std::greater, ele se torna uma fila de prioridade mínima.

#include <iostream>
#include <queue>
#include <vector>
#include <functional>

int main() {
    std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
    pq.push(5); pq.push(1); pq.push(3);
    while (!pq.empty()) { std::cout << pq.top() << ' '; pq.pop(); }
    std::cout << '\n';
    return 0;
}

Comparar pares

Para ordenar um conjunto de pares pelo segundo elemento, escreva um comparador que examine .second.

#include <iostream>
#include <set>
#include <utility>

struct BySecond {
    bool operator()(const std::pair<int,int>& a, const std::pair<int,int>& b) const {
        return a.second < b.second;
    }
};

int main() {
    std::set<std::pair<int,int>, BySecond> s{{1, 9}, {2, 3}, {3, 6}};
    for (const auto& p : s) std::cout << p.first << ':' << p.second << ' ';
    std::cout << '\n';
    return 0;
}

Comparadores transparentes

Usar std::less<> (com os sinais de menor e maior vazios) habilita a busca heterogênea no C++14, evitando conversões temporárias de chaves.

#include <iostream>
#include <set>
#include <functional>

int main() {
    std::set<int, std::less<>> s{1, 2, 3};
    std::cout << (s.find(2) != s.end() ? "found" : "no") << '\n';
    return 0;
}

Verificação rápida

Teste sua compreensão sobre como os comparadores definem a igualdade.

Recapitulação

Você aprendeu que os comparadores personalizados:

alteram a ordenação por meio do parâmetro de modelo do comparador do contêiner
podem ser std::greater, uma estrutura de objeto de função ou uma lambda (por meio de decltype)
definem a igualdade por equivalência; portanto, sempre inclua um critério de desempate para evitar perder elementos distintos

Próximo curso: busca rápida baseada em dispersão com std::unordered_map.

Perguntas Frequentes

A aula “Comparadores personalizados” é grátis?

Sim — o texto completo de “Comparadores personalizados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Comparadores personalizados”?

Controle a ordenação Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Comparadores personalizados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

std::map
std::set
multimap e multiset
Comparadores personalizados

← Voltar para C++ Academy