Rewrite This Malloc Using New For 2D Array

Question

After some trial and error I found a way to malloc a 2D array so it is contiguous in memory, equivalent to the non-dynamic case.

int numRows =2;
int numCols = 4;
int (*p)[numCols];
p    = (int (*)[numCols]) malloc(sizeof(int)*numRows*numCols);

So p is now basically the same as if I had done int p[2][4] - except it's on the heap instead of the stack.

2 Questions:

1. Do I just need to call free(p) to free the memory? No looping?
2. How would I convert this to using new, instead of malloc?

I tried

p = new (int (*)[4])[2];

But that gave the error:

error: cannot convert int (**)[4] to int (*)[4] in assignment

Answer 1

You can't do that in C++. Your malloc() code is perfectly valid C, but not valid C++. And it won't work with new.

C++ requires array types to have constant size, C allows arrays types of dynamic size. There is only an exception for 1D arrays, which may be allocated with dynamic size in C++, but that's it. In a 2D array, the second size must be known at compile time.

This is the one point at which C is much more powerful than C++.

---

It takes a bit to convince g++ to follow the standard in this regard, but compiling this little program

#include <stdlib.h>

int main(int argc, char** args) {
    int (*foo)[argc];
}

with g++ -pedantic -std=c++11 foo.cpp dutifully produces the error message:

foo.cpp: In function ‘int main(int, char**)’:
foo.cpp:4:17: warning: ISO C++ forbids variable length array ‘foo’ [-Wvla]

Answer 2

1) Yes, you could just call free()

But attention, you are doing pointer aliasing (2 pointers to different types, int and int[] with the same address), which can cause subtle optimisation bugs. And in C++ it's a very bad practice to use malloc(), and numcols should be const.

2) The way you can do this in C++ would be to use [<array>][2] if the size to be known at compile time:

     array<array<int, 4>,2> a;

The more flexible alternative is to use vectors which allow for dynamic size and resizing:

     vector <vector <int>> b(2, vector<int>(4)); 

3) With new you could also do :

    p = new (int[2][4]);

The first dimension could also be variable, but the second has to be a constant. But I'd encourage you to use one of the standard containter alternative.

Answer 3

Here's a class template that uses one std::vector to hold a contiguous buffer, and size-aware proxy objects to access array elements dimension-by-dimension:

template<typename T>
class TwoDArray {
private:
    std::size_t n_rows;
    std::size_t n_cols;
    std::vector<T> buf;

public:
    class OneDArrayProxy {
    private:
        T *rowptr;
        std::size_t colsize;

    public:
        OneDArrayProxy(const T *rp, std::size_t cs) : rowptr(const_cast<T *>(rp)), colsize(cs) {}
        T const &operator[](std::size_t index) const {
            return rowptr[index];
        }

        T &operator[](std::size_t index) {
            return rowptr[index];
        }

        std::size_t size() const { return colsize; }
    };

    TwoDArray(std::size_t rows, std::size_t cols) : n_rows(rows), n_cols(cols), buf(rows * cols) {}
    TwoDArray() : TwoDArray(0, 0) {}

    OneDArrayProxy operator[](std::size_t index) const {
        return OneDArrayProxy(&buf[index * n_cols], n_cols);
    }

    std::size_t rows() const { return n_rows; }
    std::size_t columns() const { return n_cols; }
};

Usage example:

int main()
{
    TwoDArray<int> arr(9, 5);
    for (std::size_t i = 0; i < arr.rows(); i++) {
        for (std::size_t j = 0; j < arr.columns(); j++) {
            arr[i][j] = i * 10 + j;
        }
    }

    for (std::size_t i = 0; i < arr.rows(); i++) {
        // you can use the array element's 'size()' function instead of 'columns()'
        for (std::size_t j = 0; j < arr[i].size(); j++) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }
}