inicio GeNeura cursos

multiset<Key, Compare>

En el contenedor set<> no podemos añadir objetos que ya estén dentro. Pero a veces es necesario almacenar valores duplicados. Por eso las STL proporciona el contenedor multiset<>. Su funcionamiento es el mismo que set<>, pero permitiendo multiples inserciones de una misma clave.


Especificación

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

  // typedefs:

    typedef Key key_type:
    typedef Key value_type;
    typedef Allocator<Key>::pointer pointer:
    typedef Allocator<Key>::reference reference;
    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:

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

  // accessors:

    key_compare key_comp() const;
    value_compare value comp() const;
    iterator begin() const:
    iterator end() const;
    reverse iterator rbegin();
    reverse iterator rend();
    bool empty() const:
    size_type size() const;
    size_type max_size() const;

  // insert/erase:

    iterator 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);

  // multiset 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 multiset<Key, Compare, Allocator>& x,
                const multiset<Key, Compare, Allocator>& y);

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

Requisitos


Ejercicios

  1. Inserta elementos repetidos y no repetidos en un multiset y realiza búsquedas sobre ellos.