» Главная
eXcode.ru » Статьи » С / С++
» Новости
» Опросы
» Файлы
» Журнал



Пользователей: 0
Гостей: 8





Контейнеры библиотеки STL




Контейнеры - это объекты, которые содержат другие объекты. Они управляют размещением в памяти и свобождением этих объектов через конструкторы, деструкторы, операции вставки и удаления.

В следующей таблице мы полагаем, что X - контейнерный класс, содержащий объекты типа T, a и b - значения X, u - идентификатор, r - значение X&.

Таблица 8. Требования контейнеров
выражение
возвращаемый тип
семантика исполнения
утверждение/примечание
состояние до/после
сложность
X::value_type Т . . время компиляции
X::reference . . . время компиляции
X::const_refe
rence
. . . время компиляции
X::pointer тип указателя, указывающий на X::reference . указатель на T в модели памяти, используемой контейнером время компиляции
X::iterator тип итратора, указывающий на X::reference . итератор любой категории, кроме итератора вывода. время компиляции
X::const_iter
ator
тип итератора, указывающий на X::
const_reference
. постоянный итератор любой категории, кроме итератора вывода. время компиляции
X::difference
_type
знаковый целочисленный тип . идентичен типу расстояния X::iterator и X::const_iterator время компиляции
X::size_type беззнаковый целочисленный тип . size_type может представлять любое неотрицательное значение difference_type время компиляции
X u; . . после: u.size() == 0. постоянная
X() . . X().size() == 0. постоянная
X(a) . . a == X(a). линейная
X u(a);
X u == a;
. X u; u = a; после: u == a. линейная
(&a)->~X() результат не используется . после: a.size() == 0.
примечание: деструктор применяется к каждому элементу a, и вся память возвращается.
линейная
a.begin() iterator;
const_iterator для постоянного a
. . постоянная
a.end() iterator;
const_iterator для постоянного a
. . постоянная
a == b обратимый в bool a.size() ==
b.size() &&
equal(a.begin(),
a.end(),
b.begin())
== - это отношение эквивалентности.
примечание: eqial определяется в разделе алгоритмов.
линейная
a != b обратимый в bool !(a == b) . линейная
r = a X& if(&r != &a) {
(&r)-> X::~X();
new (&r) X(a);
return r; }
после: r == a. линейнaя
a.size() size_type size_type n = 0;
distance
(a.begin(),
a.end(), n);
return n;
. постоянная
a.max_size() size_type . size() самого большого возможного контейнера. постоянная
a.empty() обратимый в bool a.size() == 0 . постоянная
a < b обратимый в bool lexicographical
_compare
(a.begin(), a.end(),
b.begin(), b.end())
до: < определён для значений T.
< - отношение полного упорядочения.
lexicographical
_compare
определяется в разделе алгоритмов.
линейная
a > b обратимый в bool b < a . линейнaя
a <= b обратимый в bool !(a > b) . линейная
a >= b обратимый в bool !(a < b) . линейная
a.swap(b) void swap(a, b) . постоянная

Функция-член size() возвращает число элементов в контейнере. Её семантика определяется правилами конструкторов, вставок и удалений.

begin() возвращает итератор, ссылающийся на первый элемент в контейнере. end() возвращает итератор, который является законечным.

Если тип итератора контейнера принадлежит к категории двунаправленных итераторов или итераторов произвольного доступа, то контейнер называется reversible (обратимым) и удовлетворяет следующим дополнительным требованиям:

Таблица 9. Требования обратимых контейнеров (в дополнение к контейнерам)
выражение
возвращаемый тип
семантика исполнения
сложность
X::reverse
_iterator
. reverse_iterator
для итератора произвольного доступа.
reverse_bidirectional_iterator<
iterator, value_type, reference, difference_type>

для двунаправленного итератора
время компиляции
X::const_r
everse_ite
rator
. reverse_iterator
для итератора произвольного доступа.
reverse_bidirectional_iterator<
const_iterator, value_type, const_reference, difference_type>

для двунаправленного итератора.
время компиляции
a.rbegin() reverse_iterator;
const_reverse_iter
ator
для постоянного a
reverse_iterator(end()) постоянная
a.rend() reverse_iterator;
const_reverse_iter
ator
для постоянного a
reverse_iterator(begin()) постоянная

Последовательности (Sequences)

Последовательность - это вид контейнера, который организует конечное множество объектов одного и того же типа в строгом линейном порядке. Библиотека обеспечивает три основных вида последовательных контейнеров: vector (вектор), list (список) и deque (двусторонняя очередь). Она также предоставляет контейнерные адаптеры, которые облегчают создание абстрактных типов данных, таких как стеки или очереди, из основных видов последовательностей (или из других видов последовательностей, которые пользователь может сам определить).

В следующих двух таблицах X - последовательный класс, a - значение X, i и j удовлетворяют требованиям итераторов ввода, [i, j) - допустимый диапазон, n - значение X::size_type, p - допустимый итератор для a, q - разыменовываемый итератор для a, [ql, q2) - допустимый диапазон в a, t - значение X::value_type.

Сложности выражений зависят от последовательностей.

Таблица 10. Требования последовательностей (в дополнение к контейнерам)
выражение
возвращаемый тип
утверждение/примечание
состояние до/после
X(n, t)
X a(n, t);
. после: size() == n.
создаёт последовательность с n копиями t.
X(i, j)
X a(i, j);
. после: size() == расстоянию между i и j.
создаёт последовательность, равную диапазону [i, j).
a.insert(p, t) iterator вставляет копию t перед p.
возвращаемое значение указывает на вставленную копию.
a.insert(p, n, t) результат не используется вставляет n копий t перед p.
a.insert(p, i, j) результат не используется вставляет копии элементов из диапазона [i, j) перед p.
a.erase(q) результат не используется удаляет элемент, указываемый q.
a.erase(ql, q2) результат не используется удаляет элементы в диапазоне [ql, q2).

vector (вектор), list (список) и deque (двусторонняя очередь) выдвигают программисту различные предложения сложности и должны использоваться соответственно. vectоr - тип последовательности, которая используется по умолчанию. list нужно использовать, когда имеются частые вставки и удаления из середины последовательности, deque - структура данных для выбора, когда большинство вставок и удалений происходит в начале или в конце последовательности.

Типы iterator и const_iterator для последовательностей должны быть, по крайней мере, из категории последовательных итераторов.

Таблица 11. Необязательные операции последовательностей
выражение
возвращаемый тип
семантика исполнения
контейнер
a.front() reference;
const_reference
для постоянного a
*a.begin() vector, list, deque
a.back() reference;
const_reference
для постоянного a
*a.(--end()) vector, list, deque
a.push_front(t) void a.insert(a.begin(), t) list, deque
a.push_back(t) void a.insert(a.end(), t) vector, list, deque
a.pop_front () void a.erase(a.begin()) list, deque
a.pop_back () void a.erase(-- a.end()) vector, list, deque
a[n] reference;
const_reference
для постоянного a
*(a.begin() + n) vector, deque

Все операции в расположенной выше таблице обеспечиваются только для контейнеров, для которых они занимают постоянное время.

Вектор (Vector)

vector - вид последовательности, которая поддерживает итераторы произвольного доступа. Кроме того, он поддерживает операции вставки и удаления в конце с постоянным (амортизированным) временем; вставка и удаление в середине занимают линейное время. Управление памятью обрабатывается автоматически, хотя для улучшения эффективности можно давать подсказки.

template  class Allocator = allocator>
class vector {
public:

// определения типов (typedefs):

    typedef iterator;
    typedef const_iterator;
    typedef Allocator::pointer pointer;
    typedef Allocator::reference reference;
    typedef Allocator::const_reference const_reference;
    typedef size_type;
    typedef difference_type;
    typedef T value_type;
    typedef reverse_iterator;
    typedef const_reverse_iterator;

// размещение/освобождение (allocation/deallocation):

    vector();
    vector(size_type n, const T& value = T());
    vector(const vector& x);
    template 
    vector(InputIterator first, InputIterator last);
    ~vector();
    vector& operator=(const vector& x);
    void reserve(size_type n);
    void swap(vector& x);

// средства доступа (accessors):

    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();
    size_type size() const;
    size_type max_size() const;
    size_type capacity() const;
    bool empty() const;
    reference operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;

// вставка/стирание (insert/irase):

    void push_back(const T& x);
    iterator insert(iterator position, const T& x = T());
    void insert(iterator position, size_type n, const T& x);
    template 
    void insert(iterator position, InputIterator first, InputIterator last);
    void pop_back();
    void erase(iterator position);
    void erase(iterator first, iterator last);
};

    template 
    bool operator==(const vector& x,
             const vector& y);

    template 
    bool operator<(const vector& x,
                const vector& y);

iterator - это итератор произвольного доступа, ссылающийся на T. Точный тип зависит от исполнения и определяется в Allocator.

const_iterator - это постоянный итератор произвольного доступа, ссылающийся на const T. Точный тип зависит от исполнения и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - беззнаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

difference_type - знаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

Конструктор template vector(InputIterator first, InputIterator last) делает только N вызовов конструктора копирования T (где N - расстояние между first и last) и никаких перераспределений, если итераторы first и last относятся к последовательной, двунаправленной или произвольного доступа категориям. Он делает, самое большее, 2N вызовов конструктора копирования T и logN перераспределений, если они - только итераторы ввода, так как невозможно определить расстояние между first и last и затем сделать копирование.

Функция-член capasity (ёмкость) возвращает размер распределённой памяти в векторе. Функция-член reserve - директива, которая сообщает vector(вектору) запланированноe изменение размера, так чтобы он мог соответственно управлять распределением памяти. Это не изменяет размер последовательности и занимает, самое большее, линейное время от размера последовательности. Перераспределение в этом случае происходит тогда и только тогда, когда текущая ёмкость меньше, чем параметр reserve. После reserve ёмкость (capasity) больше или равна параметру reserve, если происходит перераспределение; а иначе равна предыдущему значению capasity. Перераспределение делает недействительными все ссылки, указатели и итераторы, ссылающиеся на элементы в последовательности. Гарантируется, что нет никакого перераспределения во время вставок, которые происходят после того, как reserve выполняется, до времени, когда размер вектора достигает размера, указанного reserve.

insert (вставка) вызывает перераспределение, если новый размер больше, чем старая ёмкость. Если никакого перераспределения не происходит, все итераторы и ссылки перед точкой вставки остаются справедливыми. Вставка единственного элемента в вектор линейна относительно расстояния от точки вставки до конца вектора. Амортизированная сложность во время жизни вектора, вставляющего единственный элемент в свой конец, постоянна. Вставка множественных элементов в вектор с единственным вызовом вставляющей функции-члена линейна относительно суммы числа элементов плюс расстояние до конца вектора. Другими словами, намного быстрее вставить много элементов в середину вектора сразу, чем делать вставку по одному элементу. Шаблонная вставляющая функция-член предраспределяет достаточно памяти для вставки, если итераторы first и last относятся к последовательной, двунаправленной или произвольного доступа категориям. Иначе функция вставляет элементы один за другим и не должна использоваться для вставки в середину векторов.

erase (стирание) делает недействительными все итераторы и ссылки после пункта стирания. Деструктор T вызывается столько раз, каково число стёртых элементов, а оператор присваивания T вызывается столько раз, каково число элементов в векторе после стёртых элементов.

Чтобы оптимизировать распределение места, даётся определение для bool.

class vector { 
public:

// битовая ссылка (bit reference):

    class reference { 
    public:
        ~reference();
        operator bool() const;
        reference& operator=(const bool x);
        void flip();        // инвертирует бит (flips the bit )
    };

// определения типов (typedefs):

    typedef bool const_reference;
    typedef iterator;
    typedef const_iterator; 
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef bool value_type;
    typedef reverse_iterator;
    typedef const_reverse_iterator;

// размещение/освобождение (allocation/deallocation):
 
    vector();
    vector(size_type n, const bool& value = bool());
    vector(const vector& x);
    template 
    vector(InputIterator first, InputIterator last);
    ~vector();
    vector& operator=(const vector& x);
    void reserve(size_type n);
    void swap(vector& x);

// средства доступа (accessors):

    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();
    size_type size() const;
    size_type max_size() const;
    size_type capacity() const;
    bool empty() const;
    reference operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;

// вставка/стирание (insert/irase):

    void push_back(const bool& x);
    iterator insert(iterator position, const bool& x = bool());
    void insert(iterator position, size_type n, const bool& x);
    template 
    void insert(iterator position, InputIterator first, InputIterator last);
    void pop_back();
    void erase(iterator position);
    void erase(iterator first, iterator last);
};

void swap(vector::reference x, 
    vector::reference y);

bool operator==(const vector& x,
        const vector& y);

bool operator<(const vector& x,
        const vector& y);

reference - класс, который имитирует поведение ссылок отдельного бита в vector.

Ожидается, что каждое исполнение обеспечит определение vector для всех поддерживаемых моделей памяти.

Сейчас невозможно шаблонизировать определение. То есть мы не можем написать:
    template