Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

list_of Reference

Boost , Chapter 1. Boost.Bimap , Reference

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext
namespace boost {
namespace bimaps {
template< class KeyType >
struct list_of;
struct list_of_relation;
} // namespace bimap
} // namespace boost

List_of set view - это интерфейс, совместимый с подписью std::list, с базовым набором элементов, содержащихся в bimap.

Если вы посмотрите на карту сбоку, вы будете использовать вид карты, и если вы посмотрели ее в целом, вы будете использовать заданный вид.

Элементы в списке_вида по умолчанию отсортированы в соответствии с их порядком вставки: это означает, что новые элементы, вставленные через другой вид bimap, добавляются к концу списка_вида. Кроме того, вид позволяет свободно упорядочивать элементы в том же ключе, что и std::list. Достоверность итераторов и отсылок к элементам сохраняется во всех операциях.

Существует ряд различий в отношении std:: списки:

  • list_of views is not Assignable (Как и любой другой взгляд.)
  • В отличие от std::list, вставки в список_ вида могут выйти из строя из-за столкновений с другими представлениями. Это изменяет семантику операций, предоставляемых по отношению к их аналогам в std::list.
  • Элементы в списке_изображения не являются изменчивыми и могут быть изменены только с помощью функций-членов заменить и изменить.

Принимая во внимание эти ограничения, list_of views являются моделями Reversible Container, Front Insertion Sequence и Back Insertion Sequence. Мы предоставляем только описания тех типов и операций, которые либо не присутствуют в моделируемых концепциях, либо не соответствуют требованиям к этим типам контейнеров.

namespace boost {
namespace bimaps {
namespace views {
template< -implementation defined parameter list- >
class -implementation defined view name-
{
    public:
    // types
    typedef -unspecified- value_type;
    typedef -unspecified- allocator_type;
    typedef -unspecified- reference;
    typedef -unspecified- const_reference;
    typedef -unspecified- iterator;
    typedef -unspecified- const_iterator;
    typedef -unspecified- size_type;
    typedef -unspecified- difference_type;
    typedef -unspecified- pointer;
    typedef -unspecified- const_pointer;
    typedef -unspecified- reverse_iterator;
    typedef -unspecified- const_reverse_iterator;
    typedef -unspecified- info_type;
    // construct/copy/destroy
    this_type & operator=(const this_type & x);
    template< class InputIterator >
    void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const value_type & value);
    allocator_type get_allocator() const;
    // iterators
    iterator               begin();
    const_iterator         begin() const;
    iterator               end();
    const_iterator         end() const;
    reverse_iterator       rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator       rend();
    const_reverse_iterator rend() const;
    // capacity
    bool      empty() const;
    size_type size() const;
    size_type max_size() const;
    void resize(size_type n, const value_type & x = value_type());
    // access
    const_reference front() const;
    const_reference back() const;
    // modifiers
    std::pair<iterator,bool> push_front(const value_type & x);
    void                     pop_front();
    std::pair<iterator,bool> push_back(const value_type & x);
    void                     pop_back();
    std::pair<iterator,bool> insert(iterator position, const value_type & x);
    void insert(iterator position, size_type n, const value_type & x);
    template< class InputIterator >
    void insert(iterator position, InputIterator first, InputIterator last);
    iterator erase(iterator position);
    iterator erase(iterator first, iterator last);
    bool replace(iterator position, const value_type & x);
    // Only in map views
    // {
      typedef -unspecified- key_type;
      typedef -unspecified- mapped_type;
      typedef -unspecified- mapped_type; // Equal to mapped_type
      template< class CompatibleKey >
      bool replace_key(iterator position, const CompatibleKey & x);
      template< class CompatibleData >
      bool replace_data(iterator position, const CompatibleData & x);
      template< class KeyModifier >
      bool modify_key(iterator position, KeyModifier mod);
      template< class DataModifier >
      bool modify_data(iterator position, DataModifier mod);
    // }
    void clear();
    // list operations
    void splice(iterator position, this_type & x);
    void splice(iterator position, this_type & x, iterator i);
    void splice(
        iterator position, this_type & x, iterator first, iterator last);
    void remove(const value_type & value);
    template< class Predicate >
    void remove_if(Predicate pred);
    void unique();
    template< class BinaryPredicate >
    void unique(BinaryPredicate binary_pred);
    void merge(this_type & x);
    template< class Compare >
    void merge(this_type & x,Compare comp);
    void sort();
    template< class Compare >
    void sort(Compare comp);
    void reverse();
    // rearrange operations
    void relocate(iterator position, iterator i);
    void relocate(iterator position, iterator first, iterator last);
}
// view comparison
bool operator==(const this_type & v1, const this_type & v2 );
bool operator< (const this_type & v1, const this_type & v2 );
bool operator!=(const this_type & v1, const this_type & v2 );
bool operator> (const this_type & v1, const this_type & v2 );
bool operator>=(const this_type & v1, const this_type & v2 );
bool operator<=(const this_type & v1, const this_type & v2 );
} // namespace views
} // namespace bimap
} // namespace boost

В случае bimap< list_of<Left>, ... >

В представленном виде:

typedef signature-compatible with relation< Left, ... > key_type;
typedef signature-compatible with relation< Left, ... > value_type;

На левой карте вид:

typedef  Left  key_type;
typedef  ...   mapped_type;
typedef signature-compatible with std::pair< Left, ... > value_type;

В правильном виде карты:

typedef  ...  key_type;
typedef  Left mapped_type;
typedef signature-compatible with std::pair< ... , Left > value_type;

Здесь и в описаниях операций взглядов list_of мы принимаем схему, изложенную в разделе сложность подписи. Сигнатура сложности просмотра list_of:

  • копирование: c(n)=n ,
  • вставка: i(n) = 1 (постоянная),
  • подсказанная вставка: h(n) = 1 (постоянная),
  • удаление: d(n)=1 (постоянно),
  • замена: r(n) = 1 (постоянная),
  • изменение: m(n) = 1 (постоянно).

list_of просмотры инстанцируются внутри bimap и указываются с помощью спецификаторов типа сбора и самой карты. Обоснования зависят от следующих видов:

  • Ценность из list_of,
  • Allocator из bimap,

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

this_type & operator=(const this_type & x);
  • Эффекты: a=b;, где a и b являются объектами bimap, к которым * относятся соответственно и x.
  • Возврат: *это.
template< class InputIterator >
void assign(InputIterator first, InputIterator last);
  • Требуется: InputIterator представляет собой модель Input Iterator над элементами типа value_type или типа, конвертируемого в value_type. Первый и последний не являются итераторами в каких-либо представлениях bimap, к которым относится это представление. last доступен из first.
  • Эффекты: clear(); insert(end(),first,last);
void assign(size_type n, const value_type & value);
  • Эффекты: ясно;i; n;push_backv;
void resize(size_type n,const value_type& x=value_type());
  • Эффекты: ()>>>>>>>>>>>>>>>>>>>>>>>>>><
  • Примечание: Если требуется расширение, то после этой операции размер вида не гарантируется равным n (другие виды могут запрещать вставки)
std::pair<iterator,bool> push_front(const value_type& x);
  • Последствия: Вставить x в начале последовательности, если никакие другие представления bimap не запрещают вставку.
  • Возврат: Возвратное значение представляет собой пару p. p.секунда является истинной, если и только если вставка состоялась. При успешной вставке p.первый указывает на вставленный элемент; в противном случае p.первый указывает на элемент, из-за которого вставка была запрещена. Обратите внимание, что более одного элемента может привести к тому, что вставка не допускается.
  • Сложность: O(I(n)).
  • Безопасность исключения: Сильная.
std::pair<iterator,bool> push_back(const value_type & x);
  • Эффекты: Вставить x в конце последовательности, если никакие другие представления bimap не запрещают вставку.
  • Возврат: Возвратное значение представляет собой пару p. p.секунда является истинной, если и только если вставка состоялась. При успешной вставке p.первый указывает на вставленный элемент; в противном случае p.первый указывает на элемент, из-за которого вставка была запрещена. Обратите внимание, что более одного элемента может привести к тому, что вставка не допускается.
  • Сложность: O(I(n)).
  • Безопасность исключения: Сильная.
std::pair<iterator,bool> insert(iterator position, const value_type & x);
  • Требуется: Положение является действительным .
  • Последствия: Вставить x перед позицией, если вставка допускается всеми другими видами bimap.
  • Возврат: Возвратное значение представляет собой пару p. p.секунда является истинной, если и только если вставка состоялась. При успешной вставке p.первый указывает на вставленный элемент; в противном случае p.первый указывает на элемент, из-за которого вставка была запрещена. Обратите внимание, что более одного элемента может привести к тому, что вставка не допускается.
  • Сложность: O(I(n)).
  • Безопасность исключения: Сильная.
void insert(iterator position, size_type n, const value_type & x);
  • Требуется: Положение является действительным .
  • Эффекты: size_type i n
template< class InputIterator>
void insert(iterator position,InputIterator first,InputIterator last);
  • Требуется: Положение является действительным iterator представления. InputIterator представляет собой модель Input Iterator над элементами типа value_type. first и last не являются итераторами в любом виде bimap, к которому относится этот вид. last доступен из first.
  • Эффекты: в то время как(первый !=последний>вставить(позиция,первый++);
  • Сложность: O(m*I(n+m)), где m - число элементов в [первый,последний).
  • Безопасность исключения: Базовая.
iterator erase(iterator position);
  • Требуется: Положение является действительным dereferenceable iterator представления.
  • Последствия:Удалить элемент, на который указывает позиция.
  • Возврат: Итератор, указывающий на элемент, непосредственно следующий за тем, который был удален, или end(), если такого элемента не существует.
  • Сложность: O(D(n)).
  • Безопасность исключения: нотроу.
iterator erase(iterator first, iterator last);
  • Требуется: [first,last) является допустимым диапазоном представления.
  • Последствия:Удалить элементы в [первый,последний).
  • Возврат: Последний.
  • Сложность: O(m*D(n)), где m - число элементов в [первый,последний).
  • Безопасность исключения: нотроу.
bool replace(iterator position,const value_type& x);
  • Требуется: Положение является действительным итератором представления.
  • Эффекты: Назначает значение x на элемент, на который указывает положение в bimap, к которому относится вид, если замена допускается всеми другими видами bimap.
  • Постусловия:Срок действия позиция сохраняется во всех случаях.
  • Возврат: Правда, если замена состоялась, ложно в противном случае.
  • Сложность: O(R(n)).
  • Безопасность исключения: Сильная. Если какое-либо пользовательское действие забрасывает исключение, то bimap, которому принадлежит вид, остается в исходном состоянии.
template< class CompatibleKey >
bool replace_key(iterator position, const CompatibleKey & x);
  • Требуется: Положение является действительным итератором сносного представления. Совместимый ключ может быть назначен key_type.
  • Эффекты: Назначает значение x e.first, где e является элементом, на который указывает позиция в bimap, которому принадлежит заданный вид, если замена допускается всеми другими видами bimap.
  • Постусловия: Действительность позиции сохраняется во всех случаях.
  • Возврат: Правда, если замена состоялась, ложно в противном случае.
  • Сложность: O(R(n)).
  • Безопасность исключения: Сильная. Если какое-либо пользовательское действие забрасывает исключение, то карта bimap, к которой относится заданный вид, остается в исходном состоянии.
template< class CompatibleData >
bool replace_data(iterator position, const CompatibleData & x);
  • Требуется: Положение является действительным итератором сносного представления. Совместимый ключ может быть назначен mapped_type.
  • Эффекты: Назначает значение x e.second, где e является элементом, на который указывает позиция в bimap, которому принадлежит заданный вид, если замена допускается всеми другими видами bimap.
  • Постусловия: Действительность позиции сохраняется во всех случаях.
  • Возврат: Правда, если замена состоялась, ложно в противном случае.
  • Сложность: O(R(n)).
  • Безопасность исключения: Сильная. Если какое-либо пользовательское действие забрасывает исключение, то карта bimap, к которой относится заданный вид, остается в исходном состоянии.
template< class KeyModifier >
bool modify_key(iterator position, KeyModifier mod);
  • Требуется: KeyModifier представляет собой модель Unary Function, принимающую аргументы типа: key_type&; позиционирование является действительным сносным итератором представления.
  • Эффекты: Звонки mod(e.первый), где e является элементом, указанным по положению и перестраивает *позиция во все представления bimap. Если перегруппировка не удается, элемент стирается. Успешно, если перегруппировка допускается всеми другими видами bimap.
  • Постусловия: Срок действия Положение сохраняется при успешном выполнении операции.
  • Возврат: Правда, если замена состоялась, ложно в противном случае.
  • Сложность: O(M(n)).
  • Безопасность исключения: Базовая. Если исключение выбрасывается какой-либо пользовательской операцией (за исключением, возможно, мода), то элемент, указанный позицией, стирается.
  • Примечание: Только для просмотра карт.
template< class DataModifier >
bool modify_data(iterator position, DataModifier mod);
  • Требуется: DataModifier представляет собой модель Unary Function, принимающую аргументы типа: mapped_type&; позиционирование является действительным итератором представления.
  • Последствия:Звонки mod(e.второй), где e является элементом, указанным по положению и перестраивает *положение во все представления бимап. Если перегруппировка не удается, элемент стирается. Успешно, если перегруппировка допускается всеми другими видами bimap.
  • Постусловия: Срок действия Положение сохраняется при успешном выполнении операции.
  • Возврат: Правда, если замена состоялась, ложно в противном случае.
  • Сложность: O(M(n)).
  • Безопасность исключения: Базовая. Если исключение выбрасывается какой-либо пользовательской операцией (за исключением, возможно, мода), то элемент, указанный позицией, стирается.
  • Примечание: Только для просмотра карт.

list_of views предоставляет полный набор операций списка, найденных в std::list; однако семантика этих функций-членов отличается от семантики std::list в некоторых случаях, поскольку вставки могут не увенчаться успехом из-за запрета другими представлениями. Аналогично, сложность операций может зависеть от других представлений, относящихся к той же bimap.

void splice(iterator position, this_type & x);
  • Требуется: Положение является действительным итератором представления. &x!=this.
  • Последствия: Вставляет содержимое x перед положением, в том же порядке, в каком они были в x. Успешно вставленные элементы удаляются из x.
  • Сложность: O(x.x.size()+size.size.x.size)).
  • Безопасность исключения: Базовая.
void splice(iterator position, this_type & x,iterator i);
  • Требуется: Положение является действительным итератором представления. i является действительным сносным итератором x.
  • Последствия: Вставляет элемент, указанный i перед положением: если вставка успешна, элемент стирается из x. В особом случае &x== это, копия или удаление не выполняется, и операция всегда успешна. Если позиция ==i, операция не выполняется.
  • Постусловия: Если &x==это, ни итератор, ни ссылка не являются недействительными.
  • Сложность: Если &x== это, константа; в противном случае O(I(n) + D(n)).
  • Безопасность исключения: Если &x== это, не хроу; в противном случае, сильно.
void splice(iterator position, this_type & x, iterator first, iterator last);
  • Требуется: Положение является действительным итератором представления. first и last являются действительными итераторами x. последний доступен из first. позиция не находится в диапазоне [first,last).
  • Последствия:Для каждого элемента в диапазоне [первый,последний), вставка пробуется перед положением; если операция успешна, элемент стирается из x. В особом случае &x== это не выполняется ни копирование, ни удаление, а вставки всегда успешны.
  • Постусловия: Если &x==это, ни итератор, ни ссылка не являются недействительными.
  • Сложность: Если &x== это, константа; в противном случае O(m*I(n+m) + m*D(x.size())) где m - число элементов в [first,last).
  • Безопасность исключения: Если &x== это, в противном случае базовое.
void remove(const value_type & value);
  • Эффекты: Стирает все элементы представления, которые сравниваются с значением .
  • Сложность: O(n + m*D(n)), где m - число стертых элементов.
  • Безопасность исключения: Базовая.
template< class Predicate >
void remove_if(Predicate pred);
  • Эффекты: Стирает все элементы x вида, для которого pred(x).
  • Сложность: O(n + m*D(n)), где m - число стертых элементов.
  • Безопасность исключения: Базовая.
void unique();
  • Последствия:Устраняет все, кроме первого элемента, из каждой последовательной группы равных элементов, указанных итератором i в диапазоне [first,last), для которых -1.
  • Сложность: O(n + m*D(n)), где m - число стертых элементов.
  • Безопасность исключения: Базовая.
template< class BinaryPredicate >
void unique(BinaryPredicate binary_pred);
  • Эффекты: Исключает все, кроме первого элемента, из каждой последовательной группы элементов, указанных итератором i в диапазоне [первый +1, последний], для которого binary_pred(*i,*i-1)).
  • Сложность: O(n + m*D(n)), где m - число стертых элементов.
  • Безопасность исключения: Базовая.
void merge(this_type & x);
  • Требуется: std::less<value_type> представляет собой Strict Weak Ordering over value_type. И вид, и x сортируются в соответствии с std::less<value_type>.
  • Последствия:Попытки вставить каждый элемент x в соответствующее положение вида (по порядку). Успешно вставленные элементы удаляются из x. Полученная последовательность является стабильной, то есть эквивалентные элементы любого контейнера сохраняют свое относительное положение. В особом случае &x== эта операция не выполняется.
  • Постусловия: Элементы в представлении и оставшиеся элементы в x сортируются. Сохраняется действительность итераторов к виду и нестираемых элементов ссылок x.
  • Сложность: Если это, константа; в противном случае O(n + x..size.size.size.size.())).
  • Безопасность исключения: Если &x== это, в противном случае базовое.
template< class Compare >
void merge(this_type & x, Compare comp);
  • Требуется: Сравните Строгий слабый порядок с значение_тип. И вид, и x сортируются в соответствии с comp.
  • Последствия:Попытки вставить каждый элемент x в соответствующее положение вида (согласно comp). Успешно вставленные элементы удаляются из x. Полученная последовательность является стабильной, то есть эквивалентные элементы любого контейнера сохраняют свое относительное положение. В особом случае &x== эта операция не выполняется.
  • Постусловия: Элементы в представлении и оставшиеся элементы в x сортируются в соответствии с comp. Сохраняется действительность итераторов к виду и нестираемых элементов ссылок x.
  • Сложность: Если это, константа; в противном случае O(n + x..size.size.size.size.())).
  • Безопасность исключения: Если &x== это, в противном случае базовое.
void sort();
  • Требуется: std::less<value_type> представляет собой Strict Weak Ordering over value_type.
  • Эффекты: Сортирует вид по std::less<value_type>. Сортировка стабильна, т.е. эквивалентные элементы сохраняют свое относительное положение.
  • Постусловия: Сохраняется достоверность итераторов и ссылок.
  • Сложность: O(n*log(n)).
  • Безопасность исключения: nothrow, если std::less<value_type> не выбрасывает; в противном случае базовая.
template< typename Compare >
void sort(Compare comp);
  • Требуется: Сравнить Строгая слабая упорядочивание по значению_типа.
  • Последствия:Сортирует вид по комп. Сортировка стабильна, т.е. эквивалентные элементы сохраняют свое относительное положение.
  • Постусловия: Сохраняется достоверность итераторов и ссылок.
  • Сложность: O(n*log(n)).
  • Безопасность исключения: нехроу, если комп не бросает; в противном случае базовая.
void reverse();
  • Последствия:Обратный порядок элементов в представлении.
  • Постусловия: Сохраняется достоверность итераторов и ссылок.
  • Сложность: O(n).
  • Безопасность исключения: нотроу.

Эти операции без аналога в std::list (хотя сплайс обеспечивает частично перекрывающуюся функциональность), выполняют индивидуальное и глобальное перепозиционирование элементов внутри индекса.

void relocate(iterator position, iterator i);
  • Требуется: Положение является действительным итератором представления. i является допустимым итератором представления.
  • Последствия: Вставляет элемент, указанный i, перед позицией. Если позиция ==i, операция не выполняется.
  • Постусловия: Итератор или ссылка не являются недействительными.
  • Сложность:Константа.
  • Безопасность исключения: нотроу.
void relocate(iterator position, iterator first, iterator last);
  • Требуется: Положение является действительным итератором представления. first и last являются действительными итераторами представления. last доступен из first. позиция не находится в диапазоне [первый,последний).
  • Эффекты: Диапазон элементов [первый,последний) перепозиционируется непосредственно перед позиция.
  • Постусловия: Итератор или ссылка не являются недействительными.
  • Сложность:Константа.
  • Безопасность исключения: нотроу.

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

  • Требуется: Никаких дополнительных требований к тем, которые предъявляются контейнером.
  • Требования: Никаких дополнительных требований к тем, которые предъявляются контейнером. Постусловия: При успешной загрузке каждый из элементов [begin(),end является восстановленной копией соответствующего элемента в getibegin(),m>().get>().end()), где ilist_of вид в контейнере.
  • Требуется: it является действительным итератором представления. Ранее была сохранена связанная карта bimap.
  • Постусловия: При успешной загрузке, если она была сносной, *it' является восстановленной копией *itit, в противном случае it==end().
  • Примечание: Допускается, что it является const_iterator и восстановленным it' итератором, или наоборот.

PrevUpHomeNext

Статья list_of Reference раздела Chapter 1. Boost.Bimap Reference может быть полезна для разработчиков на c++ и boost.




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



:: Главная :: Reference ::


реклама


©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-07-05 02:35:32/0.0061230659484863/0