C++11 推荐只要可以，尽量用const类型的迭代器

最新推荐文章于 2025-05-02 19:59:58 发布
最新推荐文章于 2025-05-02 19:59:58 发布
阅读量1.5k 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Effectivve Modern Cpp 文章标签： c++ 容器 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/rubikchen/article/details/122052246
本文探讨了C++中迭代器的最佳使用方式，特别是在C++11及以后版本中使用const迭代器的优点。通过示例代码展示了如何在不同C++标准下正确地使用迭代器进行搜索和插入操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. 主要内容

    • 核心内容

      • 迭代时,只要不修改,都建议用const类型的迭代器.

      • C++98的迭代器简单难用,C++11则加强了,希望广泛使用.

    • 好处

      • 减小被修改的风险.

    • 迭代器

      • ++,--这种,各类容器的操作抽象化.

      • 比如数组的迭代器++,--是偏移,链表的则是切换节点,树的++,--则是递归遍历.

      • 其他的容器就更加复杂了.

    • 迭代器的好处

      • 将复杂的操作统一且抽象化了.

      • 隐藏细节,使用简单.

  2. const迭代器

    • 什么时候推荐

      • 迭代的时候,没有修改元素的需求,就建议用const迭代器.

    • C++98

      • 对const类型的迭代器支持不好,特别是STL容器.

    • C++98缺陷

      • 创建复杂,使用麻烦,功能有限.

    • C++98的需求

      • 从一个std::vector<int>中搜索1983,然后在其后面插入1998.
      • 没有找到则插在末尾.

    • 实现

      #include <iostream>
#include <algorithm>
#include <vector>

int main() {
   std::vector<int> years {1983};
   auto iter = std::find(years.begin(),years.end(),1983);
   years.insert(iter + 1,1998);
   for(auto i = years.begin(); i != years.end();i++) {
       std::cout << *i << std::endl;
   }
}

      • 很简单.

      • 问题:不修改值却用了非const的迭代器,有被修改的风险.

      • 不能有一丝丝的风险.不能让安全隐患存在.

    • C++11

      #include <iostream>
#include <algorithm>
#include <vector>

int main() {
   std::vector<int> years {1983};
   typedef std::vector<int>::const_iterator IterType;
   IterType iter = std::find(static_cast<IterType>(years.begin()),
                         static_cast<IterType>(years.end()),
                         1983);

   years.insert(static_cast<IterType>(iter),1998);
   for(auto i = years.begin(); i != years.end();i++) {
       std::cout << *i << std::endl;
   }
}

      • 可以正常编译执行.

    • c++98版本

      #include <iostream>
#include <algorithm>
#include <vector>

int main() {
   std::vector<int> years;
   years.push_back(1983);
   typedef std::vector<int>::const_iterator IterType;
   IterType iter = std::find(static_cast<IterType>(years.begin()),
                         static_cast<IterType>(years.end()),
                         1983);

   years.insert(static_cast<IterType>(iter),1998);
   for(auto i = years.begin(); i != years.end();i++) {
       std::cout << *i << std::endl;
   }
}

      • c++98编译报错.

      • g++ test.cpp -std=c++98.

      • typedef是c++98版本的别名.

      • 输出

      [root@localhost test]# g++ test.cpp -std=c++98
test.cpp: In function ‘int main()’:
test.cpp:13:50: error: no matching function for call to ‘std::vector<int>::insert(__gnu_cxx::__normal_iterator<const int*, std::vector<int> >, int)’
    years.insert(static_cast<IterType>(iter),1998);
                                                 ^
test.cpp:13:50: note: candidates are:
In file included from /usr/include/c++/4.8.2/vector:69:0,
                from test.cpp:3:
/usr/include/c++/4.8.2/bits/vector.tcc:107:5: note: std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::insert(std::vector<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<int*, std::vector<int> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = int*; std::vector<_Tp, _Alloc>::value_type = int]
    vector<_Tp, _Alloc>::
    ^
/usr/include/c++/4.8.2/bits/vector.tcc:107:5: note:   no known conversion for argument 1 from ‘__gnu_cxx::__normal_iterator<const int*, std::vector<int> >’ to ‘std::vector<int>::iterator {aka __gnu_cxx::__normal_iterator<int*, std::vector<int> >}’
In file included from /usr/include/c++/4.8.2/vector:64:0,
                from test.cpp:3:
/usr/include/c++/4.8.2/bits/stl_vector.h:1023:7: note: void std::vector<_Tp, _Alloc>::insert(std::vector<_Tp, _Alloc>::iterator, std::vector<_Tp, _Alloc>::size_type, const value_type&) [with _Tp = int; _Alloc = std::allocator<int>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<int*, std::vector<int> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = int*; std::vector<_Tp, _Alloc>::size_type = long unsigned int; std::vector<_Tp, _Alloc>::value_type = int]
      insert(iterator __position, size_type __n, const value_type& __x)
      ^
/usr/include/c++/4.8.2/bits/stl_vector.h:1023:7: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/4.8.2/bits/stl_vector.h:1050:9: note: template<class _InputIterator> void std::vector<_Tp, _Alloc>::insert(std::vector<_Tp, _Alloc>::iterator, _InputIterator, _InputIterator) [with _InputIterator = _InputIterator; _Tp = int; _Alloc = std::allocator<int>]
        insert(iterator __position, _InputIterator __first,
        ^
/usr/include/c++/4.8.2/bits/stl_vector.h:1050:9: note:   template argument deduction/substitution failed:
test.cpp:13:50: note:   cannot convert ‘iter’ (type ‘__gnu_cxx::__normal_iterator<const int*, std::vector<int> >’) to type ‘std::vector<int>::iterator {aka __gnu_cxx::__normal_iterator<int*, std::vector<int> >}’
    years.insert(static_cast<IterType>(iter),1998);
                                                 ^
test.cpp:14:14: error: ‘i’ does not name a type
    for(auto i = years.begin(); i != years.end();i++) {
             ^
test.cpp:14:33: error: expected ‘;’ before ‘i’
    for(auto i = years.begin(); i != years.end();i++) {
                                ^
test.cpp:14:33: error: ‘i’ was not declared in this scope

      • 错误信息,insert不能是const类型.

      • 核心是对迭代器的支持不够,c++98则进行了加强.c++14也进行了加强.

      • 所以后面就推荐用迭代器,且const类型的迭代器。

    • 核心观念

      • 推荐用const是因为C++11对const进行了加强.

      • c++98对相关支持比较少.

      • 推荐const可以减少错误率.

  3. c++11

    • 改进

      • 获取const迭代器更加容易.

      • 容器有cbegin,cend可以获取const迭代器. 不论是否是const类型容器.

      • STL容器支持用const迭代器进行指定,增删的位置.

      • 即上面的易错版C++98代码简单修改就可以在c++11标准下使用。

    • C++11的const版本

      #include <iostream>
#include <algorithm>
#include <vector>

int main() {
  std::vector<int> years {1983};
  auto iter = std::find(years.cbegin(),years.cend(),1983);
  years.insert(iter + 1,1998);
  for(auto i = years.cbegin(); i != years.cend();i++) {
      std::cout << *i << std::endl;
  }
}

      • 可以正常执行.

  4. 需求

    • 更加通用的函数

      • 抽象成模板函数,如果使用成员的cbegin和cend就有点问题.毕竟有的没有实现.

      • 没有实现的可以通过特例化实现.

    • 改成通用型

      #include <iostream>
#include <algorithm>
#include <vector>

template<typename Container,typename T = typename Container::value_type>
void insert(Container && years,T val) {
   auto iter = std::find(std::cbegin(years),std::cend(years),val);
   years.insert(iter,1998);
   for(auto i = years.cbegin(); i != years.cend();i++) {
       std::cout << *i << std::endl;
   }
}

int main() {
   std::vector<int> t{1983};
   insert(t,1);
}

      • c++14可以编译通过,但是c++11不能.

      • 因为std::cbegin是c++14之后补齐的.而且c++11的insert不支持const.

      • cbegin, cend, rbegin, rend, crbegin, and crend都是。

    • c++11

      #include <iostream>
#include <algorithm>
#include <vector>

template<typename T>
auto my_cbegin(const T& t) 
   -> decltype(std::begin(t)) {
       return std::begin(t);
}
template<typename T>
auto my_cend(const T& t) 
   -> decltype(std::end(t)) {
       return std::end(t);
}


template<typename Container,typename T = typename Container::value_type>
void insert(Container && years,T val) {
   auto iter = std::find(years.begin(),years.end(),val);
   years.insert(iter,1998);
   for(auto i = my_cbegin(years); i != my_cend(years);i++) {
       std::cout << *i << std::endl;
   }
}

int main() {
   std::vector<int> t{1983};
   insert(t,1);
}

      • 可执行.

    • c++14版本

      #include <iostream>
#include <algorithm>
#include <vector>

template<typename T>
auto my_cbegin(const T& t) 
   -> decltype(std::begin(t)) {
       return std::begin(t);
}
template<typename T>
auto my_cend(const T& t) 
   -> decltype(std::end(t)) {
       return std::end(t);
}


template<typename Container,typename T = typename Container::value_type>
void insert(Container && years,T val) {
   auto iter = std::find(my_cbegin(years),my_cend(years),val);
   years.insert(iter,1998);
   for(auto i = my_cbegin(years); i != my_cend(years);i++) {
       std::cout << *i << std::endl;
   }
}

int main() {
   std::vector<int> t{1983};
   insert(t,1);
}

      • 可行,因为c++14的insert支持const和非const.

    • 三方版

      #include <iostream>
#include <algorithm>
#include <vector>



class myType {
   int a[10]{};
public:
   auto begin() const {
       return a;
   }
   auto end() const {
       return a+10;
   }
   auto insert(const int*,int b) {
       a[0]+=b;
       return a;
   }
};


template<typename T>
auto my_cbegin(const T& t) 
   -> decltype(std::begin(t)) {
       return std::begin(t);
}
template<typename T>
auto my_cend(const T& t) 
   -> decltype(std::end(t)) {
       return std::end(t);
}

template<typename Container,typename T = typename Container::value_type>
void insert(Container && years,T val) {
   auto iter = std::find(my_cbegin(years),my_cend(years),val);
   years.insert(iter,1998);
   for(auto i = my_cbegin(years); i != my_cend(years);i++) {
       std::cout << *i << std::endl;
   }
}

int main() {
   // std::vector<int> t{1983};
   // insert(t,1);
   myType t;
   insert(t,1);
}

  5. 总结

    • c++11建议不修改都用const迭代器.

    • c++14的插入删除支持const和非const两种.

    • c++98的时候条件不好,支持不好,c++11也不太好,不过勉强够用.c++14较为完善.

    • 总是建议使用const迭代器.降低错误风险.

【c++教程】为迭代器使用const限定
程程之光
11-21 1040
对STL中的迭代器使用const限定的方法
C++ const用法 尽可能使用const
weixin_34151004的博客
04-15 258
　　C++ const 允许指定一个语义约束，编译器会强制实施这个约束，允许程序员告诉编译器某值是保持不变的。如果在编程中确实有某个值保持不变，就应该明确使用const，这样可以获得编译器的帮助。 1.const 修饰成员变量  1 #include&lt;iostream&gt; 2 using namespace std; 3 int main(){ 4 int ...
C++迭代器
最新发布
qq_73333296的博客
05-02 794
rbegin和rend的使用与上述的迭代器使用是相似的，相反的是，rbegin指向的容器最后一个元素，而rend指向的是迭代器最开始元素的前一个位置。我们在对容器插入一个数据后，就必须跳出循环，使用新的迭代器。当我们运行如下代码时，我们会发现容器中首元素的值与目标元素的值并不一样，原因是我们的操作只是将元素的值复制给了容器，容器中的内容与我们的目标元素并不是一个内容。那么同样，end返回的仍然是是一个迭代器类型的变量，只不过，end所指向并不是容器中最后一个元素，而是该元素的下一个位置即一个不存在的元素。
const 迭代器和const 迭代型
爱飞的蒲公英
07-19 4234
正如大多C++编程人员所知的，每个标准容器类都提供四种迭代器类型。对于container而言，iterator的作用相当于T*，而const_iterator则相当于const T*（与T const* 意思一样）。增加一个iterator或者const_iterator可以在一
9 个开始使用 C++11 的理由
weixin_34403693的博客
05-14 169
如果你的代码工作正常并且表现良好，你可能会想知道为什么还要使用C++ 11。当然了，使用用最新的技术感觉很好，但是事实上它是否值得呢？  在我看来，答案毫无疑问是肯定的。我在下面给出了9个理由，它们分为两类：性能优势和开发效率。 获得性能优势 理由1：move语义(move semantics)。简单的说，它是优化复制的一种方式。有时候复制很显然是浪费的。如果你从一个临时的string对象复...
C++ - const 与 迭代器(iterator) 使用 详解
weixin_33857679的博客
11-13 408
const 与 迭代器(iterator) 使用 详解 本文地址: http://blog.youkuaiyun.com/caroline_wendy/article/details/16030561 迭代器(iterator) 是一种指针类型, 也分const指针本身(地址) 和 const指针所指的值, 两种情况; 但是写法和const内置指针有所不同...
C++迭代器介绍（iterator、const_iterator、reverse_interator、const_reverse_interator）
12-20
使用迭代器时，通常需要声明迭代器类型，如`string::iterator`，然后通过`begin()`和`end()`获取容器的首尾迭代器，用`for`循环遍历元素。解引用迭代器（`*i`）可以获得元素的引用，而`->`操作符可以访问元素的成员...
【C++第十课 - List】List的使用、list底层实现、list的const迭代器实现、反向迭代器
m0_60803455的博客
06-19 1272
list不能用算法库里面的sort，算法库里面的sort是快排（需要连续的空间，原地排序，不稳地排序，O(n2)），list自带的sort是归并(稳定排序，O(nlogn))（2）访问权限：struct默认的成员变量访问控制权限是public，而class默认的成员变量访问权限则为private。把一个链表的值转移到另一个链表，是把一个链接里面的节点直接拿走。是内置类型，是要改变的是Node*的指向，不能改变指针的运算符。默认的析构函数对类里面的成员是不做处理的。
C++标准模板（STL）- 迭代器库 - 迭代器操作 - 返回指向容器或数组结尾的迭代器
qq_40788199的博客
07-10 759
返回指向给定容器 c 或数组 array 结尾（即最末元素的后一元素）的迭代器。这些模板依赖于拥有合理实现的 C::end() 。
C++中const迭代器 和 const_iterator的区别
热门推荐
11-03 1万+
话说这两个区别非常大，但是不太好理解啊，而且感觉解释也是各种绕口。说一下我自己的理解吧。     const迭代器，顾名思义，就是不能改变的迭代器，是常量，其性质是由const决定的。比如说我们这样定义一个const迭代器。vector vv(10,9); const vector :: iterator iter = vv.begin();则，当程序中出现这样的语句时是错误的 ++iter;
尽可能使用const
没有最好，只有更好！
03-16 943
尽可能使用constconst定义语义约束：制定一个不被改动的对象，编译器会强制实施这项约束。只要某值保持不变时事实，就应该确实说出来，这样编译器可以确保这项约束不违反。const多才多艺：可以用在classes外部修饰global或namespace作用域中的常量，或修饰文件、函数、或区块作用于中被声明为static的对象。它可以用来修饰classes内部的static或non-static成员变
尽量使用const
android菜鸟的专栏
07-12 202
[align=center][size=large][b]尽可能的使用const[/b][/size][/align] const:使用const的好处是指定一种语义上的约束----某种对象不能被修改，而作用于变量上，则告诉编辑器和其他程序员：此变量为常量，不可被修改。 [b]一、const作用在变量上：[/b] 看下面的例子： [code="c++"] char *p ...
尽量多使用const
扬风踏浪
08-02 756
C++中const非常多才多艺。被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。 一。const与指针、引用：         pointer-to-nonconst可以初始化或赋值给pointer-to-const，反之不可以，只有一个例外
const_iterator,const 迭代器
bailu6536的博客
03-29 206
const 迭代器:是迭代器产量，该迭代器的值不能被修改，且需要初始化，初始化之后不能指向其他元素。 const_iterator:当我们对const_iterator类型解引用时，返回一个const值，所以只能读，不能写。它是一种迭代器类型。 e.g: 　　for ( vector<int>::const_iterator iter = ivec....
《Effective C++》读后总结（三）尽量使用const
douya2016的博客
10-06 277
将某些东西声明为const可以帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象，函数参数，函数返回类型，成员函数本体。 class Rational {.....} const Rational operator* (const Rational &lhs, const Rational rhs);使用const的好处在于可以防止以下情况if(a * b = c) //比
C++中const迭代器和const_iterator的区别
ZXR_LJ的博客
03-18 1042
const迭代器，就是不能改变的迭代器，是常量，类似指针常量，不能改变指向的地址，但是可以改变指向地址的内容。 例如： vector&lt;int&gt; vv(10,9); const vector&lt;int&gt; :: iterator iter = vv.begin(); 如果出现： ++iter;//报错 就会报错，因为iter...
const迭代器与模板构造函数
weixin_74074953的博客
11-02 211
隐式类型转化和模板构造函数
c++之迭代器
华数云图小分队的博客
01-05 1733
需要注意的是，迭代器不仅可以用于遍历容器元素，还可以用于对容器进行各种操作，如插入、删除和排序等。例如，在vector容器中，我们可以使用insert函数在任意位置插入新元素，使用erase函数删除指定位置的元素，使用sort函数对元素进行排序等。通过迭代器，我们可以在不知道容器内部数据结构的情况下访问和修改容器中的数据，从而提高代码的可读性和可维护性。通过迭代器，可以以一种统一的方式来遍历容器，并且可以在遍历过程中对容器进行各种操作，如查找、插入、删除和排序等。的结构体，用于表示学生的姓名和年龄属性。
C++中const迭代器和const iterator的区别
2301_79326510的博客
09-20 180
const iterator是指迭代器本身是常量的，也就是说，一旦我们将一个迭代器声明为const iterator，就不能再将其指向其他元素。注意到在使用const迭代器时，我们无法修改迭代器指向的元素，而在使用const iterator时，我们可以修改元素的值，但不能修改迭代器本身。具体来说，当我们使用const迭代器时，通过解引用操作符(*)获取的是一个常量引用，这意味着我们只能读取元素的值，而不能修改它。const迭代器限制了对元素的修改，而const iterator限制了迭代器本身的修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值