共用方式為


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這類例外狀況發生時,會處於已知狀態。

Ee373559.collapse_all(zh-tw,VS.110).gif建構函式

forward_list

建構型別的物件forward_list。

Ee373559.collapse_all(zh-tw,VS.110).gifTypedef

allocator_type

表示順向的清單物件的配置器類別的型別。

const_iterator

此型別常數的 iterator 提供順向的清單。

const_pointer

提供型別,變數的指標, const順向的清單中的項目。

const_reference

此型別提供常數參考 [向前] 清單中的項目。

difference_type

由 iterator 指向帶正負號的整數型別,可以用來表示順向的清單項目之間的範圍內的項目數。

Iterator

提供 [向前] 清單中的 iterator 型別。

pointer

提供型別,變數的指標,[向前] 清單中的項目。

參考

提供 [向前] 清單中的項目參考型別。

size_type

表示兩個元素之間的不帶正負號的距離的型別。

value_type

儲存轉寄的清單中的元素的型別表示的型別。

Ee373559.collapse_all(zh-tw,VS.110).gif成員函式

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

移除通過指定測試的相鄰項目。

Ee373559.collapse_all(zh-tw,VS.110).gif運算子

operator=

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

需求

標頭: <forward_list>

Namespace: 標準

請參閱

參考

<forward_list>

其他資源

<forward_list> 成員