使用基于范围的C 11的正确方法是什么？

Question

对于，使用C 11基于范围的的正确方法是什么？

应该使用什么语法<代码>用于（自动元素：容器），或用于（自动




Answer 1

正确的方法总是

for(auto&& elem : container)

这将保证保留所有语义。

Answer 2

对于（自动元素：容器）或（自动）没有正确的使用方法

让我详细说明一下。我们去散散步吧。

for (auto elem : container) ...

这是语法糖：

for(auto it = container.begin(); it != container.end(); ++it) {

    // Observe that this is a copy by value.
    auto elem = *it;

}

如果您的容器中包含复制成本较低的元素，则可以使用此选项。

for (auto& elem : container) ...

这是语法糖：

for(auto it = container.begin(); it != container.end(); ++it) {

    // Now you're directly modifying the elements
    // because elem is an lvalue reference
    auto& elem = *it;

}

例如，当您想直接写入容器中的元素时，请使用此选项。

for (const auto& elem : container) ...

这是语法糖：

for(auto it = container.begin(); it != container.end(); ++it) {

    // You just want to read stuff, no modification
    const auto& elem = *it;

}

正如评论所说，只是为了阅读。就是这样，只要使用得当，一切都是“正确的”。

Answer 3

匿名用户

>

要观察元素，请使用以下语法：

for (const auto& elem : container)    // capture by const reference

>

如果对象复制起来很便宜（如ints、Doubles等），可以使用稍微简化的形式：

  for (auto elem : container)    // capture by value

要在位修改图元，请使用：

for (auto& elem : container)    // capture by (non-const) reference

>

如果容器使用“代理迭代器”（如std：：vector

  for (auto&& elem : container)    // capture by &&

当然，如果需要在循环体中创建元素的本地副本，那么按值捕获（auto-elem:container）是一个不错的选择。

让我们开始区分观察容器中的元素和就地修改它们。

让我们考虑一个简单的例子：

vector<int> v = {1, 3, 5, 7, 9};

for (auto x : v)
    cout << x << ' ';

上述代码打印向量中的元素（ints）：

1 3 5 7 9

现在考虑另一种情况，在这种情况下，向量元素不仅是简单的整数，而且是更复杂类的实例，具有自定义的复制构造函数等。

// A sample test class, with custom copy semantics.
class X
{
public:
    X() 
        : m_data(0) 
    {}
    
    X(int data)
        : m_data(data)
    {}
    
    ~X() 
    {}
    
    X(const X& other) 
        : m_data(other.m_data)
    { cout << "X copy ctor.\n"; }
    
    X& operator=(const X& other)
    {
        m_data = other.m_data;       
        cout << "X copy assign.\n";
        return *this;
    }
       
    int Get() const
    {
        return m_data;
    }
    
private:
    int m_data;
};

ostream& operator<<(ostream& os, const X& x)
{
    os << x.Get();
    return os;
}

如果我们对这个新类使用上面的for（autox： v）{...}语法：

vector<X> v = {1, 3, 5, 7, 9};

cout << "\nElements:\n";
for (auto x : v)
{
    cout << x << ' ';
}

输出类似于：

[... copy constructor calls for vector<X> initialization ...]

Elements:
X copy ctor.
1 X copy ctor.
3 X copy ctor.
5 X copy ctor.
7 X copy ctor.
9

由于可以从输出中读取，因此在基于范围的循环迭代期间进行复制构造函数调用。
这是因为我们按值从容器中捕获元素（autox部分在for（autox： v）中）。

这是低效的代码，例如，如果这些元素是std：：string的实例，则可以进行堆内存分配，并需要昂贵的内存管理器访问等。如果我们只想观察容器中的元素，这是无用的。

因此，可以使用更好的语法：通过const引用捕获，即const auto

vector<X> v = {1, 3, 5, 7, 9};

cout << "\nElements:\n";
for (const auto& x : v)
{ 
    cout << x << ' ';
}

现在输出为：

 [... copy constructor calls for vector<X> initialization ...]

Elements:
1 3 5 7 9

没有任何虚假（并且可能昂贵）的复制构造函数调用。

因此，当观察容器中的元素（即只读访问）时，以下语法对于简单的廉价复制类型很好，如int、double等：

for (auto elem : container) 

否则，在一般情况下，通过const引用捕获更好，以避免无用的（并且可能昂贵的）复制构造函数调用：

for (const auto& elem : container) 

如果我们想使用基于范围的for修改容器中的元素，则上述for（auto elem:container）和for（const auto

事实上，在前一种情况下，elem存储原始元素的副本，因此对其所做的修改将丢失，而不会持久存储在容器中，例如：

vector<int> v = {1, 3, 5, 7, 9};
for (auto x : v)  // <-- capture by value (copy)
    x *= 10;      // <-- a local temporary copy ("x") is modified,
                  //     *not* the original vector element.

for (auto x : v)
    cout << x << ' ';

输出只是初始序列：

1 3 5 7 9

相反，尝试使用<代码>for（const auto

g输出类似这样的错误消息：

TestRangeFor.cpp:138:11: error: assignment of read-only reference 'x'
          x *= 10;
            ^

在这种情况下，正确的方法是通过非const引用捕获：

vector<int> v = {1, 3, 5, 7, 9};
for (auto& x : v)
    x *= 10;

for (auto x : v)
    cout << x << ' ';

输出如下（如预期）：

10 30 50 70 90

此<代码>用于（自动

vector<string> v = {"Bob", "Jeff", "Connie"};

// Modify elements in place: use "auto &"
for (auto& x : v)
    x = "Hi " + x + "!";
    
// Output elements (*observing* --> use "const auto&")
for (const auto& x : v)
    cout << x << ' ';
    

输出为：

Hi Bob! Hi Jeff! Hi Connie!

假设我们有一个向量

vector<bool> v = {true, false, false, true};
for (auto& x : v)
    x = !x;

以上代码编译失败。

g输出类似以下内容的错误消息：

TestRangeFor.cpp:168:20: error: invalid initialization of non-const reference of
 type 'std::_Bit_reference&' from an rvalue of type 'std::_Bit_iterator::referen
ce {aka std::_Bit_reference}'
     for (auto& x : v)
                    ^

问题是std::向量模板专门用于bool，其实现打包bools以优化空间（每个布尔值存储在一个位中，一个字节中有八个“布尔”位）。

因此（因为不可能返回对单个位的引用），向量

修改向量的元素

for (auto&& x : v)
    x = !x;

以下代码工作正常：

vector<bool> v = {true, false, false, true};

// Invert boolean status
for (auto&& x : v)  // <-- note use of "auto&&" for proxy iterators
    x = !x;

// Print new element values
cout << boolalpha;        
for (const auto& x : v)
    cout << x << ' ';
    

和输出：

false true true false

请注意（自动）的

（作为附注，前面提到的的“观察”语法用于（const Auto

上述讨论可总结为以下指南：

>

要观察元素，请使用以下语法：

for (const auto& elem : container)    // capture by const reference

>

如果对象复制起来很便宜（如ints、Doubles等），可以使用稍微简化的形式：

  for (auto elem : container)    // capture by value

要在位修改图元，请使用：

for (auto& elem : container)    // capture by (non-const) reference

>

如果容器使用“代理迭代器”（如std：：vector

  for (auto&& elem : container)    // capture by &&

当然，如果需要在循环体中创建元素的本地副本，那么按值捕获（auto-elem:container）是一个不错的选择。

在泛型代码中，由于我们无法假设泛型类型的复制成本很低，因此在观察模式下，始终使用（const auto

此外，在修改模式下，如果我们希望泛型代码在代理迭代器的情况下也能工作，那么最好的选择是（auto

因此，在通用代码中，可以提供以下准则：

>

for (const auto& elem : container)

要在位修改图元，请使用：

for (auto&& elem : container)