range-based for on multi-dimensional array

Question

My embedded system got a C++11-capable version of g++, so I've been cleaning up code from

for( uint16_t* p = array; p < (&array)[1]; ++p ) {
    *p = fill_value;
}

to

for( uint16_t& r : array ) {
    r = fill_value;
}

which is much more readable.

Is there a range-based for loop which operates over all elements of array2[m][n]?

The old version is

for( int16_t* p = array2[0]; p < (&array2)[1][0]; ++p ) {
    *p = fill_value;
}

and I don't want nested loops, unless it's guaranteed the compiler will flatten them.

(FWIW, the compiler is the GNU 4.7.4 Linaro g++ ARM cross-compiler that ships with TI Code Composer Studio 6.0.0)

@πάνταῥεῖ: Using std::array, I could write for( p = array2.front().begin(); p < array2.back().end(); ++p ) which is a big improvement, but still not as nice as a range-based for — Ben Voigt
– Ben Voigt, Commented Jun 19, 2014 at 22:30
"and I don't want nested loops, unless it's guaranteed the compiler will flatten them." Mind if I ask why? Isn't is sufficient that the compiler will flatten them if that's beneficial? — David Schwartz
– David Schwartz, Commented Jun 19, 2014 at 22:34
If you can use Boost, and can replace those arrays with Boost.MultiArray, I'm pretty sure there's a way to get a one-dimensional view of a multi-dimensional array. You can then iterator over the view using a range-based for. — Praetorian
– Praetorian, Commented Jun 19, 2014 at 22:35
@David: It's an embedded system. I try not to do things that gratuitously increase instruction count. — Ben Voigt
– Ben Voigt, Commented Jun 19, 2014 at 22:36
@BenVoigt Then, presumably, so does your compiler. Otherwise, you've chosen a poor compiler. You should code what you mean first, and worry about these details only if you have evidence the compiler got something wrong. — David Schwartz
– David Schwartz, Commented Jun 19, 2014 at 22:42

abhimanyuaryan · Accepted Answer · 2015-02-02 01:33:15Z

19

As an example, there are various ways to print and manipulate value of a multidimensional array.

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

First Method,

size_t count = 0 ; 

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

Here in the first for loop we are referring to the two array. Then in the second array we have reference to the 3 elements of those subarrays separately. And we are also assigning count to col. So, it iterates over to the next element of the subarray.

Second Method,

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

We take reference here in the first loop because we want to avoid array to pointer conversion.

If this is done( error case: first for loop is not a reference ),

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

Here, we have int * in row. By the time we reach the second for loop. Because row is now int * and not a list the program will not compile. You have to create a list then only we can pass that it to ranged for loop and use it for iterating over that list.

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

Now we can use the list for iteration

for ( ----- : list)

answered Feb 2, 2015 at 1:33

abhimanyuaryan

4,0746 gold badges46 silver badges85 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Mah35h Over a year ago

what will be the actual datatype of row and col? ( declared as auto )

rosshjb Over a year ago

@Mah35h The outer loop iterates arr(int[2][3]). Each inner array(int[3]) will be assigned to row by copy. By copy means that int[3] is converted to a pointer to its first element. So row is int*. With just auto, we can't determine the col's type because it doesn't compile.

Vlad from Moscow · Accepted Answer · 2014-06-20 11:46:52Z

8

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

EDIT: You can try the following

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;;

The output is

10 10 10 10 10 10

The advantage of this approach is that you can reinterpret any multidimensional array not only a two-dimensional array. For example

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;;

edited Jun 20, 2014 at 11:46

answered Jun 19, 2014 at 22:32

Vlad from Moscow

313k27 gold badges204 silver badges358 bronze badges

11 Comments

Praetorian Over a year ago

I don't want nested loops, unless it's guaranteed the compiler will flatten them. - got any guarantees for the compiler he's using?

Ben Voigt Over a year ago

I don't like repeating the size, but it looks like this method is at least safe, see stackoverflow.com/a/15284276/103167

Vlad from Moscow Over a year ago

@Ben Voigt There is an advantage of this method compared with a template class that you can reinterpret an array of ant dimensions.:)

Ben Voigt Over a year ago

@Vlad: I agree that's a nice feature. Oh, n * m can be replaced by sizeof a / sizeof **a

Vlad from Moscow Over a year ago

@Ben Voigt Or for example sizeof a / sizeof ***a and so on.

|

Kerrek SB · Accepted Answer · 2014-06-19 23:10:09Z

Here's some code that will fill an arbitrary array (of statically known size):

#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>());
}

Example usage:

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

Ben Voigt · Accepted Answer · 2014-06-20 21:03:32Z

1

Combining parts of Vlad's and Praetorian's answers, I decided to use:

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;
}

answered Jun 20, 2014 at 21:03

Ben Voigt

286k45 gold badges444 silver badges764 bronze badges

3 Comments

Constructor Over a year ago

A bit more general variant of this (for n-dimensional arrays).

Constructor Over a year ago

Could I add this general variant (see the reference at the previous comment) as an answer?

Ben Voigt Over a year ago

@Constructor: Of course you can add that as an answer.

Community · Accepted Answer · 2017-05-23 12:10:16Z

1

A bit more general variant of @Ben Voigt's answer (which can be applied to n-dimensional arrays):

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);

Live example.

edited May 23, 2017 at 12:10

CommunityBot

11 silver badge

answered Jun 22, 2014 at 9:08

Constructor

7,5512 gold badges29 silver badges74 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 12:10:16Z

A bit simpler (and possibly less effective) solution than @Kerrek SB's one:

#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);
    }
}

Example of use:

int a[2][3][5];

FillArray(a, 42);

A little more general solution which allows to apply a functor to all elements of a multidimensional array:

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);
    }
}

Example of use:

int a[2][3][5];

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

Aaqib Javaid · Accepted Answer · 2023-01-23 06:51:26Z

-1

#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;
}

answered Jan 23, 2023 at 6:51

Aaqib Javaid

4634 silver badges6 bronze badges

1 Comment

Ben Voigt Over a year ago

Said in the question "I don't want nested loops".

Collectives™ on Stack Overflow

range-based for on multi-dimensional array

7 Answers 7

2 Comments

11 Comments

Comments

3 Comments

Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

2 Comments

11 Comments

Comments

3 Comments

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related