www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - declaration/initialization of multidimensional arrays

reply "Tyro[17]" <nospam home.com> writes:
What is the proper way to declare a multidimensional array?
In Java, I can do:

	double[][] a = new double[M][N];

D does not allow this because of two reasons.

1) M & N are variables and cannot be read at compile time even if they 
are explicitly initialized.

	Error: variable N cannot be read at compile time (sawalks)

2) double[17][17] is a static array and cannot be used to initialize a 
dynamic array.

	Error: cannot implicitly convert expression (new double[17LU][](17LU)) 
of type double[17LU][] to double[][] (sawalks)

Assigning a length and then trying to access the values obviously will 
not work:

	double[][] a;
	a.length = M * N;
	a[i][j] = 17; // core.exception.RangeError sawalks(19): Range violation

So what is the proper way to do this in D?

Thanks
Nov 18 2012
next sibling parent reply "bearophile" <bearophileHUGS lycos.com> writes:
Tyro[17]:

 What is the proper way to declare a multidimensional array?
 In Java, I can do:

 	double[][] a = new double[M][N];

In D (hopefully I have not swapped the to sizes, it's a too much common mistake in my D code): auto a = new double[][](M, N); Bye, bearophile
Nov 18 2012
next sibling parent "Tyro[17]" <nospam home.com> writes:
On 11/18/12 7:53 PM, bearophile wrote:
 Tyro[17]:

 What is the proper way to declare a multidimensional array?
 In Java, I can do:

     double[][] a = new double[M][N];

In D (hopefully I have not swapped the to sizes, it's a too much common mistake in my D code): auto a = new double[][](M, N); Bye, bearophile

Thanks... This solved my issue. Much appreciated.
Nov 18 2012
prev sibling parent "Tyro[17]" <nospam home.com> writes:
On 11/18/12 8:14 PM, bearophile wrote:
 Why is no one complaining about this array allocation syntax?

A syntax I like is: new double[][3][](N, M)

Why not simply allow new double[N][3][M]; ? Seems a lot more intuitive/succinct than a separate []() implementation.
 Where:
 - The numbers inside the [] must be always compile-time constants, and
 they always refer to fixed-sized arrays.
 - The numbers inside the () are run-time values and must be used for
 dynamic arrays. (They can be up to the number of empty []. No more. But
 maybe they are allowed to be less).

 This means this syntax becomes an error:

 int n = 5;
 auto a = new int[n];

 You must write:

 int n = 5;
 auto a = new int[](n);

 This becomes allowed and allocates a fixed-sized array on the heap?

 auto a = new int[5];

 Bye,
 bearophile

Nov 18 2012
prev sibling next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
 auto a = new double[][](M, N);

That's a way to declare and initialize a dynamic array of dynamic arrays. If you want to allocate something else, you need a different syntax. Example, this creates something rather different: auto b = new double[][3][](M, N); In D there are both dynamic arrays and fixed-sized arrays, thankfully. Bye, bearophile
Nov 18 2012
prev sibling next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
 auto b = new double[][3][](M, N);

That doesn't compile, I don't know why. The D array syntax allocation syntax is a bit of a mess. So to do that you have to write: auto b = new double[][3][](N); Or: auto b = new double[][3][N]; And then fill the arrays with a loop. Why is no one complaining about this array allocation syntax? Bye, bearophile
Nov 18 2012
prev sibling next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
 Why is no one complaining about this array allocation syntax?

A syntax I like is: new double[][3][](N, M) Where: - The numbers inside the [] must be always compile-time constants, and they always refer to fixed-sized arrays. - The numbers inside the () are run-time values and must be used for dynamic arrays. (They can be up to the number of empty []. No more. But maybe they are allowed to be less). This means this syntax becomes an error: int n = 5; auto a = new int[n]; You must write: int n = 5; auto a = new int[](n); This becomes allowed and allocates a fixed-sized array on the heap? auto a = new int[5]; Bye, bearophile
Nov 18 2012
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Sunday, November 18, 2012 21:06:58 Tyro[17] wrote:
 On 11/18/12 8:14 PM, bearophile wrote:
 Why is no one complaining about this array allocation syntax?

A syntax I like is: new double[][3][](N, M)

Why not simply allow new double[N][3][M]; ? Seems a lot more intuitive/succinct than a separate []() implementation.

Because that declares a dynamic array of static arrays. You'd end up with a dynamic array of length N containing static arrays of length 3 containing static arrays of length M. The fact that you can declare dynamic arrays of static arrays screws with the syntax for declaring multidimensional arrays pretty thoroughly. - Jonathan M Davis
Nov 18 2012
prev sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Tyro[17]:

 Why not simply allow new double[N][3][M]; ?
 Seems a lot more intuitive/succinct than a separate []() 
 implementation.

I think with that there is some ambiguity regarding what coordinates are fixed-sized arrays and what dynamic arrays. Bye, bearophile
Nov 18 2012