forward_list Class

描述物件來控制元素的順序不同的長度。 序列會儲存成單向連結的節點清單，每一個都會包含型別的成員Type。

template<class Type, class Allocator = allocator<Type> >
    class forward_list {
public:
    typedef Allocator allocator_type;
    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer
        const_pointer;
    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;
    typedef typename Allocator::value_type value_type;
    typedef typename Allocator::size_type size_type;
    typedef typename Allocator::difference_type difference_type;

    typedef T0 iterator;
    typedef T1 const_iterator;

    forward_list();
    explicit forward_list(const Allocator& _Alloc);
    explicit forward_list(size_type _Count);
    forward_list(
        size_type _Count, 
        const Type& _Val
    );
    forward_list(
        size_type _Count, 
        const Type& _Val, 
        const Allocator& _Alloc
    );
    forward_list(const forward_list& _Right);
    template<class InputIterator>
        forward_list (
            InputIterator _First, 
            InputIterator _Last
);
    template<class InputIterator>
        forward_list (
            InputIterator _First,
            InputIterator _Last, 
            const Allocator& _Alloc
);

    forward_list (initializer_list<Type> _Init)
    forward_list (
        initializer_list<Type> _Init,
        const Allocator& _Alloc
);
    forward_list (forward_list&& _Right);
 
    ~forward_list();

    forward_list& operator= (const forward_list& _Right);
    forward_list& operator= (forward_list&& _Right);

    iterator before_begin ();
    const_iterator before_begin () const;
    iterator begin ();
    const_iterator begin () const;
    iterator end ();
    const_iterator end () const;

    const_iterator cbefore_begin () const;
    const_iterator cbegin () const;
    const_iterator cend () const;

    void resize (size_type _Count);
    void resize (
        size_type _Count, 
        const Type& _Val
    );
    size_type max_size () const;
    bool empty () const;

    Alloc get_allocator () const;

    reference front ();
    const_reference front () const;

    void push_front (const Type& _Val);
    void push_front (Type&& _Val);
    template<class _Type>
        void emplace_front(_Type&& _Val);
    void pop_front ();

    template<class InputIterator>
        void assign (
            InputIterator _First, 
            InputIterator _Last
);
    void assign (
        size_type _Count, 
        const Type& _Val
    );

    iterator insert_after (
        const_iterator _Pos, 
        const Type& _Val
    );
    void insert_after (
        const_iterator _Pos, 
        size_type _Count, 
        const Type& _Val
    );
    template<class InputIterator >
        void insert_after (
            const_iterator _Pos, 
            InputIterator _First, 
            InputIterator _Last
        );
    void insert_after (
        const iterator _Pos, 
        initializer_list<Type> _Init
)
    iterator insert_after (
        const_iterator _Pos, 
        Type&& _Val
    );
    template<class Type>
        iterator emplace_after(const_iterator _Where, Type&& _Val);
    iterator erase_after (const_iterator _Pos);
    iterator erase_after (
        const_iterator _First, 
        const_iterator _Last
    );
    void clear ();

    void swap (forward_list& _Right);

    void splice_after (
        const_iterator _Pos, 
        forward_list& _List
    );
    void splice_after (
        const_iterator _Pos, 
        forward_list& _List, 
        iterator _First
    );
    void splice_after (
        const_iterator _Pos, 
        forward_list& _List, 
        iterator _First,
        iterator _Last);

    void remove (const Type& _Val);
    template<class Predicate>
        void remove_if (Predicate _Pred);
    void unique ();
    template<class BinaryPredicate>
        void unique (BinaryPredicate _Comp);

    void merge (forward_list& _List);
    template<class BinaryPredicate>
        void merge (
            forward_list& _List, 
            BinaryPredicate _Comp
);
    void sort ();
    template<class BinaryPredicate>
        void sort (BinaryPredicate _Comp);
    void reverse ();
};

參數

參數	描述
Type	若要儲存在 forward_list 元素資料型別。
_Alloc	預存的配置器物件，它可封裝 forward_list 配置及解除配置記憶體的詳細資料。 這個參數是一個選擇性項目。 預設值是配置 <Type>。
_Count	在 forward_list 中的項目數。
_Val	若要加入的項目forward_list。
_Right	若要將合併至清單forward_list。
_Pos	指出指定位置的 iterator forward_list。
_First	表示範圍中的項目之開始位置的 iterator forward_list。
_Last	表示範圍中的項目結尾位置的 iterator forward_list。
_Init	初始設定式清單
_List	若要合併，forward_list 分離，或從指定。
_Comp	比較函式。

備註

A forward_list物件配置和釋放它控制透過預存的物件類別的順序儲存Allocator為基礎allocator Class (通常稱為std::allocator)。 如需詳細資訊，請參閱 Allocators。 配置器物件必須要有相同的外部介面的樣板類別物件allocator。

注意事項
指派給容器物件時，不會複製預存的配置器物件。

Iterator、 指標和參考可能會變成無效時透過刪除其受控制序列的項目時forward_list。 透過受控制序列上執行的插入與 splices forward_list無法確認 iterator。

加入受控制序列的項目可能是由呼叫forward_list::insert_after，也就是唯一的成員函式呼叫的建構函式Type(const _Type&)。 forward_list可能也會呼叫移動建構函式。 如果這類運算式擲回例外狀況，容器物件插入新的項目，並重新擲回例外狀況。 因此，樣板類別的物件forward_list這類例外狀況發生時，會處於已知狀態。

建構函式

forward_list

建構型別的物件forward_list。

Typedef

allocator_type	表示順向的清單物件的配置器類別的型別。
const_iterator	此型別常數的 iterator 提供順向的清單。
const_pointer	提供型別，變數的指標， const順向的清單中的項目。
const_reference	此型別提供常數參考 [向前] 清單中的項目。
difference_type	由 iterator 指向帶正負號的整數型別，可以用來表示順向的清單項目之間的範圍內的項目數。
Iterator	提供 [向前] 清單中的 iterator 型別。
pointer	提供型別，變數的指標，[向前] 清單中的項目。
參考	提供 [向前] 清單中的項目參考型別。
size_type	表示兩個元素之間的不帶正負號的距離的型別。
value_type	儲存轉寄的清單中的元素的型別表示的型別。

成員函式

assign	清除 [正向清單中的項目，並將一組新的項目複製到目標的順向清單。
before_begin	傳回 iterator 定址順向的清單中的第一個元素位置。
begin	傳回 iterator 定址順向的清單中的第一個項目。
cbefore_begin	傳回常數的 iterator 定址順向的清單中的第一個元素位置。
cbegin	傳回常數的 iterator 定址順向的清單中的第一個項目。
cend	傳回常數的 iterator，解決後續順向的清單中的最後一個元素的位置。
clear	清除 [正向清單的所有項目。
emplace_after	移動指定的位置之後，建構新的項目。
emplace_front	將清單的開頭來建構項目。
empty	測試是否正向的清單是空的。
end	Iterator 可解決成功順向的清單中的最後一個元素的位置，它會傳回。
erase_after	移除 [向前] 清單中的項目之後的指定位置。
front	在 [正向清單中傳回第一個項目的參考。
get_allocator	傳回一份用來建構順向的清單配置器物件。
insert_after	將元素加入至 [向前] 清單中，指定的位置之後。
max_size	會傳回正向清單的最大長度。
merge	從引數清單中移除項目、 將其插入目標的順向清單中，以及新的合併一組項目以遞增順序或其他指定的順序，排序。
pop_front	刪除的順向的清單開頭處的項目。
push_front	將元素加入至正向清單的開頭。
remove	清除 [正向符合指定的值清單中的項目。
remove_if	清除中滿足指定之述詞的話正向清單的項目。
resize	指定新的大小，如需順向的清單。
反向	反向的順序發生順向的清單中的項目。
sort	排列元素，以遞增順序或述詞所指定的順序。
splice_after	Restitches 節點之間的連結。
交換	交換兩個正向清單的項目。
unique	移除通過指定測試的相鄰項目。

運算子

operator=

另一個正向清單的複本來取代 [向前] 清單中的項目。

需求

標頭: <forward_list>

Namespace: 標準

請參閱

參考

<forward_list>

其他資源

<forward_list> 成員