How do you use a void pointer to generate 2D dynamic Array?

Question

Does anyone know how to use a void pointer to generate a 2D array rather than an int pointer?

For integer pointer, I do as follow:

int **m;

m = new int* [row];     
for(int i=0; i< row; i++)     
        m[i] = new int[col];

for (int i = 0; i < row; i++)
       for (int j = 0; j < col; j++)
             m[i][j] = rand () % 10;

What if the pointer type is void***m?

How can I define the storage like int? eg.(m = new int* [row];)

Thanks for your help.

---

Please allow me to specify my question clearer, I'm given these:

class Matrix
{
   public:
           Matrix();
           Matrix(int,int);

           void printMatrix();

   private:
           int row;
           int col;
           void***m;
           void initMatrix();      // Initialize the storage for row and column
           void generateMatrix (); // construct a 2D array
}

Answer 1

You can't. You need to know the size of the elements if you're responsible for creating the array. With a void *, you don't know anything about what it points to. You'd have to have the caller supply you with a size argument or something.

Edit: Perhaps the third * is the key: Is he asking you to create a two-dimensional array of void *, perhaps? After all, void * is a type just as much as int is. Where you say new int[col] you should be able to say new void * [col]. You didn't show enough of your code for me to really get how you were doing it, but if it was working with int**, then it should work with void*** very nearly by just doing a search-and-replace on int => void *.

Answer 2

With the snippet you posted in a comment to another answer, it's a bit easier to help you.

class Matrix {
    private:
    int row;
    int col;
    void** m;
}

Code to initialize the rows of the table could be something like this:

m = malloc(sizeof(int*) * row);

Hopefully you can use this to solve the rest of your homework, yourself.

Answer 3

Your question is probably best answered by an explanation of what void means.

void basically denotes the absence of a type. As a consequence of this, you cannot tell the compiler to create an object of type void, e.g. with the following statements:

• new void
• new void[...]

The meaning of these expressions is roughly the following: "create something", or "create an array of somethings" respectively. This is clearly not a precise enough statement for the compiler.

void* (pointer to void) however is permitted because pointers are fundamentally always the same thing to the compiler: a memory address of another object. You can think of a pointer as some kind of arrow pointing to something. If you're working with a pointer, the compiler sees that arrow, and not the actual thing it points at. Therefore the compiler doesn't care that the "target type" is void.

The consequence of this, however, is that you cannot dereference a void* (pointer to void), because then you make the compiler effectively look at the pointed-to thing, which would be a void value, which doesn't make any sense to the compiler.

Summary:

1) You cannot create an array of type void, as in new void[...].

2) You can create a pointer to void (void*), or even a pointer to a pointer to void* (void**).

3) You cannot dereference a void* pointer (but you can dereference a void** pointer).

Conclusions:

4) You can create an int* array and let a void* refer to it:

int** m;
// ... (create the dangling array as in the OP's code and let m point to it)
void* v = (void*)m;

(See the comments below on why a void* is used here instead of void**!)

5) Because of statement #3, all you can reasonably do with such a pointer is pass it around, but you cannot work on the array's actual content. In order to do this, you need to type-cast it back to the correct data type:

int **m2 = (int**)v;

Answer 4

Since every pointer type is implicitly convertible into a void*, you do as you did with the int* and assign that to the void*.

Where is the problem? Am I missing something?

Answer 5

a void* is a pointer to some unspecified type. Of course, it's a happy accident that in the common case a pointer is exactly the same size as an int, so there really isn't anything preventing you from writing:

int **m;

m = new int* [row];     
for(int i=0; i< row; i++)     
    m[i] = new int[col];

for (int i = 0; i < row; i++)
   for (int j = 0; j < col; j++)
         m[i][j] = rand () % 10;

void ***v = (void ***)m; // v is a 2-d array of void* pointers now!

Of course, I'm not sure why you'd want a void*** array for a Matrix class. perhaps a custom numeric datatype?

Answer 6

The closest answer I can think of is the following one. You can create a 2D array as a vector of ints, and then transferr it as void *. This is very similar to how it is stored in memory.

const unsigned int MaxRow = 10;
const unsigned int MaxColumn = 10;

void print(void * m)
{
    int * matrix = (int *) m;

    for(unsigned int i = 0; i < MaxRow; ++i) {
        for(unsigned int j = 0; j < MaxColumn; ++j) {
            std::printf( "%03d ", matrix[ ( i * MaxColumn ) + j ] );
        }

        std::printf( "\n" );
    }
}

int main()
{
    // Create
    int * matrix = new int[ MaxRow * MaxColumn ];

    for(unsigned int i = 0; i < MaxRow; ++i) {
        for(unsigned int j = 0; j < MaxColumn; ++j) {
            matrix[ ( i * MaxColumn ) + j ] = ( i * MaxColumn ) + j;
        }
    }

    // Show
    print( matrix );

    delete[] matrix;
    return 0;
}

Answer 7

Let me specify my question clearer!

I'm given

class Matrix
{
   public:
           Matrix();
           Matrix(int,int);

           void printMatrix();

   private:
           int row;
           int col;
           void***m;
           void initMatrix();      // Initialize the storage for row and column
           void generateMatrix(); // construct a 2D array
}