Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::set — una colección ordenada de claves únicas

std::set, de <set>, almacena claves únicas en el orden del comparador. Aprende a insertar y buscar, y conoce las diferencias entre find, contains, count y equal_range, incluido cómo comprobar end() de forma segura.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <set>
std::set<Key> values;
auto [it, inserted] = values.insert(key);
auto found = values.find(key);
bool present = found != values.end();
bool exists = values.contains(key);
auto occurrences = values.count(key);
auto [first, last] = values.equal_range(key);

std::set<Key> de <set> es un contenedor asociativo ordenado. Cada elemento es también una clave; el comparador predeterminado std::less<Key> ordena los enteros de menor a mayor. La unicidad significa equivalencia según el comparador: !comp(a, b) && !comp(b, a), no necesariamente a == b. El comparador debe establecer un orden débil estricto.

La sobrecarga habitual de std::set::insert(key) para un solo valor devuelve un par: un iterador al elemento insertado o ya existente y un bool que indica si se produjo la inserción. Una clave equivalente no se añade de nuevo. std::set::find(key) devuelve un iterador a un elemento equivalente o std::set::end(). end() apunta más allá del último elemento: comprueba it != values.end() antes de desreferenciar el resultado de una búsqueda.

std::set::contains(key) devuelve un valor booleano que indica si la clave está presente. std::set::count(key) devuelve el número de elementos equivalentes, aquí siempre 0 o 1. std::set::equal_range(key) devuelve dos iteradores que describen el rango semiabierto [first, last) de elementos equivalentes: vacío o con un elemento. Un rango vacío significa first == last, pero no necesariamente first == values.end().

La inserción habitual de un solo valor y las operaciones de búsqueda indicadas tienen una complejidad O(log n); end() requiere tiempo constante. No se pueden modificar las claves mediante iteradores. El ejemplo está pensado para compilarse con -std=c++23. El documento proporcionado es un borrador en evolución, no una publicación definitiva de C++23; la opción del compilador del repositorio no acredita la compatibilidad en tiempo de ejecución en producción.

Ejemplos

#include <iostream>
#include <set>

int main() {
    std::set<int> values{3, 1, 3};
    auto [it, inserted] = values.insert(2);
    auto duplicate = values.insert(3);

    std::cout << std::boolalpha;
    std::cout << "insert: " << *it << ' ' << inserted << '\n';
    std::cout << "duplicate: " << duplicate.second << '\n';
    std::cout << "ordered:";
    for (int value : values) {
        std::cout << ' ' << value;
    }
    std::cout << '\n';

    auto found = values.find(2);
    if (found != values.end()) {
        std::cout << "find: " << *found << '\n';
    }
    std::cout << "contains 4: " << values.contains(4) << '\n';
    std::cout << "count 3: " << values.count(3) << '\n';

    auto [first, last] = values.equal_range(2);
    std::cout << "equal_range 2:";
    for (auto current = first; current != last; ++current) {
        std::cout << ' ' << *current;
    }
    std::cout << '\n';
}

Resultado

insert: 2 true
duplicate: false
ordered: 1 2 3
find: 2
contains 4: false
count 3: 1
equal_range 2: 2

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes