What is declaration syntax of an array?

Answer 1

In what language?

c and c++

a 5 x 5 array of Int

int nMultiIntArray[5][5];

Answer:

in java

int array[][]=new int[5][5];

in vb

dim array(5,5) as Integer

Answer 2

C-style static array:

int x[10][5]; // an array of arrays (10 arrays of 5 elements each)

C++ static array:

std::array<std::array<int, 5>, 10> a;

C++ dynamic array (vector):

std::vector<std::vector<int>> v;

In a C++ dynamic array, each dimension can have a different number of elements. A classic example of a multidimensional array is an array of strings, where each string is a character array of variable length:

std::vector<std::string> s;

Answer 3

Syntax of an array

type var_name[];

or

type []var_name;

Where

type- Type is an valid data type or reference name.

var_name- Valid identifier where is accepted by Java compiler.

Answer 4

There are two types of arrays: static and dynamic.

A two dimensional array is one array, each element of which consists of another array. Declaring a two-dimensional static array is as follows:

[][];

For instance:

int myintarray[10][5];

This sets up an array of 50 elements: 10*5. Assuming intis 4 bytes large, the total size of this array is 200 bytes. The outermost array is indexed from 0 to 9, and the innermost arrays are indexed from 0 to 4. Thus, "maxindex+1" above.

Dynamic arrays are created using a memory allocation function (i.e. malloc()). The above array declaration could be rewritten as follows:

int **myintarray, index;

myintarray=(int**)malloc(sizeof(int*)*10);

for (index=0; index<10; index++)

myintarray[index]=(int*)malloc(sizeof(int)*5);

The outermost array has a block of memory 40 bytes long on a system using 32-bit pointers. Each array within has a block of memory 20 bytes long for a 32-bit int.

Please note that using constants like above (10 and 5) is not recommended, and you should use #define statements to help prevent invisible bugs. For instance, if you later changed 10 to 20 in the allocator, but neglected to make the same change in a for() iterator loop, memory that had been allocated would not be used; conversely, making a similar change in the iterator but not the allocator would lead to a segmentation fault condition (segfault).

So either of the following is instead recommended:

#define OUTARRSIZE 10

#define INARRSIZE 5

int myintarray[OUTARRSIZE][INARRSIZE];

Or:

#define OUTARRSIZE 10

#define INARRSIZE 5

int **myintarray, index;

myintarray=(int**)malloc(sizeof(int*)*OUTARRSIZE);

for (index=0; index

myintarray[index]=(int*)malloc(sizeof(int)*INARRSIZE);

More information on arrays and pointers is available at the related links below.

(Note that the code above has not been tested, and is available for demonstrative purposes only.)