Question

I have a series of NX objects (e.g., a static bool array of dimension [NX][N1][N2] in the example below).

I would like to loop over these objects. At each iteration, an object called ‘A’ is to function as a surrogate for the corresponding element ‘B[x]’ in the series.
However, the code inside the loop is legacy code, so we cannot really change how we refer to ‘A’ itself

    const int NX = ...;
    const int N1 = ...;
    const int N2 = ...;
    bool B[NX][N1][N2];

    Code_needed: declare A here (maybe first defining a class template?)

    int main(){

      for(int x = 0; x < NX; ++x){
        Code_needed: make A refer to B[x] here (maybe A = &B[x])
        // In the following, "A[i][j]" should refer to B[x][i][j]...
        A[3][5] = true; // This is legacy code, so we cannot change it
                        // (e.g., cannot add a * in front of A)
      }        
    }

Note that the types of objects on which I want to apply this are heavy, such as arrays of containers, so copying them over inside the loop is not acceptable. Maximizing performance is generally of interest in this application.

Would appreciate the help!!

EDIT: How would the answer be affected, if A were to be a scalar (i.e., it is B[NX] only)?

Answer 1

You can define a reference to a two-dimensional array inside the for loop:

bool (&A)[N1][N2] = B[x];

Now A[i][j] is equivalent to B[x][i][j].

Note that you cannot move the definition of A outside the for loop, because references have to be initialized when they are defined, and they cannot be rebound later.

If you need to define A outside the for loop and reassign inside the for loop, use a pointer instead:

// outside the for loop
bool (*A)[N2];

// inside the for loop
A = B[x];

---

And here is a complete code example which compiles just fine on my compiler:

const int NX = 3;
const int N1 = 5;
const int N2 = 7;

bool B[NX][N1][N2];
bool (*A)[N2];

int main()
{
    for (int x = 0; x < NX; ++x)
    {
        A = B[x];
        A[3][5] = true;
    }
}

---

You can also write an alias class template which overloads the assignment operator appropriately:

template <typename T>
class alias
{
    T* p;

    alias(const alias&);
    alias& operator=(const alias&);

public:

    alias() : p(0) {}

    void rebind(T& x)
    {
        this->p = &x;
    }

    void operator=(const T& x)
    {
        *p = x;
    }

    operator T&()
    {
        return *p;
    }
};

This works with arrays:

bool B[NX][N1][N2];
alias<bool[N1][N2]> A;
// ...
A.rebind(B[x]);
A[3][5] = true;

And plain bools:

bool B[NX];
alias<bool> A;
// ...
A.rebind(B[x]);
A = true;