devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

range-based for loop

作者：神奇cpp | 2024-07-07 11:39:35

赞

踩

range-based for loop

1. 基于范围的for循环语法

C++11标准引入了基于范围的for循环特性，该特性隐藏了迭代器
的初始化和更新过程，让程序员只需要关心遍历对象本身，其语法也
比传统for循环简洁很多：

  1. for ( range_declaration : range_expression )
  2. {
  3.     loop_statement;
  4. }

基于范围的for循环不需要初始化语句、条件表达式以及更新表
达式，取而代之的是一个范围声明和一个范围表达式。其中范围声明
是一个变量的声明，其类型是范围表达式中元素的类型或者元素类型
的引用。而范围表达式可以是数组或对象，对象必须满足以下2个条件
中的任意一个。
    1．对象类型定义了begin和end成员函数。

    2. 定义了以对象参数为类型的begin和end普通函数。

  1. #include <iostream>
  2. #include <string>
  3. #include <map>
  4. std::map<int, std::string> index_map{ {1, "hello"}, {2, "world"},
  5. {3, "!"} };
  6. int int_array[] = { 0, 1, 2, 3, 4, 5 };
  7. int main()
  8. {
  9.     for (const auto &e : index_map)
  10.     {
  11.         std::cout << "key=" << e.first << ", value=" << e.second <<
  12.         std::endl;
  13.     }
  14.  
  15.     for (auto e : int_array)
  16.     {
  17.         std::cout << e << std::endl;
  18.     }
  19. }

如果不会在循环过程中修改引用对象，那么推荐在范围声明中加上const限定符以帮助编译器生成更加高效的代码：
 

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. struct X
  5. {
  6.     X() { std::cout << "default ctor" << std::endl; }
  7.     X(const X& other)
  8.     {
  9.         std::cout << "copy ctor" << std::endl;
  10.     }
  11. };
  12.  
  13. int main()
  14. {
  15.     std::vector<X> x(10);
  16.     std::cout << "for (auto n : x)" << std::endl;
  17.     for (auto n : x)
  18.     {
  19.     }
  20.     std::cout << "for (const auto &n : x)" << std::endl;
  21.     for (const auto &n : x)
  22.     {
  23.     }
  24. }

2. 实现自己的range-for

  1. //since C++17, until C++20
  2.  
  3. for (range-declaration : range-expression )
  4. {
  5.     loop-statement
  6. }
  7.  
  8. The above syntax produces code equivalent to the following except for the lifetime expansion of temporaries of range-expression.
  9. {
  10.     auto && __range = range-expression ;  //gcc
  11.     //auto &_range = range-expression;   //clang
  12.     auto __begin = begin-expr ;
  13.     auto __end = end-expr ;
  14.     for ( ; __begin != __end; ++__begin)
  15.     {
  16.           range-declaration = *__begin;
  17.           loop-statement
  18.     }
  19. }

其中operator *用于编译器生成解引用代码，operator !=用于生成循环条件代码，而前缀版本的operator ++用于更新迭代器。

  1. #include <iostream>
  2.  
  3. template<typename T, size_t L>
  4. class Iter
  5. {
  6. public:
  7.     Iter(T* data, size_t idx):data{data}, idx{idx}{}
  8.  
  9.     T& operator*()
  10.     {
  11.         return *(data + idx);
  12.     }
  13.     Iter& operator++()//前缀operator ++
  14.     {
  15.         idx++;
  16.         return *this;
  17.     }
  18.     bool operator != (const Iter& other)
  19.     {
  20.         return other.idx != this->idx;
  21.     }
  22.  
  23. private:
  24.     size_t idx{0};
  25.     T* data;
  26. };
  27.  
  28. template<typename T, size_t L>
  29. class array
  30. {
  31. public:
  32.     using iterator = Iter<T, L>;
  33.     array(std::initializer_list<T> list)
  34.     {
  35.         T * ptr = data;
  36.         for (const auto e : list)
  37.         {
  38.             *ptr = e;
  39.             ptr++;
  40.         }
  41.     }
  42.  
  43.     iterator begin()
  44.     {
  45.         return iterator(data, 0);
  46.     }
  47.     iterator end()
  48.     {
  49.         return iterator(data, L);
  50.     }
  51. private:
  52.     T data[L]{};
  53. };
  54.  
  55. int main(void)
  56. {
  57.     array<int, 4> arr{10,20,30,40};
  58.  
  59.    
  60.     for(auto iter = arr.begin(); iter != arr.end(); ++iter)
  61.     {
  62.         std::cout << *iter << ' ';
  63.     }
  64.  
  65.     for (const auto i : arr)
  66.     {
  67.         std::cout << i << ' ';
  68.     }
  69.     std::cout << std::endl;
  70. }

以上代码，类模板array中实现了iterator begin()和 iterator end()，在迭代器类Iter中实现了operator*(), operator++()[注意这里是前缀operator++]，以及operator!=。

3. 临时范围表达式的陷阱

无论是C++11还是C++17，基于范围的for循环伪代码

//since C++17, until C++20

for (range-declaration : range-expression )

{

    loop-statement

}

The above syntax produces code equivalent to the following except for the lifetime expansion of temporaries of range-expression.

{

    auto && __range = range-expression ;  //gcc版本

    //auto &_range = range-expression;   //clang版本

    auto __begin = begin-expr ;

    auto __end = end-expr ;

    for ( ; __begin != __end; ++__begin)

    {

          range-declaration = *__begin;

          loop-statement

    }

}

对于下面这个例子代码

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. class RangeFor
  5. {
  6. public:
  7.     std::vector<int>& items() { return data; }
  8. private:
  9.     std::vector<int> data{10, 20, 30, 40};
  10. };
  11.  
  12. RangeFor foo()
  13. {
  14.     RangeFor data;
  15.     return data;
  16. }
  17.  
  18. int main(void)
  19. {
  20.     /*
  21. 	step 1: foo() return rvalue;
  22. 	step 2: items() return l_val_ref of rvalue.
  23. 	step 3: __range is an align for l_val_ref.
  24. 	step 4: rvalue(temp value) destory.
  25. 	now __range reference to dangling refenence.
  26. 	*/
  27.     for (const auto& x : foo().items()) //gcc: unexcepted number
  28.                                         //clang: segmentation fault
  29.     {
  30.         std::cout << x << " ";
  31.     }
  32.     return 0;
  33. }

我们从C++ Insights分析看：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. class RangeFor
  5. {
  6.   
  7.   public: 
  8.   inline std::vector<int, std::allocator<int> > & items()
  9.   {
  10.     return this->data;
  11.   }
  12.   
  13.   
  14.   private: 
  15.   std::vector<int, std::allocator<int> > data;
  16.   public: 
  17.   // inline RangeFor(RangeFor &&) noexcept = default;
  18.   // inline ~RangeFor() noexcept = default;
  19.   // inline constexpr RangeFor() noexcept(false) = default;
  20. };
  21.  
  22.  
  23. RangeFor foo()
  24. {
  25.   RangeFor data = RangeFor() /* NRVO variable */;
  26.   return data;
  27. }
  28.  
  29. int main()
  30. {
  31.   {
  32.     std::vector<int, std::allocator<int> > & __range1 = foo().items();
  33.     __gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > > __begin1 = __range1.begin();
  34.     __gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > > __end1 = __range1.end();
  35.     for(; __gnu_cxx::operator!=(__begin1, __end1); __begin1.operator++()) {
  36.       int const & x = __begin1.operator*();
  37.       std::operator<<(std::cout.operator<<(x), " ");
  38.     }
  39.     
  40.   }
  41.   return 0;
  42. }

从clang角度编译器看： std::vector<int, std::allocator<int> > & __range1 = foo().items();

foo()返回临时右值，这个临时右值调用items返回了一个左值引用，然后 __range有引用了这个临时右值接口items返回的左值引用；这个句子结束后，这个临时右值销毁了，这个时候__range其实引用的是一个已经不存在对象的数据。

auto && __range = range-expression ;  

这个是是cpp reference上说的(应该是gcc版本的)。其最终结果也是一样的；我们来分析下上面那段代码：

/*
    step 1: foo() return temp rvalue;
    step 2: items() return l_val_ref of rvalue.
    step 3: __range is an alias for l_val_ref.
    step 4: rvalue(temp value) destory.
    now __range reference to dangling refenence.
*/
    for (const auto& x : foo().items()) //gcc: unexcepted number
                                                         //clang: segmentation fault
    {
        std::cout << x << " ";
    }

可能这里有些人觉得 定义了const auto&x可以捕获临时变量，这个是没错的；对于这个range-for来回代码相当于如下：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. #include <string>
  5.  
  6. class RangeFor
  7. {
  8. public:
  9.     RangeFor() : data("rangeFor") { std::cout << "ctor" << std::endl; }
  10.     std::string& getItems()
  11.     {
  12.          std::cout << "get data" << std::endl;
  13.         return data;
  14.     }
  15.  
  16.     ~RangeFor()
  17.     {
  18.         std::cout << "dtor" << std::endl;
  19.         data = "";
  20.     }
  21.  
  22. private:
  23.     std::string data;
  24. };
  25.  
  26. RangeFor foo()
  27. {
  28.     RangeFor data;
  29.     return data;
  30. }
  31.  
  32.  
  33. int main(void)
  34. {
  35.  
  36.     /*
  37. 	step 1: foo() return rvalue;
  38. 	step 2: items() return l_val_ref of rvalue.
  39. 	step 3: vec is an align for l_val_ref.
  40. 	step 4: rvalue(temp value) destory.
  41. 	*/
  42.     const auto& ret = foo().getItems();
  43.     //note: now vec reference to dangling refenence.
  44.     if (ret.empty())
  45.     {
  46.         std::cout << "empty string" << std::endl;
  47.     }
  48.     else
  49.     {
  50.         std::cout << ret << std::endl;
  51.     }
  52.  
  53.     return 0;
  54. }

const auto& ret = foo(), getItems();这个 const左值引用ret作用于getItems返回的左值引用，这个getItems返回的左值引用(打比喻是毛)的真真数据是foo(）返回的临时变量(打比喻是皮)，这行代码结束后，临时变量被销毁了。getItems返回的左值引用，用一句话总结就是：皮之不存毛将焉附！

4. 基于范围的for 循环的初始化

C++17 引入了if 和switch 控制结构的可选初始化，C++20 现在为基于范围的for 循环引入了这
样一个可选的初始化。

for ( init-statement(optional); range-declaration : range-expression )

{

      loop-statement

}

The above syntax produces code equivalent to the following:

{

       init-statement

      auto && __range = range-expression ;

      auto __begin = begin-expr ;

      auto __end = end-expr ;

      for ( ; __begin != __end; ++__begin)

      {

            range-declaration = *__begin;

            loop-statement

       }

}

我们来看个代码示例：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. class RangeFor
  5. {
  6. public:
  7.     std::vector<int>& items() { return data; }
  8. private:
  9.     std::vector<int> data{10, 20, 30, 40};
  10. };
  11.  
  12. RangeFor foo()
  13. {
  14.     RangeFor data;
  15.     return data;
  16. }
  17.  
  18. int main(void)
  19. {
  20.     //const auto& thing = foo();
  21.     //for (const auto& x : thing.items())// C++17
  22. 	for (auto thing = foo(); const auto& x :thing.items()) //since c++20
  23.     {
  24.         std::cout << x << " ";
  25.     }
  26.     return 0;
  27. }

5. for循环初始化陷阱

控制结构中初始化器通常需要注意的是: 初始化器需要声明一个有名称的变量。否则，初始化
本身就是一个表达式，创建并立即销毁临时对象。

例如，初始化未命名的锁保护是一个逻辑错误，因为当迭代发生时，保护将不再锁定:

  1. for (std::lock_guard{collMx}; const auto& elem : coll)  // runtime ERROR
  2. {
  3.     std::cout << elem: << elem << '\n'; // - no longer locked
  4. }

这里互斥锁需要有变量名：

  1. for (std::lock_guard lg{collMx}; const auto& elem : coll)  //OK
  2. {
  3.     std::cout << elem: << elem << '\n';
  4. }

为了验证匿名命名for初始化对象的生命周期，通过如下示例验证：

  1. #include <iostream>
  2. #include <vector>
  3.  
  4. class Widget
  5. {
  6. public:
  7.     Widget() { std::cout << "ctor" << std::endl; }
  8.     ~Widget() { std::cout << "dtor" << std::endl; }
  9. };
  10.  
  11. Widget foo()
  12. {
  13.     return Widget{};
  14. }
  15.  
  16. int main()
  17. {
  18.     std::vector<int> vi{1,2,3};
  19.  
  20.     for(foo(); const auto i : vi)
  21.     {
  22.         std::cout << i << std::endl;
  23.     }
  24.  
  25.     return 0;
  26. }

 output:

ctor

dtor

1

2

3

从程序输出可以看出，Widget对象析构后，再打印vector中数值的。

其他可以参考：https://www.cnblogs.com/zhao-zongsheng/p/8653108.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/795534
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号