C++迭代器操作

一、advance

头文件iterator

template <class InputIterator, class Distance>
  void advance (InputIterator& it, Distance n);

推进迭代器
通过n个元素位置推进迭代器。

如果它是随机访问迭代器,则该函数仅使用一次operator +或operator-。 否则,该函数重复使用增加或减少运算符(运算符++或运算符 - ),直到n个元素被提前。

参数

  1. it
    迭代器要先进。
    InputIterator至少应该是一个输入迭代器。
  2. n
    要提前的元素位置数。
    这对随机访问和双向迭代器只是负面的。
    Distance应为能够表示此类迭代器之间距离的数值类型。

返回值

没有

// advance example
#include <iostream>     // std::cout
#include <iterator>     // std::advance
#include <list>         // std::list

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::list<int>::iterator it = mylist.begin();

  std::advance (it,5);

  std::cout << "The sixth element in mylist is: " << *it << '\n';

  return 0;
}

在这里插入图片描述

复杂度

随机访问迭代器的常量。
否则,线性为n。

迭代器有效性

推进一个至少不是前向迭代器的输入迭代器可能会使从其值获得的任何迭代器,指针和引用无效。

数据范围

该函数修改迭代器,但它永远不会被解引用(调用不会访问指向对象)。
还要注意上面描述的对迭代器有效性的影响。

异常

如果在迭代器上执行的任何算术运算抛出,则抛出,提供与此类操作相同的保证级别。

二、distance

template<class InputIterator>
  typename iterator_traits<InputIterator>::difference_type
    distance (InputIterator first, InputIterator last);

返回迭代器之间的距离
计算第一个和最后一个之间的元素数。

如果它是随机访问迭代器,则函数使用operator-来计算它。 否则,该函数重复使用增量运算符(operator ++)。

参数

  1. first
    迭代器指向初始元素。
  2. last
    迭代器指向最后的元素。 这必须从一开始就可以到达。

InputIterator至少应该是一个输入迭代器。

返回值

第一个和最后一个之间的元素数量。

// distance example
#include <iostream>     // std::cout
#include <iterator>     // std::distance
#include <list>         // std::list

int main () {
	std::list<int> mylist;
	for (int i=0; i<10; i++) mylist.push_back (i*10);

	std::list<int>::iterator first = mylist.begin();
	std::list<int>::iterator last = mylist.end();

	std::cout << "The distance is: " << std::distance(first,last) << '\n';

	return 0;
}

在这里插入图片描述

复杂度

随机访问迭代器的常量。
否则,线性为n。

迭代器有效性

如果InputIterator不是至少一个前向迭代器,那么首先和任何迭代器,从其值获得的指针和引用可能会失效。

数据范围

该函数访问两个迭代器,但没有解除引用(调用不访问指向对象)。
还要注意上面描述的对迭代器有效性的影响。

异常

如果在迭代器上执行的任何算术运算抛出,则抛出,提供与此类操作相同的保证级别。

三、begin

头文件iterator、array、deque、forward_list、list、map、regex、set、string、unordered_map、unordered_set、vector
【C++ 11】

container (1)	
template <class Container>
  auto begin (Container& cont) -> decltype (cont.begin());
template <class Container>
  auto begin (const Container& cont) -> decltype (cont.begin());
array (2)	
template <class T, size_t N>
  T* begin (T(&arr)[N]);

迭代开始
返回指向序列中第一个元素的迭代器:

(1)容器
该函数返回cont.begin()。
(2)数组
该函数返回其参数的数组到指针的转换。

如果序列为空,则不应取消引用返回的值。

这些函数模板在多个头文件中定义:这些头文件中的每一个都包含所有容器和数组类型的通用模板,而不仅仅是特定的重载。 头文件是:<iterator>,<array>,<deque>,<forward_list>,<list>,<map>,<regex>,<set>,<string>,<unordered_map>,<unordered_set>和<vector>。

相反,<initializer_list>和<valarray>中的begin被重载(具有不同的定义)。

参数

  1. cont
    定义了成员begin的类类型的对象。
  2. arr
    数组。

返回值

对于(1),与cont.begin()返回的相同。
对于(2),指向数组中第一个元素的指针。

数据范围

访问该参数但未修改。
调用不会访问序列中的任何元素,但返回的迭代器可用于访问或修改它们。

异常

提供与对参数执行的操作相同级别的保证(对于标准容器和数组,这是一种无抛出保证)。

四、end

头文件iterator、array、deque、forward_list、list、map、regex、set、string、unordered_map、unordered_set、vector
【C++ 11】

container (1)	
template <class Container>
  auto end (Container& cont) -> decltype (cont.end());
template <class Container>
  auto end (const Container& cont) -> decltype (cont.end());
array (2)	
template <class T, size_t N>
  T* end (T(&arr)[N]);

迭代器结束
返回指向序列中的past-the-end元素的迭代器:

(1)容器
该函数返回cont.end()。
(2)数组
该函数返回arr + N.

如果序列为空,则返回的值将与begin返回的值相等,并使用相同的参数。

这些函数模板在多个头文件中定义:这些头文件中的每一个都包含所有容器和数组类型的通用模板,而不仅仅是特定的重载。 标题是:<iterator>,<array>,<deque>,<forward_list>,<list>,<*map>*,<regex>,<set>,<string>,<unordered_map>,<unordered_set>和<vector>。

相反,在头<initializer_list>和<valarray>中,end被重载(具有不同的定义)。

参数

  1. cont
    定义成员结束的类类型的对象。
  2. arr
    数组。

返回值

对于(1),与cont.end()返回的相同。
对于(2),指向将跟随数组中最后一个元素的元素的指针。

// std::begin / std::end example
#include <iostream>     // std::cout
#include <vector>       // std::vector, std::begin, std::end

int main () {
  int foo[] = {10,20,30,40,50};
  std::vector<int> bar;

  // iterate foo: inserting into bar
  for (auto it = std::begin(foo); it!=std::end(foo); ++it)
    bar.push_back(*it);

  // iterate bar: print contents:
  std::cout << "bar contains:";
  for (auto it = std::begin(bar); it!=std::end(bar); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

在这里插入图片描述

数据范围

访问该参数但未修改。
调用不会访问序列中的任何元素,但返回的迭代器可用于访问或修改它们。

异常

提供与对参数执行的操作相同级别的保证(对于标准容器和数组,这是一种无抛出保证)。

五、prev

头文件iterator

template <class BidirectionalIterator>
  BidirectionalIterator prev (BidirectionalIterator it,
       typename iterator_traits<BidirectionalIterator>::difference_type n = 1);

获取前一个元素的迭代器
返回一个迭代器,指向如果高级-n位置它将指向的元素。

如果它是随机访问迭代器,则该函数仅使用一次operator +或operator-。 否则,该函数在复制的迭代器上重复使用增加或减少运算符(operator ++或operator–),直到n个元素被提前。

参数

  1. it
    迭代器到基地位置。
    BidirectionalIterator至少应该是一个双向迭代器。
  2. n
    元素位置偏移量(默认为1)。
    difference_type是表示BidirectionalIterator类型的迭代器之间的距离的数字类型。

返回值

元素n的迭代器位于it之前。

// prev example
#include <iostream>     // std::cout
#include <iterator>     // std::next
#include <list>         // std::list
#include <algorithm>    // std::for_each

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::cout << "The last element is " << *std::prev(mylist.end()) << '\n';

  return 0;
}

在这里插入图片描述

复杂度

随机访问迭代器的常量。
对于双向迭代器,n为线性。

迭代器有效性

没有效果。

数据范围

该函数访问迭代器,但它永远不会被解引用(调用不会访问指向的对象)。

异常

如果对复制的迭代器执行的任何算术运算抛出,则抛出,提供与此类操作相同的保证级别。

六、next

头文件iterator

template <class ForwardIterator>
  ForwardIterator next (ForwardIterator it,
       typename iterator_traits<ForwardIterator>::difference_type n = 1);

获取下一个元素的迭代器
返回一个迭代器,指向如果高级n位置它将指向的元素。

它没有被修改。

如果它是随机访问迭代器,则该函数仅使用一次operator +或operator-。 否则,该函数在复制的迭代器上重复使用增加或减少运算符(operator ++或operator–),直到n个元素被提前。

参数

  1. it
    迭代器到基地位置。
    ForwardIterator至少应是一个前向迭代器。
  2. n
    元素位置偏移量(默认为1)。
    这对随机访问和双向迭代器只是负面的。
    difference_type是表示ForwardIterator类型的迭代器之间的距离的数字类型。

返回值

元素n的迭代器远离it。

// next example
#include <iostream>     // std::cout
#include <iterator>     // std::next
#include <list>         // std::list
#include <algorithm>    // std::for_each

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::cout << "mylist:";
  std::for_each (mylist.begin(),
                 std::next(mylist.begin(),5),
                 [](int x) {std::cout << ' ' << x;} );

  std::cout << '\n';

  return 0;
}

在这里插入图片描述

复杂度

随机访问迭代器的常量。
否则,线性为n。

迭代器有效性

没有效果。

数据范围

该函数访问迭代器,但它永远不会被解引用(调用不会访问指向的对象)。

异常

如果对复制的迭代器执行的任何算术运算抛出,则抛出,提供与此类操作相同的保证级别。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值