Thread: Conflict with double pointer

I was working on my tile engine in SDL and came across a problem to when using my double array(int TileMap[10][10]) as a parameter to this function call: void CTile:rawTiles( int** );
I've tried the same thing in a smaller problem to see whats up.

Code:

#include <iostream>

   using std::cout;
   using std::cin;
   using std::endl;

   
   
void SetArray( int** );


int main( void )
{

     int array[2][3]= { {14, 6, 4}, {6, 14, 7} };
     
     
     SetArray( array );
     
     
     cout << array[0][0] << endl;


     cin.get();
     return EXIT_SUCCESS;
}


void SetArray( int** array )
{

     array[0][0]+= 7;
}

How can I make variable 'array' suitable for function void SetArray( int ** )?

A 2D array is not a **

void SetArray( int[][3] );

Ok, but I want to use a similiar function in my Tile Engine. What if the programmer using doesn't want the size of the tile be 3? I would have to declare the function parameters a little differently.

>What if the programmer using doesn't want the size of the tile be 3?
Then you can use a double pointer and require them to allocate memory for whatever size matrix they want.

Then you can use a double pointer and require them to allocate memory for whatever size matrix they want.

Code:

#include <iostream>

   using std::cout;
   using std::cin;
   using std::endl;

   
   
void SetArray( int** );


int main( void )
{

     int **array= new int*[20];
//     int array[2][3]= { {14, 6, 4}, {6, 14, 7} };
     array[0][0]= 7;
     
     
     SetArray( array );
     
     
     cout << array[0][0] << endl;


     delete [] array;

     cin.get();
     return EXIT_SUCCESS;
}


void SetArray( int** array )
{

     array[0][0]+= 7;
}

Still doesn't work.

Originally posted by Leiarchy9
Ok, but I want to use a similiar function in my Tile Engine. What if the programmer using doesn't want the size of the tile be 3? I would have to declare the function parameters a little differently.

Then I'd recommend using a matrix type. You can use boost's multi_array (boost.org), or make your own. To make your own, encapsulate a pointer and dynamically allocate an array of size width*height and then overload operator [] to return the pointer plus the row you are trying to access times the number of colums. This way you have a unified type for an nxm matrix so you can just make your function take a reference to the type and it will account for matrices of any size. I don't recommend using the pointer to pointer solution.

>Still doesn't work.
That's because you aren't doing it right. To create a dynamically allocated matrix you need to do this:

Code:

T **matrix = new T*[m];
for ( int i = 0; i < m; i++ )
  matrix[i] = new T[n];

Then to release the memory, you do the opposite:

Code:

for ( int i = 0; i < m; i++ )
  delete [] matrix[i];
delete [] matrix;

Remember that you are working with a dynamic array of pointers that are each a dynamic array of type T.

>I don't recommend using the pointer to pointer solution.
There are advantages and disadvantages, but the pointer to pointer solution is generally easier to understand. Of course, it's better to avoid such low level manipulations in general unless the performance is required.

Works now.

Code:

#include <iostream>

   using std::cout;
   using std::cin;
   using std::endl;

   
   
void SetArray( int** );


int main( void )
{


     const int m= 20, n= 20;
     int **array= new int*[m];


     for( int i= 0; i < m; i++ )
     {
     
        array[i]= new int[n];
     }
     
     
     array[0][0]= 7;
     SetArray( array );
     
     
     cout << array[0][0] << endl;


     for( int i= 0; i < m; i++ )
     {
     
        delete [] array[i];
     }
     delete [] array;
     

     cin.get();
     return EXIT_SUCCESS;
}


void SetArray( int** array )
{

     array[0][0]+= 7;
}

I have no more problem. How can I initialize each element of 'array' in a easy/shortcut-like fashion? Like so:

Code:

// In your code, it is not possible to initialize 'array' like so:

int array[20][20]= { {1, 1, 1, 1,}....well you get the idea

// I don't want to initialize each element individual like this

array[0][0]= 7;
array[0][1]= 2;
array[0][2]= 8;
.......well, you get the point.

//I assume you have a solution/shortcut for this?

> How can I initialize each element of 'array' in a easy/shortcut-like fashion?
Well if you dynamically allocated it, pretty much one at a time is all you can do.

Unless of course, you also have a static array initialised with all your data and you want to copy it across to your dynamic array.

But then, why exactly are you allocating the array? Is it just to fit in with some provided API?
Because with a bit of effort, you can turn a 2D array into an array of pointers, without all this memory allocation....

>//I assume you have a solution/shortcut for this?
No, you have to do it manually with either a series of assignment statements, or a loop. Usually you will see something like this:

Code:

for ( int i = 0; i < m; i++ )
  for ( int j = 0; j < n; j++ )
    matrix[i][j] = default_value;

But for dynamic initialization, you are on your own.

Why isn't this working?

Code:

#include <iostream>
#include <cstdio>
#include <cstdlib>

   using std::cout;
   using std::cin;
   using std::endl;
   
   int Map[2][4]= { {1, 1, 1, 1},
                    {1, 1, 1, 1} };

   template <typename N>
   void AllocateMemory( N**, int, int );

   template <typename N>
   void DeallocateMemory( N**, int );



int main( void )
{

     int **array;
     
     
     AllocateMemory<int>( array, 2, 4 );
     

     for( int j= 0; j < 2; j++ )
     {
     
        for( int k= 0; k < 4; k++ )
        {
        
           array[j][k]= Map[j][k];
        }
    }


     DeallocateMemory<int>( array, 2 );

     cin.get();
     return EXIT_SUCCESS;
}


template <typename N>
void AllocateMemory( N** var, int groups, int elements )
{

     var= new N*[ groups ];
     
     
     for( int i= 0; i < groups; i++ )
     {
     
        var[i]= new N[ elements ];
     }
     
}


template <typename N>
void DeallocateMemory( N** var, int groups )
{

     for( int i= 0; i < groups; i++ )
     {

        delete [] var[i];
     }

     delete [] var;
}

> void AllocateMemory( N**, int, int );
The N** needs to be a reference if you want the value to be changed in the caller.
As it stands, its just a local variable whose value is lost when the function returns.

I see that you in fact do have a static array containing initialised data, and you're copying it to dynamically allocated memory.

Code:

   int Map[2][4]= { {1, 1, 1, 1},
                    {1, 1, 1, 1} };
   int *array[2] = { Map[0], Map[1] };  // or use a loop

   // more stuff
   SetArray( array );

The N** needs to be a reference if you want the value to be changed in the caller.

Does the parameter/local variable('N** var') have to be referenced? How do I reference a double pointer?

Code:

template <typename N>
void AllocateMemory( N**& var, int groups, int elements )
{

     var= new N*[ groups ];


     for( int i= 0; i < groups; i++ )
     {

        var[i]= new N[ elements ];
     }

}