C++

参考

<iterator>

类模板
<iterator>

std::front_insert_iterator

template <class Container> class front_insert_iterator;
前向插入迭代器

前向插入迭代器是一种特殊的 输出迭代器，它允许通常会覆盖元素的 算法（例如 copy）转而将新元素插入到容器的开头。

该容器需要有一个名为 push_front 的成员函数（例如标准容器 deque 和 list）。

对 front_insert_iterator 使用赋值运算符（无论是通过解引用还是直接使用），都会导致容器扩展一个元素，该元素会被赋给它的值进行初始化。

对于 front_insert_iterator，也定义了 输出迭代器 的其他典型运算符，但它们没有实际效果：所有赋给它们的值都会被插入到容器的开头。

它的定义与以下行为相同：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
template <class Container>
  class front_insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void>
{
protected:
  Container* container;

public:
  typedef Container container_type;
  explicit front_insert_iterator (Container& x) : container(&x) {}
  front_insert_iterator<Container>& operator= (typename Container::const_reference value)
    { container->push_front(value); return *this; }
  front_insert_iterator<Container>& operator* ()
    { return *this; }
  front_insert_iterator<Container>& operator++ ()
    { return *this; }
  front_insert_iterator<Container> operator++ (int)
    { return *this; }
};
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
template <class Container>
  class front_insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void>
{
protected:
  Container* container;

public:
  typedef Container container_type;
  explicit front_insert_iterator (Container& x) : container(&x) {}
  front_insert_iterator<Container>& operator= (const typename Container::value_type& value)
    { container->push_front(value); return *this; }
  front_insert_iterator<Container>& operator= (typename Container::value_type&& value)
    { container->push_front(std::move(value)); return *this; }
  front_insert_iterator<Container>& operator* ()
    { return *this; }
  front_insert_iterator<Container>& operator++ ()
    { return *this; }
  front_insert_iterator<Container> operator++ (int)
    { return *this; }
};
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
template <class Container>
  class front_insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void>
{
protected:
  Container* container;

public:
  typedef Container container_type;
  explicit front_insert_iterator (Container& x) : container(std::addressof(x)) {}
  front_insert_iterator<Container>& operator= (const typename Container::value_type& value)
    { container->push_front(value); return *this; }
  front_insert_iterator<Container>& operator= (typename Container::value_type&& value)
    { container->push_front(std::move(value)); return *this; }
  front_insert_iterator<Container>& operator* ()
    { return *this; }
  front_insert_iterator<Container>& operator++ ()
    { return *this; }
  front_insert_iterator<Container> operator++ (int)
    { return *this; }
};

库提供了一个名为 front_inserter 的函数，它可以从合适的容器自动生成一个 front_insert_iterator 类。

模板参数

容器
一个定义了 push_front 成员函数的容器类（例如标准容器 deque 和 list）。

成员类型

成员在 front_insert_iterator 中的定义
iterator_categoryoutput_iterator_tag
value_typevoid
difference_typevoid
指针void
引用void
iterator_typevoid

成员函数

构造函数
front_insert_iterator 对象由一个容器构造，它们在内部保留该容器的引用。
operator=
在容器的开头插入一个新元素，并用参数对其进行初始化。
operator*
无操作。返回对象的引用。
operator++
无操作。返回对象的引用。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
// front_insert_iterator example
#include <iostream>     // std::cout
#include <iterator>     // std::front_insert_iterator
#include <deque>        // std::deque
#include <algorithm>    // std::copy

int main () {
  std::deque<int> foo, bar;
  for (int i=1; i<=5; i++)
  { foo.push_back(i); bar.push_back(i*10); }

  std::front_insert_iterator< std::deque<int> > front_it (foo);

  std::copy (bar.begin(),bar.end(),front_it);

  std::cout << "foo:";
  for ( std::deque<int>::iterator it = foo.begin(); it!= foo.end(); ++it )
	  std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

输出

50 40 30 20 10 1 2 3 4 5


另见

front_inserter
构造前向插入迭代器 (函数模板)
back_insert_iterator
后向插入迭代器 (类模板)
insert_iterator
插入迭代器(类模板)