I'm using c++ and I want to use two dimensional dynamic array. I tried this:
#include<iostream.h>
using namespace std;
void main(){
int const w=2;
int size;
cout<<"enter number of vertex:\n";
cin>>size;
int a[size][w];
for(int i=0; i<size; i++)
for(int j=0; j<w; j++){
cin>>a[i][j];
}
}
but not worded. and I tried this:
int *a = new a[size][w];
instead of
int a[size][w];
but not worked!
could you help me plz.
thanks a lot.
The correct approach here would be to encapsulate some of the standard containers, that will manage memory for you, inside a class that provides a good interface. The common approach there would be an overload of operator() taking two arguments that determine the row and column in the matrix.
That aside, what you are trying to create manually is an array of dynamic size of arrays of constant size 2. With the aid of typedef you can write that in a simple to understand manner:
const int w = 2;
typedef int array2int[w];
int size = some_dynamic_value();
array2int *p = new array2int[size];
Without the typedef, the syntax is a bit more convoluted, but doable:
int (*p)[w] = new int [size][w];
In both cases you would release memory with the same simple statement:
delete [] p;
The difference with the approaches doing double pointers (int **) is that the memory layout of the array is really that of an array of two dimensions, rather than a jump table into multiple separately allocated unidimensional arrays, providing better locality of data. The number of allocations is lower: one allocation vs. size + 1 allocations, reducing the memory fragmentation. It also reduces the potential from memory leaks (a single pointer is allocated, either you leak everything or you don't leak at all).
array2int objects, each element in the array is a statically sized (in this case size==2) array. The complexity is in attempting to parse the awkward syntax that is required to do it without a typedef, but that is just learning how to read declarations: p is a pointer to an (or array of) w-dimensional array of int. If you feel that something needs further explanation, please do ask. I do agree that this is not beginner-friendly (I already mentioned that I would not use this approach)
For a dynamic sized array you must dynamically allocate it. Instead of
int *a = new a[size][w];
Use
int** a = new int*[size];
for(int i = 0; i < size; i++)
a[i] = new int[w];
new[] too many times. Only one of the dimensions is dynamic, so a single new [] (with the appropriate type) suffices.new [] code is fine.size + 1 allocations, where only one allocation is needed. This has different impacts: higher cost of allocating/deallocating, memory fragmentation, less locality of data.int* a = new int[size * w];? Your way allocates it all as a single, contiguous block; @dornhege's example isn't guaranteed to use contiguous memory, but it should still compile and run just fine. I agree, it may not be the most efficient, but it still works, which is my point. Plus, no pointer arithmetic, which is scary to newbies.int (*a)[w] = new int[size][w];. Single allocation, memory footprint and efficiency similar to that intended in the original non-compliant code, same syntax to access the elements (no need for arithmetic). Although in production code I would write a thin wrapper around std::vector<int> with operator()(int r, int c) doing integral arithmetic (no pointer arithmetic) to index a r * width + c.OP is saying he wants to create a 2 dimensional array where one dimension is already known and constant and the other dimension is dynamic.. Not sure if I got it right but here goes:
int main() {
const int w = 2;
int size = 10;
int* arr[w];
for (int i = 0; i < w; ++i)
arr[i] = new int[size];
//do whatever with arr..
//std::cout<<arr[0][0];
for (int i = 0; i < w; ++i)
for (int j = 0; j < size; ++j)
std::cout<<arr[i][j];
for (int i = 0; i < w; ++i)
delete[] arr[i];
return 0;
}
You can not do that in c++, please read about dynamic memory allocation
the code below should work
int* twoDimentionalArray = new [size*w]
twoDimentionalArray + 1 will point to the second item of the array but not to the second row as expected.