Безліч (Set)

     set – Це асоціативний контейнер, який підтримує
унікальні ключі (не містить ключі з однаковими значеннями) і забезпечує
швидкий пошук ключів.

template <class Key, class Compare = less<Key>,
template <class U> class Allocator = allocator>
class set {
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:

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


     iterator – Постійний двонаправлений ітератор, який вказує
на const value_type. Точний тип залежить від реалізації і визначається
в Allocator.


     сonst_iterator – Той же самий тип, що і iterator.


     size_type – Цілочисельний тип без знака. Точний тип залежить
від реалізації і визначається в Allocator.


     difference_type – Цілочисельний тип зі знаком. Точний тип
залежить від реалізації і визначається в Allocator.


Безліч з дублікатами (Multiset)


     multiset – Це асоціативний контейнер, який підтримує
рівні ключі (можливо, містить численні копії того ж самого значення
ключа) і забезпечує швидкий пошук ключів.

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

// typedefs:

typedef Key key_type;
typedef Key value_type;
typedef Allocator<Key>::pointer pointer;
typedef Aliocator<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();
revferse_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);


     iterator – Постійний двонаправлений ітератор, який вказує
на const value_type. Точний тип залежить від реалізації і визначається
в Allocator.


     сonst_iterator – Той же самий тип, що і iterator.


     size_type – Цілочисельний тип без знака. Точний тип залежить
від реалізації і визначається в Allocator.


     difference_type – Цілочисельний тип зі знаком. Точний тип
залежить від реалізації і визначається в Allocator.


Словник (Map)


     map – Асоціативний контейнер, який підтримує
унікальні ключі (не містить ключі з однаковими значеннями) і забезпечує
швидкий пошук значень іншого типу T, Пов'язаних з ключами.

 template <class Key, class T, class Compare = less <Key>,
template <class U> class Allocator = allocator>
class map {
public:

// typedefs:

typedef Key key_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
class value_compare
: Public binary_function <value_type, value_type, bool> {
friend class map;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator () (const value_type & x, const value_type & y) {
return comp(x.first, y.first);
}
};
typedef iterator;
typedef const_iterator;
typedef Allocator<value_type>::pointer pointer;
typedef Allocator<value_type>::reference reference;
typedef Allocator <value_type>:: const_reference const_reference;
typedef size_type;
typedef difference_type;
typedef reverse_iterator;
typedef const_reverse_iterator;

// allocation/deallocation:

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

// accessors:

key_compare key_comp() const;
value_compare value_comp() const;
iterator begin()
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator rend();
bool empty() const;
size_type size() const;
size_type max_size() const;
Allocator <T>:: reference operator [] (const key_type & x);

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

// map operations:

iterator find(const key_type& x);
const_iterator find(const key_type& x) const;
size_type count(const key_type& x) const;
iterator lower_bound(const key_type& x);
const_iterator lower_bound(const key_type& x) const;
iterator upper_bound(const key_type& x);
const_iterator upper_bound(const key_type& x) const;
pair <iterator, iterator> equal_range (const key_type & x);
pair <const_iterator, const_iterator> equal_range (const key_type & x) const;
};

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

template <class Key, class T, class Compare, class Allocator>
bool operator <(const mapr <Key, T, Compare, Allocator> & x,
const map<Key, T, Compare, Allocator>& y);


     iterator – Двонаправлений ітератор, який вказує на
value_type. Точний тип залежить від реалізації і визначається в
Allocator.


     const_iterator – Постійний двонаправлений ітератор,
вказує на const value_type. Точний тип залежить від реалізації та
визначається в Allocator. Гарантується, що є конструктор для
const_iterator з iterator.


     size_type – Цілочисельний тип без знака. Точний тип залежить
від реалізації і визначається в Allocator.


     difference_type – Цілочисельний тип зі знаком. Точний тип
залежить від реалізації і визначається в Allocator.


На додаток до стандартного набору методів асоціативних контейнерів,
map забезпечує операцію Allocator::reference
operator[](const key_type&)
. Для словника m і ключа
k запис m[k] семантично еквівалентна
(*((m.insert(make_pair(k, T()))).first)).second.


Словник з дублікатами (Multimар)


     multimар – Асоціативний контейнер, який підтримує
рівні ключі (можливо, містить численні копії того ж самого значення
ключа) і забезпечує швидкий пошук значень іншого типу T,
пов'язаних з ключами.

 template <class Key, class T, class Compare = less <Key>,
template <class U> class Allocator = allocator>
class multimap {
public:

// typedefs:

typedef Key key_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
class value_compare
: Public binary_function <value_type, value_type, bool> {
friend class multimap;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator () (const value_type & x, const value_type & y) {
return comp(x.first, y.first);
}
};
typedef iterator;
typedef const_iterator;
typedef Allocator<value_type>::pointer pointer;
typedef Allocator<value_type>::reference reference;
typedef Allocator <value_type>:: const_reference const_reference;
typedef size_type;
typedef difference_type;
typedef reverse_iterator;
typedef const_reverse_iterator;

// allocation/deallocation:

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

// accessors:

key_compare key_comp() const;
value_compare value_comp() const;
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin();
reverse_iterator rend()
const_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);

// multimap operations:

iterator find(const key_type& x);
const_iterator find(const key_type& x) const;
size_type count(const key_type& x) const;
iterator lower_bound(const key_type& x);
const_iterator lower_bound(const key_type& x) const;
iterator upper_bound(const key_type& x);
const_iterator upper_bound(const key_type& x) const;
pair <iterator, iterator> equal_range (const key_type & x);
pair <const_iterator, const_iterator> equal_range (const key_type & x) const;
};

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

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


     iterator – Двонаправлений ітератор, який вказує на
value_type. Точний тип залежить від реалізації і визначається в
Allocator.


     const_iterator – Постійний двонаправлений ітератор,
вказує на value_type. Точний тип залежить від реалізації та
визначається в Allocator. Гарантується, що є конструктор для
const_iterator з iterator.


     size_type – Цілочисельний тип без знака. Точний тип залежить
від реалізації і визначається в Allocator.


     difference_type – Цілочисельний тип зі знаком. Точний тип
залежить від реалізації і визначається в Allocator.

Схожі статті:


Сподобалася стаття? Ви можете залишити відгук або підписатися на RSS , щоб автоматично отримувати інформацію про нові статтях.

Коментарів поки що немає.

Ваш отзыв

Поділ на параграфи відбувається автоматично, адреса електронної пошти ніколи не буде опублікований, допустимий HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

*

*