株式会社エス・スリー・フォー

slist<T, Alloc> リファレンス

※ slist<T,Alloc>はSGI版STLが提供するコンテナクラスであり、標準C++ライブラリには含まれていません。
しかしながらこのSGI版STLは大元のHPのリファレンス実装の直系で、STLportなど様々なSTL実装のベースとなっていることから、事実上の標準といっても差支えないものです。gccもこのSGI版STL（もしくはSTLport)を採用しています。

slistは単方向リンクリストです。slist内の各要素は次の要素へのリンクを持っていますが、双方向リンクリスト:std::listのように前の要素へのリンクを持ってはいません。

したがって、(std::listのイテレータが双方向イテレータであるのに対し)slistのイテレータは ‘前方向イテレータ’ であり、イテレータの指す位置を遡ることはできません(operator–()を持っていません)。

また、前の要素へのリンクを持たないことから、std::listにある末尾に対する参照/追加/削除メソッド back / push_back / pop_back をサポートしていません。

slistはstd::listに比べて機能的には劣ります。が、双方向イテレータを必要としない用途であれば、管理しなければならないリンクが単方向で済むため、std::listより若干ながらコンパクトかつ高速です。

標準C++が定めるコンテナの要求を満たすため、slistにはstd::listと同等のメソッドが実装されています。
しかしながら前の要素へのリンクを持たないため、inssertやeraseはstd::listよりかなり低速(要素数に比例)であることに留意してください。代替メソッドとして、定数時間で処理を行なうinsert_after, erase_afterが用意されています。 できる限りこれらをお使いください。

サンプル

#include <slist>
#include <iostream>
#include <algorithm>

using namespace std;
int main() {
  slist<int> L;
  L.push_front(0);
  L.push_front(1);
  L.insert_after(L.begin(), 2);
  copy(L.begin(), L.end(),    // 出力: 1 2 0
       ostream_iterator<int>(cout, " "));
  cout << endl;

  slist<int>::iterator back = L.previous(L.end());
  back = L.insert_after(back, 3);
  back = L.insert_after(back, 4);
  back = L.insert_after(back, 5);
  copy(L.begin(), L.end(),    // 出力: 1 2 0 3 4 5
       ostream_iterator<int>(cout, " "));
  cout << endl;
  return 0;
}

<slist>

/*
 * このヘッダは STLport-4.5-01119 を基に作成されたものであり、
 * SGIオリジナル(後述のメソッド一覧)と完全には一致していません
 */

template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
class slist : protected _Slist_base<_Tp,_Alloc>
{
public:
  typedef _Tp                  value_type;
  typedef value_type*          pointer;
  typedef const value_type*    const_pointer;
  typedef value_type&          reference;
  typedef const value_type&    const_reference;
  typedef size_t               size_type;
  typedef ptrdiff_t            difference_type;
  typedef forward_iterator_tag _Iterator_category;

  typedef _Slist_iterator<_Tp, _Nonconst_traits<_Tp> >  iterator;
  typedef _Slist_iterator<_Tp, _Const_traits<_Tp> >     const_iterator;

  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
  typedef typename _Base::allocator_type allocator_type;

public:

  allocator_type get_allocator() const;

  explicit slist(const allocator_type& __a = allocator_type());
  slist(size_type __n, const value_type& __x,
        const allocator_type& __a =  allocator_type());
  explicit slist(size_type __n);
  template <class _InputIterator>
  slist(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL);
  slist(const _Self& __x);

  _Self& operator= (const _Self& __x);

  ~slist() {}

  void assign(size_type __n, const _Tp& __val);

  template <class _InputIterator>
    void assign(_InputIterator __first, _InputIterator __last);

  iterator before_begin();
  const_iterator before_begin() const;

  iterator begin();
  const_iterator begin() const;

  iterator end();
  const_iterator end() const;

  size_type size() const;
  size_type max_size() const;
  bool empty() const;

  void swap(_Self& __x);

  reference front();
  const_reference front() const;

  void push_front();
  void pop_front();

  iterator previous(const_iterator __pos);
  const_iterator previous(const_iterator __pos) const;

  iterator insert_after(iterator __pos, const value_type& __x);
  iterator insert_after(iterator __pos);
  void insert_after(iterator __pos, size_type __n, const value_type& __x);
  template <class _InIter>
    void insert_after(iterator __pos, _InIter __first, _InIter __last);

  iterator insert(iterator __pos, const value_type& __x);
  iterator insert(iterator __pos);
  void insert(iterator __pos, size_type __n, const value_type& __x);
  template <class _InIter>
    void insert(iterator __pos, _InIter __first, _InIter __last);

  iterator erase_after(iterator __pos);
  iterator erase(iterator __pos);
  iterator erase(iterator __first, iterator __last);

  void resize(size_type new_size, const _Tp& __x);
  void resize(size_type new_size);
  void clear();
  void splice_after(iterator __pos,
                    iterator __before_first, iterator __before_last);
  void splice_after(iterator __pos, iterator __prev);
  void splice_after(iterator __pos, _Self& __x);
  void splice(iterator __pos, _Self& __x);
  void splice(iterator __pos, _Self& __x, iterator __i);
  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last);

  void reverse();

  void remove(const _Tp& __val);
  void unique();
  void merge(_Self& __x);
  void sort();     

  template <class _Predicate>
    void remove_if(_Predicate __pred);
  template <class _BinaryPredicate>
    void unique(_BinaryPredicate __pred);
  template <class _StrictWeakOrdering>
    void merge(slist<_Tp,_Alloc>& __x, _StrictWeakOrdering __comp);

  template <class _StrictWeakOrdering>
    void sort(_StrictWeakOrdering __comp);
};

メソッド一覧