Printable View
Hello. I recently started to learn c++ again and started from the beginning. I've been trying to create a 2 dimentional array that would allocate memory during the runtime and came up with something like this:
int **array;
array = new int* [6];
I'm not even sure what I exactly created, but seems to work as a 2 dimentional array.
I tried to send this array as an argument to a void function i created but the compiller gives me an error. What are the right methods?
Beware, you're creating an array of 6 int*, not a two-dimensional array.
Remember, a two-dimensional array is name[dim1][dim2].
As to how to create a two-dimensional array on the heap, I'm at a loss. I can't find the syntax for it.
You create a 2-dimensional array using the knowledge you already have about creating a 1-dimensional array. As you've started doing, you create a 1D array of 1D arrays.
First you make a variable to hole the array of arrays: done.
Next you create the array to hold the other arrays and assign that to the variable: done.
Next you create all those other arrays and assign them to the positions in the array: NOT done.
It helps a lot if you typedef the kind of pointer that goes in the first array.
So you're just missing the loop that creates all those actual data arrays. You already have the array to hold them all. Think you can finish it now?
btw this kind of array even allows for the secondary arrays to be of differing lengths.
Now the other way to create a 2-D array of m*n items is to simply create an array that is m*n big. Then you step across in multiples of m to go down by one n. That's how bitmaps do it too. This method is usually preferred because it is more efficient. However, unlike the other method, this way you can't use the array[m][n] syntax. Instead it's better to make a function to to the lookups, and then you get the even better syntax of: lookup(m, n).
If you're using a pointer to the array, it is very possible to do [x][y], since the compiler just calculates the offset.
From the above info, I'd suggest the easiest way to create a 2D array is just to create a single dimension array with all elements (x * y) and use a pointer to that array, so you can use 2D syntax.
No, you can't do that. Each [] operator is a dereference. It only works for the first method I described precisely because there are 2 dereferences involved. In the second case there is only 1 dereference, so it cannot work.Quote:
Originally Posted by Elysia
Don't feel you're obliged to give advice when you don't know the subject matter. As you've already stated you don't know about this stuff, which is perfectly fine. Feel free to ask questions of course. The more you learn, the more you realise you don't know, as they say.
Actually here's one for ya: Did you know that if you have a pointer 'a' and an integer 'i', that i[a] is the same as a[i]?!
I'm working from my knowledge of pointers... OK, so it's not possible. I didn't know that, I never actually tried. But a[10] works, nevertheless, and which just compiles to a + sizeof(a) * 10. So why wouldn't 2D work?
Unless, of course, there is a way to cast that pointer to a type that is a 2D-pointer.
I disgress. Sometimes others can fill out what someone else cannot. We aren't perfect.
Otherwise, it's possible to doOrCode:*(p + sizeof(p) * x * y) = y
Code:int& array(int* p, int x, int y)
{
return *(p + sizeof(p) * x * y);
}
int main()
{
int* p = new int[100];
array(p, 10, 2) = 50;
}
I think 2D won't work because the compiler cannot know how large the dimensions are. If you allocate an array of 20 ints, how is the compiler supposed to know whether you are using it as array[2][10] or array[4][5] (or other combinations)?
Another easy way to create 2D arrays is to use a std::vector of std::vectors:
This line would take care of all the complicated memory allocations in the original approach. And the vector would deallocate all memory automatically when it goes out of scope.Code:std::vector<std::vector<int> > vec2d(dim1, std::vector<int>(dim2));
It looks ugly but typedefs can improve that. And you don't need to create a "rectangular" array when you start but you can add subarrays of arbitrary length at any time.
No, it compiles to *(a + sizeof(a) * 10). Thus, a[10][4] compiles to *(*(a + sizeof(a) * 10) + sizeof(*a) * 4), and if a is an int*, the second dereference is invalid.Quote:
But a[10] works, nevertheless, and which just compiles to a + sizeof(a) * 10.
Just use Boost.MultiArray.
Boost is a huge POS, honestly I dont know why people recommend it to beginners (or anyone else), as it will only confuse them and keep them from learning the fundamentals. The guy is obviously trying to learn how to use pointers, creating the actual array is secondary to that goal. Boost is irrelevant here, since it wont teach him how to use pointers.
1) Anyone calling Boost a POS is earning a lot of negative points in my book.
2) The thread is called "2 dimentional array", and spelling aside, this looks like a request for a 2-dimensional array to me.
3) I consider multi-dimensional arrays a really bad way of learning pointers.
If you know the dementions of the array at compile time you can do The following. Array 2dRef will work just like a 2d array. Unfortunately, this has limited usefulness since the prime reason for using a heap array in the first place is to have the size be runtime dependent.Quote:
Originally Posted by iMalc
You can also make m runtime dependant:(let n=4 in this example)Code:int *array1d=new int[m*n];
int (*array2dptr)[m][n] = (int (*)[m][n])(array1d);
int (&array2dRef)[m][n]=*array2dptr;
//usage example
array2dRef[7][2]=0;
...
delete &array2dRef;
Code:char *array1d=new char[m*4];
char (*array2d)[4] = (char(*)[4])(array1d);
//usage example
array2d[7][2]='0';
...
delete array2d;