C++中基于范围的for循环(range-based for loop)

在 C++中，基于范围的for循环（Range-based for loop）是一种简洁的循环结构，它可以遍历迭代器范围内的元素。这种循环结构提供了一种简单的方式来迭代数组、容器、字符串等可迭代对象中的元素。

基于范围的for循环的语法如下：

for (auto& element : collection) {
    // 循环体
}

其中，auto& element 是循环变量，它的类型会自动推导为迭代器指向的元素类型。collection 是可迭代对象，可以是数组、容器、字符串等。

以下是一些使用基于范围的for循环的示例：

1. 遍历数组：

int array[] = {1, 2, 3, 4, 5};
for (int& element : array) {
    std::cout << element << " ";
}

2. 遍历容器：

std::vector<int> vec = {1, 2, 3, 4, 5};
for (int& element : vec) {
    std::cout << element << " ";
}

3. 遍历字符串：

std::string str = "Hello, World!";
for (char& element : str) {
    std::cout << element << " ";
}

需要注意的是，基于范围的for循环不能用于std::map和std::unordered_map等关联容器，因为它们的迭代器并非连续的。但是，可以通过pair<const Key, T>&的方式访问键值对，如下所示：

#include <map>

int main() {
  std::map<int, std::string> m = {{1, "one"}, {2, "two"}};

  for (const auto& p : m) {
    std::cout << "Key: " << p.first << ", Value: " << p.second << '\n';
  }

  return 0;
}

我们实现自己的容器的时候也可以实现使用基于范围的for循环，只要实现begin和end接口，如下是一个自定义容器，并且可以使用for循环遍历：

#include <iostream>

template<typename T>
class MyContainer {
public:
    class const_iterator {
  public:
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = const T*;
    using reference = const T&;
    using iterator_category = std::random_access_iterator_tag;

    const_iterator(const T* ptr): ptr(ptr) {}

    reference operator*() const {
      return *ptr;
    }

    pointer operator->() const {
      return ptr;
    }

    const_iterator& operator++() {
      ++ptr;
      return *this;
    }

    const_iterator operator++(int) {
      const_iterator tmp(*this);
      operator++();
      return tmp;
    }

    const_iterator operator--() {
      --ptr;
      return *this;
    }

    const_iterator operator--(int) {
      const_iterator tmp(*this);
      operator--();
      return tmp;
    }

    const_iterator operator+(size_t n) const {
      return const_iterator(ptr + n);
    }

    const_iterator operator-(size_t n) const {
      return const_iterator(ptr - n);
    }

    const_iterator& operator+=(size_t n) {
      ptr += n;
      return *this;
    }

    const_iterator& operator-=(size_t n) {
      ptr -= n;
      return *this;
    }

    friend bool operator==(const const_iterator& lhs, const const_iterator& rhs) {
      return lhs.ptr == rhs.ptr;
    }

    friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs) {
      return !operator==(lhs, rhs);
    }

  private:
    const T* ptr;
  };

  MyContainer(const T* begin, const T* end) : data(begin), size(end - begin) {}

  const_iterator begin() const { return const_iterator(data); }
  const_iterator end() const { return const_iterator(data + size); }

private:
  const T* data;
  size_t size;
};

int main() {
  int arr[] = {1, 2, 3, 4, 5};
  MyContainer<int> mc(arr, arr + sizeof(arr) / sizeof(int));

  for (auto e : mc) {
    std::cout << e << ' ';
  }

  return 0;
}

在这个示例中，我们定义了一个模板类MyContainer，该类包含一个内部类const_iterator类，用于表示常量迭代器。此外，我们在MyContainer中定义了begin()和end()函数，分别返回一个指向容器首元素和尾元素的迭代器。这样就可以使用基于范围的for循环遍历容器中的元素了。

C++中基于范围的for循环有许多优点，包括：

1. 更简洁的语法：基于范围的for循环使得遍历容器和数组更加直观，无需手动管理迭代器，使得代码更容易阅读和编写。
2. 更高的效率：基于范围的for循环不需要每次都调用begin()和end()函数，而是只在开始和结束时各调用一次，可以减少开销。
3. 更少的bug：基于范围的for循环在安全上优于普通for循环，减少了因忘记更新迭代器引起的bug。

使用基于范围的for循环可以提高代码的可读性和可靠性，是一种值得推荐的编程实践。