Написання власного контейнера STL


120

Чи є вказівки, як слід писати новий контейнер, який буде вести себе як будь-який STLконтейнер?


7
Перегляньте реалізацію існуючих стандартних контейнерів та спробуйте їх зрозуміти - функції, типи повернення, перевантаження операторів, вкладені типи, управління пам'яттю та все.
Наваз

Я, як правило, починаю з копіювання прототипів функцій-членів, який контейнер найближчим за концепцією до того, що я роблю, або з msdn, або зі стандарту. ( cplusplus.com не має C ++ 11 функцій, а www.sgi.com не відповідає)
Mooing Duck

@Mooing Duck: ти вважаєш, що msdn ближче до стандарту, ніж sgi?
Дані

3
Це безумовно. MSDN поточний - SGI є попереднім стандартом
Щеня

9
Найкраща онлайн-посилання (wrt повнота, коректність та особливо зручність використання) - це на сьогоднішній день cppreference.com. Це також пояснює тону мовних особливостей окрім бібліотеки. І це вікі, тому вона повинна містити менше помилок, ніж cplusplus.com.
rubenvb

Відповіді:


209

Ось послідовність псевдо-контейнер я шматочках з § 23.2.1 \ 4 Зверніть увагу , що iterator_categoryповинен бути один з std::input_iterator_tag, std::output_iterator_tag, std::forward_iterator_tag, std::bidirectional_iterator_tag, std::random_access_iterator_tag. Також зауважте, що нижче технічно суворіше, ніж потрібно, але це ідея. Зауважимо, що переважна більшість "стандартних" функцій технічно не є обов'язковою, завдяки чудовій ітерації.

template <class T, class A = std::allocator<T> >
class X {
public:
    typedef A allocator_type;
    typedef typename A::value_type value_type; 
    typedef typename A::reference reference;
    typedef typename A::const_reference const_reference;
    typedef typename A::difference_type difference_type;
    typedef typename A::size_type size_type;

    class iterator { 
    public:
        typedef typename A::difference_type difference_type;
        typedef typename A::value_type value_type;
        typedef typename A::reference reference;
        typedef typename A::pointer pointer;
        typedef std::random_access_iterator_tag iterator_category; //or another tag

        iterator();
        iterator(const iterator&);
        ~iterator();

        iterator& operator=(const iterator&);
        bool operator==(const iterator&) const;
        bool operator!=(const iterator&) const;
        bool operator<(const iterator&) const; //optional
        bool operator>(const iterator&) const; //optional
        bool operator<=(const iterator&) const; //optional
        bool operator>=(const iterator&) const; //optional

        iterator& operator++();
        iterator operator++(int); //optional
        iterator& operator--(); //optional
        iterator operator--(int); //optional
        iterator& operator+=(size_type); //optional
        iterator operator+(size_type) const; //optional
        friend iterator operator+(size_type, const iterator&); //optional
        iterator& operator-=(size_type); //optional            
        iterator operator-(size_type) const; //optional
        difference_type operator-(iterator) const; //optional

        reference operator*() const;
        pointer operator->() const;
        reference operator[](size_type) const; //optional
    };
    class const_iterator {
    public:
        typedef typename A::difference_type difference_type;
        typedef typename A::value_type value_type;
        typedef typename const A::reference reference;
        typedef typename const A::pointer pointer;
        typedef std::random_access_iterator_tag iterator_category; //or another tag

        const_iterator ();
        const_iterator (const const_iterator&);
        const_iterator (const iterator&);
        ~const_iterator();

        const_iterator& operator=(const const_iterator&);
        bool operator==(const const_iterator&) const;
        bool operator!=(const const_iterator&) const;
        bool operator<(const const_iterator&) const; //optional
        bool operator>(const const_iterator&) const; //optional
        bool operator<=(const const_iterator&) const; //optional
        bool operator>=(const const_iterator&) const; //optional

        const_iterator& operator++();
        const_iterator operator++(int); //optional
        const_iterator& operator--(); //optional
        const_iterator operator--(int); //optional
        const_iterator& operator+=(size_type); //optional
        const_iterator operator+(size_type) const; //optional
        friend const_iterator operator+(size_type, const const_iterator&); //optional
        const_iterator& operator-=(size_type); //optional            
        const_iterator operator-(size_type) const; //optional
        difference_type operator-(const_iterator) const; //optional

        reference operator*() const;
        pointer operator->() const;
        reference operator[](size_type) const; //optional
    };

    typedef std::reverse_iterator<iterator> reverse_iterator; //optional
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; //optional

    X();
    X(const X&);
    ~X();

    X& operator=(const X&);
    bool operator==(const X&) const;
    bool operator!=(const X&) const;
    bool operator<(const X&) const; //optional
    bool operator>(const X&) const; //optional
    bool operator<=(const X&) const; //optional
    bool operator>=(const X&) const; //optional

    iterator begin();
    const_iterator begin() const;
    const_iterator cbegin() const;
    iterator end();
    const_iterator end() const;
    const_iterator cend() const;
    reverse_iterator rbegin(); //optional
    const_reverse_iterator rbegin() const; //optional
    const_reverse_iterator crbegin() const; //optional
    reverse_iterator rend(); //optional
    const_reverse_iterator rend() const; //optional
    const_reverse_iterator crend() const; //optional

    reference front(); //optional
    const_reference front() const; //optional
    reference back(); //optional
    const_reference back() const; //optional
    template<class ...Args>
    void emplace_front(Args&&...); //optional
    template<class ...Args>
    void emplace_back(Args&&...); //optional
    void push_front(const T&); //optional
    void push_front(T&&); //optional
    void push_back(const T&); //optional
    void push_back(T&&); //optional
    void pop_front(); //optional
    void pop_back(); //optional
    reference operator[](size_type); //optional
    const_reference operator[](size_type) const; //optional
    reference at(size_type); //optional
    const_reference at(size_type) const; //optional

    template<class ...Args>
    iterator emplace(const_iterator, Args&&...); //optional
    iterator insert(const_iterator, const T&); //optional
    iterator insert(const_iterator, T&&); //optional
    iterator insert(const_iterator, size_type, T&); //optional
    template<class iter>
    iterator insert(const_iterator, iter, iter); //optional
    iterator insert(const_iterator, std::initializer_list<T>); //optional
    iterator erase(const_iterator); //optional
    iterator erase(const_iterator, const_iterator); //optional
    void clear(); //optional
    template<class iter>
    void assign(iter, iter); //optional
    void assign(std::initializer_list<T>); //optional
    void assign(size_type, const T&); //optional

    void swap(X&);
    size_type size() const;
    size_type max_size() const;
    bool empty() const;

    A get_allocator() const; //optional
};
template <class T, class A = std::allocator<T> >
void swap(X<T,A>&, X<T,A>&); //optional

Крім того, щоразу, коли я роблю контейнер, я тестуюсь з класом, більш-менш подібним:

#include <cassert>
struct verify;
class tester {
    friend verify;
    static int livecount;
    const tester* self;
public:
    tester() :self(this) {++livecount;}
    tester(const tester&) :self(this) {++livecount;}
    ~tester() {assert(self==this);--livecount;}
    tester& operator=(const tester& b) {
        assert(self==this && b.self == &b);
        return *this;
    }
    void cfunction() const {assert(self==this);}
    void mfunction() {assert(self==this);}
};
int tester::livecount=0;
struct verify {
    ~verify() {assert(tester::livecount==0);}
}verifier;

Створіть контейнери з testerпредметами та зателефонуйте кожному, function()коли ви перевіряєте контейнер. Не складайте жодних глобальних testerоб’єктів. Якщо ваш контейнер обманює будь-де, цей testerклас буде, assertі ви дізнаєтесь, що ви обдурили випадково десь.


1
Це цікаво. Як працює ваш тестер? Є кілька помилок розбору, які є тривіальними (відсутні ';'), але не впевнені, як працює ця перевірка деструктора. О, ти мав на увазі assert(tester::livecount == 0);. Мммм, все ще не впевнений, як працює цей тестер-каркас. Чи можете ви навести приклад?
Адріан

2
У тестера є один нестатичний член, який вказує на себе, і деструктор та члени - це спосіб перевірити, чи не memcpyсталося недійсного . (тест не є надійним, але він захоплює деякі). Це livecountпростий детектор витоку, щоб переконатися, що ваш контейнер назвав рівну кількість конструкторів та деструкторів.
Mooing Duck

Гаразд, я це бачу, але як це перевіряє ваш ітератор? До речі, я думаю, ти цього verifierне мав на увазі varifier.
Адріан

4
@ Adrian Ні, ні, ви пишете свій контейнер, а потім поміщаєте купу цього в контейнер і робите все з контейнером, щоб переконатися, що ви випадково не заповнили пам’ять, і пам’ятали, щоб викликати всіх деструкторів.
Mooing Duck

1
я можу запропонувати успадкувати ітератор від std::iteratorзаголовка<iterator>
sp2danny

28

Вам потрібно буде прочитати розділ Стандарт C ++ про контейнери та вимоги, які встановлює стандарт C ++ для реалізації контейнерів.

Відповідна глава стандарту C ++ 03:

Розділ 23.1 Вимоги до контейнера

Відповідна глава стандарту C ++ 11:

Розділ 23.2 Вимоги до контейнера

Майже остаточний проект ++ 11 стандарту C знаходиться в вільному доступі тут .

Ви також можете прочитати кілька чудових книг, які допоможуть вам зрозуміти вимоги з точки зору користувача контейнера. Дві чудові книги, які легко вразили мене:

Ефективне STL відScott Meyers &
The ++ Стандартної бібліотеки C: підручник і довідник поNicolai Josutils


6

Ось дуже спрощена реалізація підробленого вектора, який в основному є обгорткою навколо std::vectorі має власний (але реальний) ітератор, який імітує ітератор STL. Знову ж таки, ітератор дуже спрощений, пропускаючи багато понять, наприклад const_iterator, перевірки дійсності тощо.

Код можна отримати з коробки.

#include <iostream>
#include <string>
#include <vector>

template<typename T>
struct It
{
    std::vector<T>& vec_;
    int pointer_;

    It(std::vector<T>& vec) : vec_{vec}, pointer_{0} {}

    It(std::vector<T>& vec, int size) : vec_{vec}, pointer_{size} {}

    bool operator!=(const It<T>& other) const
    {
        return !(*this == other);
    }

    bool operator==(const It<T>& other) const
    {
        return pointer_ == other.pointer_;
    }

    It& operator++()
    {
        ++pointer_;            
        return *this;
    }

    T& operator*() const
    {
        return vec_.at(pointer_);   
    }
};

template<typename T>
struct Vector
{
    std::vector<T> vec_;

    void push_back(T item)
    {
        vec_.push_back(item);
    };

    It<T> begin()
    {
        return It<T>(vec_);
    }

    It<T> end()
    {
        return It<T>(vec_, vec_.size());
    }
};

int main()
{
  Vector<int> vec;
  vec.push_back(1);
  vec.push_back(2);
  vec.push_back(3);

  bool first = true;
  for (It<int> it = vec.begin(); it != vec.end(); ++it)
  {
      if (first) //modify container once while iterating
      {
          vec.push_back(4);
          first = false;
      }

      std::cout << *it << '\n'; //print it 
      (*it)++;                  //change it
  }

  for (It<int> it = vec.begin(); it != vec.end(); ++it)
  {
      std::cout << *it << '\n'; //should see changed value
  }
}
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.