arraysc++memory-managementmultidimensional-array
When I read some values from the user and I need to create an array of the specific size I do it somehow like this:
#include <iostream>
using namespace std;
unsigned* numbers;
int main()
{
int a;
cin >> a;
numbers = new unsigned[a];
}
How can I do it with a 2d array(sized a*b read from the user)?
If your row length is a compile time constant, C++11 allows
auto arr2d = new int [nrows][CONSTANT];
See this answer. Compilers like gcc that allow variable-length arrays as an extension to C++ can use new as shown here to get fully runtime-variable array dimension functionality like C99 allows, but portable ISO C++ is limited to only the first dimension being variable.
Another efficient option is to do the 2d indexing manually into a big 1d array, as another answer shows, allowing the same compiler optimizations as a real 2D array (e.g. proving or checking that arrays don't alias each other / overlap).
Otherwise, you can use an array of pointers to arrays to allow 2D syntax like contiguous 2D arrays, even though it's not an efficient single large allocation. You can initialize it using a loop, like this:
int** a = new int*[rowCount];
for(int i = 0; i < rowCount; ++i)
a[i] = new int[colCount];
The above, for colCount= 5 and rowCount = 4, would produce the following:
Don't forget to delete each row separately with a loop, before deleting the array of pointers. Example in another answer.
By the letter of the law, here's how to do it:
// Create 2D array of pointers:
int*** array2d = new (int**)[rows];
for (int i = 0; i < rows; ++i) {
array2d[i] = new (int*)[cols];
}
// Null out the pointers contained in the array:
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
array2d[i][j] = NULL;
}
}
Be careful to delete the contained pointers, the row arrays, and the column array all separately and in the correct order.
However, more frequently in C++ you'd create a class that internally managed a 1D array of pointers and overload the function call operator to provide 2D indexing. That way you're really have a contiguous array of pointers, rather than an array of arrays of pointers.
Best Answer
If a and b are the number of rows and number of columns, respectively, you may allocate the array like this:
To access the element at row
iand columnj, do this:However, note that in reality you're almost certainly better off using
std::vectorfor whatever you're trying to do, but you may not have learned about that yet :)