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 ();
};

매개 변수

Parameter	설명
Type	요소 데이터 형식 forward_list에 저장할 수 있습니다.
_Alloc	Forward_list 할당 및 메모리 할당 취소 하는 방법에 대 한 세부 정보를 캡슐화 하는 저장된 할당자 개체입니다.이 매개 변수는 선택적 요소입니다.기본값은 할당자입니다 <Type>.
_Count	Forward_list의 요소 개수입니다.
_Val	요소를 추가 하는 forward_list.
_Right	목록에 통합 하는 forward_list.
_Pos	반복기가 나타내는 위치에 있는 forward_list.
_First	요소 범위의 시작 위치를 나타내는 반복기는 forward_list.
_Last	요소 범위의 끝 위치를 나타내는 반복기는 forward_list.
_Init	이니셜라이저 목록
_List	병합 하거나 스플라이스를 할당 하는 forward_list.
_Comp	비교 함수입니다.

설명

A forward_list 개체를 할당 하 고 해제 저장소 시퀀스 제어를 통해 저장 된 개체 클래스의 Allocator 를 기반으로 allocator Class (일반적으로 알려진 std::allocator).자세한 내용은 할당자를 참조하십시오.할당자 개체 템플릿 클래스의 개체를 같은 외부 인터페이스가 있어야 합니다. allocator.

[!참고]

컨테이너 개체는 할당 될 때 저장 된 할당자 개체는 복사 되지 않습니다.

반복기, 포인터 및 참조 될 수 있습니다 잘못 된 제어 되는 시퀀스의 요소를 통해 지운 경우 forward_list.삽입 및 스플라이스 수행을 통해 제어 되는 시퀀스에서 forward_list 반복기를 무효화 하지는 않습니다.

호출에 의해 제어 되는 시퀀스에 추가 발생할 forward_list::insert_after, 생성자를 호출 하는 유일한 멤버 함수는 Type(const _Type&).forward_list또한 호출 생성자에 이동할 수 있습니다.식에서 예외를 throw 하는 경우 컨테이너 개체 새 요소를 삽입 하 고 예외를 다시 throw 합니다.따라서 개체 템플릿 클래스의 forward_list 와 같은 예외가 발생 하면 알려진된 상태에 유지 됩니다.

생성자

forward_list

개체 형식의 생성 forward_list.

형식 정의

allocator_type	할당자 클래스의 정방향 list 개체를 나타내는 형식.
const_iterator	상수는 반복기 앞으로 목록을 제공 하는 형식입니다.
const_pointer	에 대 한 포인터를 제공 하는 형식에 const 앞으로 목록의 요소입니다.
const_reference	앞의 목록에 있는 요소에 대 한 상수 참조를 제공 하는 형식입니다.
difference_type	정방향 반복기가 가리키는 요소 사이의 범위에서 목록의 요소 수를 나타내는 데 사용 되는 부호 있는 정수 형식입니다.
반복기	앞 목록에 대 한 반복기를 제공 하는 형식입니다.
pointer	앞 목록에서 해당 요소에 대 한 포인터를 제공 하는 형식입니다.
reference	앞 목록에서 해당 요소에 대 한 참조를 제공 하는 형식입니다.
size_type	부호 없는 두 요소 사이의 거리를 나타내는 형식입니다.
value_type	앞 목록에 저장 된 요소 유형을 나타내는 형식.

멤버 함수

assign	요소 전달 목록에서 지워지고 전달 대상 목록에 새 요소 집합을 복사 합니다.
before_begin	앞 목록에서 첫 번째 요소 앞에 위치를 주소 지정 하는 반복기를 반환 합니다.
begin	첫 번째 요소 앞의 목록에 주소를 지정 하는 반복기를 반환 합니다.
cbefore_begin	Const 정방향 목록에서 첫 번째 요소 앞에 위치를 주소 지정 하는 반복기를 반환 합니다.
cbegin	Const의 첫 번째 요소 앞의 목록에 주소를 지정 하는 반복기를 반환 합니다.
cend	앞으로 목록의 마지막 요소 다음에 나오는 위치 주소는 const 반복기를 반환 합니다.
clear	앞으로 목록의 모든 요소를 지웁니다.
emplace_after	이동 후 지정 된 위치에 새 요소를 생성합니다.
emplace_front	목록의 시작 부분으로 현재 위치에서 구성 요소를 추가 합니다.
empty	앞으로 목록이 비어 있는지 여부를 테스트 합니다.
end	앞으로 목록의 마지막 요소 다음에 나오는 위치를 설명 하는 반복기를 반환 합니다.
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>

네임 스페이스: std

참고 항목

참조

<forward_list>

기타 리소스

<forward_list> 멤버