How to create a multidimensional grid structure in C++

Yes, you can certainly do that in C++.

No, there isn't anything built in that will do it for you ready made.

As CPallini indicated, it will require the use of dynamic memory allocation.

There was a somewhat related question recently. Based on that, here is a possible starting point. Beware this is off-the-cuff with no attempt to compile. It contains no error checking. It may even contain glaringly obvious errors.

template<typename T>
class multiDimArray
{
public:
    multiDimArray( const std::vector<size_t> &dimensions ) :
        dimensions_( dimensions ), pContents(NULL);
    {
        size_t size = 1;
        std::vector<size_t>::const_iterator dimIter = dimensions_.begin();
        for ( ; dimIter != dimensions_.end(), ++dimIter )
        {
            size *= *dimIter;
        }
        pContents = new T[ size ];
    }

    ~multiDimArray( )
    {
        delete [] pContents;
    }

    T& operator()( const std::vector<size_t> &indicies )
    {
        std::vector<size_t>::const_iterator indexIter = indicies.begin();
        std::vector<size_t>::const_iterator dimIter = dimensions_.begin();

        // calculate offset into linear array
        size_t offset = 0;
        ++dimIter;  // first dimension isn't used in the calculation
        for ( ; dimIter != dimensions_.end(); ++dimIter, ++indexIter )
        {
            offset += *indexIter;
            offset *= *dimIter;
        }
        offset += *indexIter;  // add last index value

        return *(pContents + offset);
    }

    std::vector<size_t>size_type NumberOfDimensions() const
    {
        return dimensions_.size();
    }

private:
    T *pContents;
    std::vector<size_t> dimensions_;
};

Sounds like Basic Linear Algebra Library[^] fits the bill, supports sparse matrices.

Regards
Espen Harlinn

Thanks a lot for the answers.

Got to know that OpenCV2.0 has a similar implementation named MatND_
http://opencv.willowgarage.com/documentation/cpp/basic_structures.html#id3[^]

You should almost always allocate memory in a single allocation and then subdivide it for the dimension of your problem, using pointers if you want notional convenience... Otherwise, you are likely going to page fault and cache miss like crazy.

BLAS, BLIX++, LAPACK, etc. should all use this methodology.