Dynamic two dimensional arrays

I have a problem declareing dynamic two dimensional arrays. In addition, I want to initialize all of the array's elements to 0, but I can't seem to do so.

This is basically my code:

Code:

cout << "Enter a number\n";
cin >> n;
int *arr = new int [n][n] = {{0},{0}};

Yet, the compiler generates an error. Whats wrong with the code?
Thank you

umm... yuck.

Code:

#include <iostream>

int main()
{
	/*
	 * These are garbage data to fill the array
	 */
	int a=1;
	int b=2;
	int c=3;
	int d=4;

	/*
	 * This is the size of the array... put this in an I/O
	 * statement/response if you wish
	 */
	int x=2;
	int y=2;
	
	/*
	 * create an array of pointers to pointers, then point each pointer
	 * to a pointer to a new pointer
	 */
	int**arr=new int*[x];
	for(int i=0;i<x;i++)
	{
		arr[i]=new int[y];
	}

	/*
	 * fill the array with the garbage data
	 */
	arr[0][0]=a;
	arr[0][1]=b;
	arr[1][0]=c;
	arr[1][1]=d;

	/*
	 * output the array
	 */
	for(int o=0;o<2;o++)
	{
		for(int i=0;i<2;i++)
		{
			std::cout<<arr[o][i]<<std::endl;
		}
	}

	/*
	 * free up the memory (I was too lazy, but this CAN NOT be skipped)
	 */
	
	return 0;
}

oh yeah... dont' forget to free up the memory too

it's been a while since I've touched code, so forgive any retartedness in there

In C++ you should use a vector or some other container instead of C style arrays. Here's the code for vector that creates the 2-d array and initializes the values to 0:

Code:

std::vector<std::vector<int> > arr(n, std::vector<int>(n));

As you must be knowing that in arrays whether single or multidimensional, elements of arrays are stored in contigious memory location.So for building a dynamic two dimensional array i would suggest u to use a single dimensional dynamic array. Here is a simple program for ur better understanding

Code:

#include<iostream>
using namespace std;

int main()
{
int row,col;
int *arr;
cout<<"\nEnter number of rows";
cin>>row;
cout<<"\nEnter number of columns";
cin>>col;

//create array large enough to hold our 2D array
arr = new int[row*col]

//insert elements
for(int i=0;i<row;i++)
     for(int j=0;j<col;j++)
          cin>>arr[(i*col)+j];

cout<<endl<<endl;

//display elements
for(i=0;i<row;i++)
{
     for(j=0;j<col;j++)
          cout<<arr[(i*col)+j];
     cout<<endl;
}
return 0;
}

note that to see how this single array works as a 2D array i would suggest you to take a paper and pencil and compute the values of arr[(i*col)+j] for different values of i and j. The program is write but still check for syntax errors.

That code isn't actually complete. In fact, what it is missing is one of the biggest reasons you should be using vector instead of dynamic arrays. If you want all the memory to be contiguous you can use the same technique with a vector.

Dynamic, contiguous and with traditional 2-subscript access.

Code:

#include<iostream>
using namespace std;

int main()
{
  int row,col;
  int **arr;

  cout<<"\nEnter number of rows";
  cin>>row;
  cout<<"\nEnter number of columns";
  cin>>col;

  //create array large enough to hold our 2D array
  arr = new int*[row];
  arr[0] = new int [row*col];
  for ( int i = 1 ; i < row ; i++ ) {
    arr[i] = arr[i-1] + col;
  }

  //insert elements
  for(int i=0;i<row;i++)
       for(int j=0;j<col;j++)
            cin>>arr[i][j];

  //display elements
  for(int i=0;i<row;i++)
  {
       for(int j=0;j<col;j++)
            cout<<arr[i][j];
       cout<<endl;
  }
  
  delete [] arr[0];
  delete [] arr;

  cin.ignore(numeric_limits<streamsize>::max(),'\n');
  cin.get();
  return 0;
}

Now use a vector.

Nah, use a Boost.MultiArray.

http://www.boost.org/libs/multi_array/doc/index.html

I say use one of the three: linear array, vector, or one of the boost arrays. But please don't use a 2D array. And please don't use a 2D vector.

Simple solution is to use a linear array and access it in two dimensions. Vectors are a much better choice if you don't know how many elements you need.

>Dynamic, contiguous and with traditional 2-subscript access.
Neat. Makes passing 2-D contiguous arrays as easy as it is in Fortran.

>> But please don't use a 2D array. And please don't use a 2D vector.
Is it really necessary to make this optimization at the expense of the extra complexity? I don't think so.

Jagged arrays have enough complexity of their own, especially vectors of vectors. Like having to resize each vector individually if you want to resize the inner dimension.

» Dynamic, contiguous and with traditional 2-subscript access.

what, no bounds checking?
j/k, I bow to thee.

> what, no bounds checking?
Of course there is, step too far out of bounds and it will segfault

>Of course there is, step too far out of bounds and it will segfault
I think kids these days want a happy fuzzy warning rather than a mean old fashioned segfault.

Or maybe just an out_of_range exception.