Thread: Multi-Demensional Arrays on Heap

> salem, are you saying i can skip that other code and just use yours & it will work?
Yes, try it now and see for yourself

>You're right there!

No, he/she's crazy. 20 pointers each pointing to 20 rooms equals 400 rooms.

>> No, he/she's crazy. 20 pointers each pointing to 20 rooms equals 400 rooms.

NO. There are only 20 rooms.

Do some research.

>NO. There are only 20 rooms.

Ok, lets go through it -

room = new Room*[20];//Set first dimensions

Creates an array of 20 pointers to Rooms. Agreed?

>for(x = 0;x < 20;x++)
room[x] = new Room[20]; //Set second dimensions<

Allocates 20 Rooms per iteration of the loop and assigns in each iteration the memory to one of the previously allocated 20 pointers to room.

My maths may be a bit flaky but I'm sure 20x20=400.

I refuse to get all fussy here, because this aint helping GrNxxDaY.

Here's one way to explain it:

Q. What do you need to create an object on the heap?
A. A pointer.

In the previous code we had 20 pointers, so we created 20 Room objects on the heap.

There aren't 400 rooms, only 20.
Think about it.

>because this aint helping GrNxxDaY

You're spot on there, guvnor. I think Salems done that anyway.

What does this code do -

int* ptr = new int[20];

?

How many ints are pointed to by ptr? 20, do you agree? Now suppose you have an array of 20 ptrs (instead of the solitary one we have here). You can perform the above allocation for each of these 20 ptrs. 20x20 !=20. Phew.

You can perform the above allocation for each of these 20 ptrs. 20x20 !=20. Phew.

NO, you can't. You're not getting it.

This declaration:

int *ptr = new int[20];

creates an array of 20 ints, the same way that

char *ptr = new char[50];

creates an array of 50 chars.

Now let's say we had this:

char **list = new char*[20];

This allocates memory for 20 char*'s.

for(int i = 0;i<20;i++)
list[i] = new char[50];

create 50 char arrays.

NOW, there aren't 100 char arrays, but only 20, each having 50 elements. This is a 2D array, but there are only 20 arrays in list.

The same way that in the previous example, there were only 20 Room objects, although it was a 2D array.

>there aren't 100 char arrays, but only 20, each having 50 elements

Assuming your code was correct this would be a two dimensional array of 1000 chars. In the same way the Fordy's original example was a two dimensional array of 400 rooms.

I suggest you both go and read the link posted by Salem near the start of the thread.

Here GrNxxDaY:

Code:

#include <iostream.h>

class Room{ //Your class.....whatever.....
public:
	int member;
};

#define FIRST	2
#define SECOND	20

Room*** function()
{
	Room*** room;
	room = new Room**[FIRST];
	
	for(int x = 0;x < FIRST;x++)
		room[x] = new Room*[SECOND];
	
	for(int i=0;i<FIRST;i++)
		for(x = 0;x < SECOND;x++)
			room[i][x] = new Room;

	return room;
}

As for this :

>>Assuming your code was correct this would be a two dimensional array of 1000 chars.

So how many arrays does list have? 20
Each having 50 elements.

>>I suggest you both go and read the link posted by Salem near the start of the thread.

>>In the same way the Fordy's original example was a two dimensional array of 400 rooms.

I think you should realize that i am right. Have you tried it?
You'll notice that you'll only have 20 Room objects.

flip, i forgot main()

Code:

int main(void)
{
	Room ***room;  //pointer to a 2D array
	
	room = function();
	//now you have 40 rooms to play with

	room[0][1]->member = 5; 

	cout << room[0][1]->member;
	
	/* Dont forget to clean up!*/
	for(int i=0; i< FIRST;i++)
		for(int x = 0;x < SECOND;x++)
			delete [] room[i][x];
		
	delete [] room[0];
	delete [] room[1];

	delete room;
		
	return 0;
}

>Have you tried it?

I've written code that relies on it.

I dunno, maybe you're confused by for loops. How many ints have we got here -

//dynamically allocated an array of pointers
//this isn't necessary if one of your dimensions
//is a compile time constant
int** array = new int*[20];

//allocate an array of 20
//integers (yes, 20 and they're integers you know)
//to each of the previously allocated pointers

array[0]=new int[20];
array[1]=new int[20];
array[2]=new int[20];
array[3]=new int[20];
array[4]=new int[20];
array[5]=new int[20];
array[6]=new int[20];
array[7]=new int[20];
array[8]=new int[20];
array[9]=new int[20];
array[10]=new int[20];
array[11]=new int[20];
array[12]=new int[20];
array[13]=new int[20];
array[14]=new int[20];
array[15]=new int[20];
array[16]=new int[20];
array[17]=new int[20];
array[18]=new int[20];
array[19]=new int[20];

There's quite a few 20s there.

Doh, my bad!

I didn't see this : new Room[20];

I assumed it was : new Room;

I'm sorry Enmeduranki, but i was following my code instead of Fordy's.