how to "new" a two-dimension array in C++?

[James]

Hi,

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?

In java, I can easily create a two-dimension array by "double[][] pp =
new double[dynamic_size][dynamic_size]". But, how to do it in C++?

Looking forward to hearing from you!

Regards,

James

[John Harrison]

"James" <me******@mail1.monash.edu.au> wrote in message
news:dc**************************@posting.google.c om...

Hi,

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
A 2D array is a one dimensional array whose elements are other one
dimensional arrays. So you can just use new.

int (*a)[20] = new int[x][20];

but this probably isn't what you want because the second dimension is fixed
(20 in this case). You can also create an array of pointers, and make those
pointers point to other arrays.

int **a = new int*[x];
for (int i = 0; i < x; ++i)
a[i] = new int[y];

this gives you a 2D array which is variable in both dimensions. But its ugly
code, the sort of thing a C programmer would do.
Is the only way to create a class?
No, but obviously it is prefereable to either create a class or use one that
has already been created. C++ has a vector class which you can use to as a
2D 'array' (a vector of vectors). It also has a class called valarray which
can also be used to create 2D 'arrays'

In java, I can easily create a two-dimension array by "double[][] pp =
new double[dynamic_size][dynamic_size]". But, how to do it in C++?

Well I've given you four different options, take your pick, vector would be
my first choice.

john

[E. Robert Tisdale]

James wrote:

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?

In java, I can easily create a two-dimension array by "double[][] pp =
new double[dynamic_size][dynamic_size]". But, how to do it in C++?

Forget about new and try this:

double pp[dynamic_size][dynamic_size];

Variable length arrays are included in the C99 standard
and will be included in the new C++ standard.
Your compiler probably supports them already.

[Method Man]

"John Harrison" <jo*************@hotmail.com> wrote in message
news:2u*************@uni-berlin.de...

"James" <me******@mail1.monash.edu.au> wrote in message
news:dc**************************@posting.google.c om...

Hi,

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
A 2D array is a one dimensional array whose elements are other one
dimensional arrays. So you can just use new.

int (*a)[20] = new int[x][20];

but this probably isn't what you want because the second dimension is

fixed (20 in this case). You can also create an array of pointers, and make those pointers point to other arrays.

int **a = new int*[x];
for (int i = 0; i < x; ++i)
a[i] = new int[y];

this gives you a 2D array which is variable in both dimensions. But its ugly code, the sort of thing a C programmer would do.

Here is another method which calls 'new' only twice and allows all elements
of a 2D int array to be contiguous in memory:

int** a = new int*[x];
int a[0] = new int[x * y];
for (int i = 1; i < x; i++)
a[i] = a[0] + i * y;

If you don't need to extend the size of your array later (perhaps dealing
with matrices), then this method is very efficient.

[Gernot Frisch]

"James" <me******@mail1.monash.edu.au> schrieb im Newsbeitrag
news:dc**************************@posting.google.c om...

Hi,

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?

In java, I can easily create a two-dimension array by "double[][] pp
=
new double[dynamic_size][dynamic_size]". But, how to do it in C++?

Write a template class, that has a parameter for the dimensions. Then
use:

vector<vector<Type> > data;
and overload the [] operator to see, whether there is data at the
requested position / insert empty types or so. I'm a bit tired today,
but I hope you get the idea...
-Gernot

[JKop]

James posted:

Hi,

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?

In java, I can easily create a two-dimension array by "double[][] pp =
new double[dynamic_size][dynamic_size]". But, how to do it in C++?

Looking forward to hearing from you!

Regards,

James

Unfortunately, the following is illegal:

#include <iostream>
#include <cstddef>

int main()
{
std::size_t random1 = 67;
std::size_t random2 = 54;

int (&multi)[random1] = *reinterpret_cast< int (* const)[random1] >
( new int[random1][random2] );
}
I think you'd be better off using something like "std::vector".
-JKop

[Richard Herring]

In message <cm**********@nntp1.jpl.nasa.gov>, E. Robert Tisdale
<E.**************@jpl.nasa.gov> trolled

James wrote:

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?
In java, I can easily create a two-dimension array by "double[][] pp

new double[dynamic_size][dynamic_size]". But, how to do it in C++?
Forget about new and try this:

double pp[dynamic_size][dynamic_size];

Variable length arrays are included in the C99 standard

You seem to have strayed into the wrong newsgroup. This is clc++
and will be included in the new C++ standard.
Says who?
Your compiler probably supports them already.

Name five.

When trolling, please don't pick on newcomers who just came here for
helpful advice.

--
Richard Herring

[Leslaw Bieniasz]

In message <cm**********@nntp1.jpl.nasa.gov>, E. Robert Tisdale
<E.**************@jpl.nasa.gov> trolled

James wrote:

I am new to C++. I want to directly create a dynamic two-dimension
double array, i.e. double pp[][]. I found the "new" is only for
one-dimension array, i.e. double *p = new p[dynamic_size]. How to
"new" a two-dimension array?
Is the only way to create a class?
In java, I can easily create a two-dimension array by "double[][] pp

new double[dynamic_size][dynamic_size]". But, how to do it in C++?

What is wrong with the standard way?:

double **pp;
int n,m;

// Allocation
pp = new double* [n];
for(register int i=0; i<n; i++)
pp[i] = new double [m];
//Here you can use pp[i][j]
....

// Deallocation
for(register int i=n-1; i>=0; i--)delete [] pp[i];
delete [] pp;
The only problem is that the above does not provide bounds checking.
Writing a class with index checking will be more safe, but substantially
slower in use, although you can speed up things a little by internally
implementing the matrix as a one-dimensional vector.

L.B.
*-------------------------------------------------------------------*
| Dr. Leslaw Bieniasz, |
| Institute of Physical Chemistry of the Polish Academy of Sciences,|
| Department of Electrochemical Oxidation of Gaseous Fuels, |
| ul. Zagrody 13, 30-318 Cracow, Poland. |
| tel./fax: [phone] |
| E-mail: nb******@cyf-kr.edu.pl |
*-------------------------------------------------------------------*
| Interested in Computational Electrochemistry? |
| Visit my web site: http://www.cyf-kr.edu.pl/~nbbienia |
*-------------------------------------------------------------------*

[James]

Dear All,

Many thanks for your help! I got it!

Regards,

James

[E. Robert Tisdale]

Leslaw Bieniasz wrote:

What is wrong with the standard way?:

double **pp;
int n,m;

// Allocation
pp = new double* [n];
for(register int i=0; i<n; i++)
pp[i] = new double [m];

//Here you can use pp[i][j]
...

// Deallocation
for(register int i=n-1; i>=0; i--)delete [] pp[i];
delete [] pp;
That's lame. Try

// allocation
double** pp = new double* [n];
pp[0] = new double [n*m];
for (int i = 1; i < n; ++i)
pp[i] = pp[i-1] + m;

// use pp[i][j]

// deallocation
delete [] pp[0];
delete [] pp;
The only problem is that the above does not provide bounds checking.
Writing a class with index checking will be more safe, but substantially
slower in use, although you can speed up things a little by internally
implementing the matrix as a one-dimensional vector.

Take a look at
The C++ Scalar, Vector, Matrix and Tensor class Library

http://www.netwood.net/~edwin/svmtl/