基于多维数组的范围

例如，有多种方法可以打印和操作多维数组的值。

int arr[2][3] = { { 2, 3, 4 }, { 5, 6, 7} };  

第一种方法，

size_t count = 0 ; 
for( auto &row : arr)
    for(auto &col : row)
         col = count ++; 

在第一个 for 循环中，我们指的是两个数组。然后在第二个数组中，我们分别引用了这些子数组的 3 个元素。我们还将计数分配给 col。因此，它会迭代到子数组的下一个元素。

第二种方法，

for( auto &row : arr)
     for( auto col : row)
          cout << col << endl; 

我们在第一个循环中引用，因为我们希望避免数组到指针的转换。

如果这样做(错误情况：第一个for循环不是引用(，

for( auto row : arr)          // program won't compile
     for( auto col : row)

在这里，我们在行中有 int *。当我们到达第二个 for 循环时。因为行现在是 int * 而不是列表，所以程序不会编译。你必须创建一个列表，然后只有我们可以将其传递给ranged for loop并使用它来迭代该列表。

vector<int> list = { *(row+0) , *(row+1) , *(row+ 2) } ;

现在我们可以使用该列表进行迭代

for ( ----- : list)

for ( auto &a : array )
{
   for ( int &x : a ) x = fill_value;
}

编辑：您可以尝试以下方法

const size_t n = 2;
const size_t m = 3;
int a[n][m] = { { 1, 2, 3 }, { 4, 5, 6 } };
for ( auto &x : reinterpret_cast<int ( & )[n * m]>( a ) )  x = 10;
for ( auto x : reinterpret_cast<int ( & )[n * m]>( a ) )  std::cout << x << ' ';
std::cout << std::endl;;

输出为

10 10 10 10 10 10 

这种方法的优点是，您可以重新解释任何多维数组，而不仅仅是二维数组。例如

int a[n][m][k] = { /* some initializers */ };
for ( auto x : reinterpret_cast<int ( & )[sizeof( a ) / sizeof( ***a )]>( a ) )
{
    std::cout << x << ' ';
}
std::cout << std::endl;;

下面是一些将填充任意数组(静态已知大小(的代码：

#include <algorithm>
#include <iterator>
#include <type_traits>
template <typename T>
void fill_all(T & a, typename std::remove_all_extents<T>::type v);
template <typename T>
void fill_all_impl(T & a, typename std::remove_all_extents<T>::type v, std::false_type);
template <typename T>
void fill_all_impl(T & a, typename std::remove_all_extents<T>::type v, std::true_type)
{
  for (auto & x : a)
    fill_all(x, v);
}
template <typename T>
void fill_all_impl(T & a, typename std::remove_all_extents<T>::type v, std::false_type)
{
  std::fill(std::begin(a), std::end(a), v);
}
template <typename T>
void fill_all(T & a, typename std::remove_all_extents<T>::type v)
{
  fill_all_impl(a, v, std::is_array<typename std::remove_extent<T>::type>());
}

用法示例：

int a[3][4][2];
fill_all(a, 10);

结合弗拉德和普拉托里安的部分答案，我决定使用：

template<typename T, size_t N, size_t M>
auto flatten(T (&a)[M][N]) -> T (&)[M*N] { return reinterpret_cast<T (&)[M*N]>(a); }
for( int16_t& r : flatten(array2) ) {
    r = fill_value;
}

@Ben Voigt 答案的更一般的变体(可以应用于 n 维数组(：

template
    <
        typename Array,
        typename Element = typename std::remove_all_extents<Array>::type,
        std::size_t Size = sizeof(Array) / sizeof(Element),
        typename FlattenedArray = Element (&)[Size]
    >
constexpr FlattenedArray Flatten(Array &a)
{
    return reinterpret_cast<FlattenedArray>(a);
}
template
    <
        typename Array,
        typename Element = typename std::remove_all_extents<Array>::type
    >
void FillArray(Array& a, Element v)
{
    for (Element& e : Flatten(a))
    {
        e = v;
    }
}
// ...
int a[2][3][5];
int d = 42;
FillArray(a, d);

活生生的例子。

比 SB@Kerrek 的解决方案更简单(可能效率较低(：

#include <type_traits>
template <typename Type>
void FillArray(Type& e, Type v)
{
    e = v;
}
template <typename Type, std::size_t N>
void FillArray(Type (&a)[N], typename std::remove_all_extents<Type>::type v)
{
    for (Type& e : a)
    {
        FillArray(e, v);
    }
}

使用示例：

int a[2][3][5];
FillArray(a, 42);

一个更通用的解决方案，允许将函子应用于多维数组的所有元素：

template <typename Type, typename Functor>
void ForEachElement(Type& e, Functor f)
{
    f(e);
}
template <typename Type, std::size_t N, typename Functor>
void ForEachElement(Type (&a)[N], Functor f)
{
    for (Type& e : a)
    {
        ForEachElement(e, f);
    }
}

使用示例：

int a[2][3][5];
ForEachElement(a, [](int& e){e = 42;});

#include <iostream>
using namespace std;
int main() {
    int arr[3][4];
    
    // Initialising the 2D array
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 4; j++){
            arr[i][j] = i * j + 10;
        }
    }
    
    // Accessing elements of 2D array using range based for loop
    for(auto &row: arr){
        for(auto &col: row){
            cout << col << " ";
        }
        cout << endl;
    }
    
    return 0;
}