to define a multi-dimension array whose dimension is a dynamical parameter - c++

Question

I want to make a function to define an external multi-dimension array, like this:
'''
const int SIZE=5; // SIZE will be dynamical
int n1=2,n2=3,n3=4,n4=5,n5=6;
int n_loop(SIZE)={n1,n2,n3,n4,n5};
void Mul_array(int n_loop(SIZE))
{
//here will define a multi-array
// I don't know how to do this part
external mul_array[n_loop[0]]....[n_loop[SIZE]]
}
So I can define a multi-dimension array, by only setting n_loop[SIZE], which will be convenient for me.

Answer 1

You cannot get an array of arbitrary length or dimensions. All must be known at compile time.
However, you can get a 1 dimensional dynamic array large enough to contain the multidimensional array and perform the math by hand to compute the mapping from N dimensions to 1 dimension.
The following has been written for easy reading and error checking, not speed.
#include <vector>
#include <iostream>
#include <cstddef>
#include <stdexcept>
// stupid helper function to get the poroduct of all the values in a vector
size_t multiply(const std::vector<size_t> & dims)
{
size_t product = 1;
for (size_t dim:dims)
{
product *= dim;
}
return product;
}
// spun off into own function for easier reading
// computes the offset for one dimension based on previous dimensions
size_t compute_dimension(size_t offset,
size_t dim,
size_t loc)
{
if (loc < dim)
{
offset *= dim; // push existing offset into correct place for higher
// dimension
offset += loc; // add on where to look in this dimension
return offset;
}
throw std::out_of_range("useful error message goes here");
}
// map a multi dimensional corrodinate into a single dimension
size_t compute_offset(const std::vector<size_t> & dims,
const std::initializer_list<size_t> & loc)
{
if (dims.size() != loc.size())
{
throw std::runtime_error("Dimension mis-match");
}
auto locit = loc.begin();
auto dimit = dims.begin();
size_t offset = 0;
while (locit < loc.end()) // compute the 1D offset dimension by dimension
{
offset = compute_dimension(offset, *dimit++, *locit++);
}
return offset;
}
class sdm_1 // Super Dimensional Matrix rev 1
{
public:
sdm_1(const std::initializer_list<size_t> & dims) :
mDims(dims), // Store dimensions
mData(multiply(mDims)) // allocate storage for all dimensions
{
}
// takes dimensions as a brace enclosed initializer list
double& operator()(const std::initializer_list<size_t> & loc)
{
return mData[compute_offset(mDims, loc)];
}
double operator()(const std::initializer_list<size_t> & loc) const
{
return mData[compute_offset(mDims, loc)];
}
// silly little helper to display the array so we can see what's going on
friend std::ostream & operator<<(std::ostream & out,
const sdm_1 & sdm)
{
for (const auto & val: sdm.mData)
{
out << val << ' ';
}
return out;
}
private:
std::vector<size_t> mDims;
std::vector<double> mData;
};
int main()
{
sdm_1 test{2,3,4}; // make a 3D array
std:: cout << test << std::endl; // print it
for (size_t one = 0; one < 2; one++)
{
for (size_t two = 0; two < 3; two++)
{
for (size_t three = 0; three < 4; three++)
{
test({one,two,three}) = 1; // set a value in the array
std:: cout << test << std::endl;
test({one,two,three}) = 0; // and clear it so we get a nice
// number marching across the grid
}
}
}
}
Note that it's very rare to require an unknown number of dimensions. There will be some groovy variadic template voodoo that will allow the number of dimensions to be set at compile time. This will almost certainly be a faster solution.