inicio GeNeura cursos

set<Key, Compare>

El conjunto es el tipo de contenedor asociativo más simple. se<Key, Compare> es un contenedor ordenado que mantiene una única copia de cada objeto de tipo Key. Como los objetos necesitan ser únicos, un intento de insertar una clave que ya este en el conjunto debe fallar. La forma de indicar este fallo dependerá del método empleado para realizar la inserción. Las operaciones más frecuentes, la inserción y la búsqueda, se realizan en tiempo O(log N).


Especificación

template<class Key, class Compare = less<Key>,
         class Allocator = allocator>
class set
{
  public:

  // typedefs:

    typedef Key key_type;
    typedef Key value_type;
    typedef Allocator<Key>::pointer pointer;
    typedef Allocator<Key>::reference referente
    typedef Allocator<Key>::const_reference const_reference;
    typedef Compare key_compare;
    typedef Compare value_compare:
    typedef iterator;
    typedef iterator const_iterator;
    typedef size_type;
    typedef difference_type;
    typedef reverse_iterator;
    typedef const_reverse_iterator;

 // allocation/deallocation:

    set(const Compare& comp = Compare());
    template<class InputIterator> set(InputIterator first,
                                      InputIterator last,
                                      const Compare& comp = Compare());
    set(const set<Key, Compare, Allocator>& x);
    ~set(
    set<Key, Compare, Allocator>&
    operator=(const set<Key, Compare, Allocator>& x);
    void swap(set<Key, Compare, Allocator>& x);

  // accessors:

    key_compare key_comp() const;
    value_compare value_comp() const;
    iterator begin() const;
    iterator end() const;
    reverse_iterator rbegin() const;
    reverse_iterator rend() const;
    bool empty() const;
    size_type size() const;
    size_type max_size() const;

  // insert/erase:

    pair<iterator, bool> insert(const value_type& x);
    iterator insert(iterator position, const value_type& x);
    template<class InputIterator> void insert(InputIterator first, 
                                              InputIterator last);
    void erase(iterator position);
    size_type erase(const key_type& x);
    void erase(iterator first, iterator last);

  // set operations

    iterator find(const key_type& x) const;
    size type count(const key type& x) const;
    iterator lower_bound(const key_type& x) const;
    iterator upper_bound(const key_type& x const);
    pair<iterator, iterator> equal_range(const key_type& x) const;
}

template<class Key, class Compare, class Allocator>
bool operator==(const set<Key, Compare, Allocator>& x,
                const set<Key, Compare, Allocator>& y;

template<class Key, class Compare, class Allocator>
bool operator<const set<Key, Compare, Allocator>& x,
              const set<Key, Compare, Allocator>& y);
    

Requisitos

Los requisitos del tipo Key son:


Ejercicios

  1. Crea un conjunto, rellenalo con unos cuantos elementos y muestralo en orden normal e inverso.
  2. Rellena un conjunto con el método insert() y comprueba el resultado de las inserciones. Por cada inserción haz que se escriba un mensaje que diga si la inserción ha tenido éxito o no.
  3. Define tu propia clase y utilízala dentro de un conjunto.