Difference between multidimensional array in C++ and Java
Last Updated :
07 Feb, 2022
Prerequisites: Multidimensional array in C++, Multidimensional array in Java
Multidimensional Arrays:
Multidimensional arrays are a tabular representation of arrays to store multiple elements. These dimensions can be 1D arrays, 2D-arrays, etc. Multidimensional arrays are available in both C++ and Java, but their implementation and some properties are different.
Implementation in C/C++ :
In C++ a multidimensional array is created internally as a giant linear array. C++ syntax abstracts this linear block of memory into a 2 or 3-dimensional behavior making it easy for the programmer.
Examples:
A 2D array of dimensions 2 rows x 3 cols {{9, 45, 51}, {5, 25, 6}} is implemented as follows (Assuming Integer takes 4 bytes):
Hence, the inner formula for inner element at particular index is given as:
arr[rowIndex][colIndex] = arr + (rowIndex * noOfCols * sizeOfDataType) + coLIndex * sizeOfDataType
Let assume base address to be 3000. Then arr[1][1] = 3000 + (1 * 3 * 4) + 1 * 4 = 3000 + 12 + 4 = 3016.
Because of such implementation, the number of columns must be equal for each row, and it is mandatory to specify column size while declaration in order to access elements properly.
Below is the implementation of the multidimensional array in C++:
C++
#include <iostream>
using namespace std;
int main()
{
int arr[3][5] = {
{ 23, 56, 34, 52, 63 },
{ 40, 20, 96, 43, 97 },
{ 75, 51, 10, 82, 43 }
};
cout << "Printing entire 2d array: "
<< endl;
for ( int i = 0; i < 3; i++) {
for ( int j = 0; j < 5; j++) {
cout << "arr[" << i << "][" << j
<< "]:" << arr[i][j]
<< " " ;
}
cout << endl;
}
return 0;
}
|
Output:
Printing entire 2d array:
arr[0][0]:23 arr[0][1]:56 arr[0][2]:34 arr[0][3]:52 arr[0][4]:63
arr[1][0]:40 arr[1][1]:20 arr[1][2]:96 arr[1][3]:43 arr[1][4]:97
arr[2][0]:75 arr[2][1]:51 arr[2][2]:10 arr[2][3]:82 arr[2][4]:43
Implementation in Java:
In Java, a multidimensional array is implemented as an array of arrays where each index of the base array refers to an entirely different array. So, arr[rowIndex] returns an entire single dimensional array and arr[rowIndex][coLIndex] returns the element at index coLIndex in that single dimensional array.
Examples:
A 2D array of dimensions 3 rows x 5 cols is implemented as follows:
Because of this structure, It is possible to have 2D arrays with different column sizes (even null values) in Java.
Below is the implementation of the multidimensional array in Java:
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
int [][] arr = {
{ 23 , 56 , 34 , 52 , 63 },
{ 40 , 20 , 96 , 43 , 97 },
{ 75 , 51 , 10 , 82 , 43 }
};
System.out.println( "Printing entire 2d array: " );
for ( int i = 0 ;
i < arr.length; i++) {
for ( int j = 0 ;
j < arr[i].length; j++) {
System.out.print(
"arr[" + i + "][" + j
+ "]:" + arr[i][j]
+ " " );
}
System.out.println();
}
System.out.println();
arr[ 2 ] = new int [] { 82 , 53 , 64 ,
12 , 45 , 3 };
System.out.println(
"Printing entire 2d array "
+ "after modification: " );
for ( int i = 0 ;
i < arr.length; i++) {
for ( int j = 0 ;
j < arr[i].length; j++) {
System.out.print(
"arr[" + i + "][" + j
+ "]:" + arr[i][j]
+ " " );
}
System.out.println();
}
}
}
|
Output
Printing entire 2d array:
arr[0][0]:23 arr[0][1]:56 arr[0][2]:34 arr[0][3]:52 arr[0][4]:63
arr[1][0]:40 arr[1][1]:20 arr[1][2]:96 arr[1][3]:43 arr[1][4]:97
arr[2][0]:75 arr[2][1]:51 arr[2][2]:10 arr[2][3]:82 arr[2][4]:43
Printing entire 2d array after modification:
arr[0][0]:23 arr[0][1]:56 arr[0][2]:34 arr[0][3]:52 arr[0][4]:63
arr[1][0]:40 arr[1][1]:20 arr[1][2]:96 arr[1][3]:43 arr[1][4]:97
arr[2][0]:82 arr[2][1]:53 arr[2][2]:64 arr[2][3]:12 arr[2][4]:45 arr[2][5]:3
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...