Basics of Integer Double Dimension Array
In this section, you are going to learn
What are the basic properties of a integer double dimension array ?
What are the different expressions of double dimension array ?
What are synonymous expresions of double dimension array ?
How to find sizeof() of expressions of double dimension array ?
int array_name[Row][Column];
Consider a integer double dimension array
int a[3][4];
Let us answer few basic questions in this array
How many integers can be stored in this array ?
See Answer
Number of Integers = Rows * Columns = 3 * 4 = 12
How many bytes are there in this array ?
See Answer
Number of Bytes = Rows * Columns * sizeof(int) = 3 * 4 * 4 = 48
What is the sizeof the array ?
See Answer
sizeof(a) = Number of Bytes = Rows * Columns * sizeof(int )= 3 * 4 * 4 = 48
How many single dimension arrays are present in this double dimension array ?
See Answer
There are 3 Single dimension arrays. Size of each single dimension array is 4 integers which is equal to 4 * 4 = 16 Bytes
What are the names of single dimension arrays in this double dimension array ?
See Answer
a[0]
a[1]
a[2]
How do you represent the first integer ?
See Answer
a[0][0]
How do you represent the last integer ?
See Answer
a[2][3]
How do you initialise the array at the time of declaration ?
See Answer
int a[3][4] = {
{ 1, 2, 3, 4 },
{ 10, 20, 30, 40 },
{ 100, 200, 300, 400 },
};
Let us now explore basic examples of double dimension array !
Step 1 : Define a Double Dimension Array
int a[3][4] = {
{ 1, 2, 3, 4 },
{ 10, 20, 30, 40 },
{ 100, 200, 300, 400 },
};
Step 2 : Access and Print individual integers
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
Step 4 : See the full program below
#include <stdio.h>
int main(void)
{
int a[3][4] = {
{ 1, 2, 3, 4 },
{ 10, 20, 30, 40 },
{ 100, 200, 300, 400 },
};
// print individual integers
printf("--------- Access and Print Integers ----------\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4 ; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
return 0;
}
Step 5 : Output is as below
--------- Access and Print Integers ----------
1 2 3 4
10 20 30 40
100 200 300 400
Let us now explore double dimension array in depth !
Below are the properties
Expressions
Synonyms
typeof(expression)
sizeof(expression)
fun(expression)
Know what are the possible expressions and how to properly call them !
Expression |
Description |
|---|---|
a[0][0] |
|
a[1][0] |
|
a[2][0] |
|
&a[0][0] |
|
&a[1][0] |
|
&a[2][0] |
|
**a |
|
*(*(a + 1) + 0) |
|
*(*(a + 2) + 0) |
|
a[0] |
|
a[1] |
|
a[2] |
|
&a[0] |
|
&a[1] |
|
&a[2] |
|
*a |
|
*(a + 1) |
|
*(a + 2) |
|
a |
|
a + 1 |
|
a + 2 |
|
&a |
|
Synonyms : Which can be used interchangeably !
Programmatically few expressions are one and the same ! Let us learn them
Expression |
Synonyms |
|---|---|
a[0][0] |
**a |
a[1][0] |
*(*(a + 1) + 0) |
a[2][0] |
*(*(a + 2) + 0) |
&a[0][0] |
a[0] |
&a[1][0] |
a[1] |
&a[2][0] |
a[2] |
**a |
a[0][0] |
*(*(a + 1) + 0) |
a[1][0] |
*(*(a + 2) + 0) |
a[2][0] |
a[0] |
*a &a[0][0] |
a[1] |
*(a + 1) &a[1][0] |
a[2] |
*(a + 2) &a[2][0] |
&a[0] |
a + 0 a |
&a[1] |
a + 1 |
&a[2] |
a + 2 |
*a |
a[0] &a[0][0] |
*(a + 1) |
a[1] &a[1][0] |
*(a + 2) |
a[2] &a[2][0] |
a |
&a[0] |
a + 1 |
&a[1] |
a + 2 |
&a[2] |
&a |
&a |
Finding the type of an expression is easy. See below
Expression |
Type |
Description |
|---|---|---|
a[0][0] |
int |
|
a[1][0] |
int |
|
a[2][0] |
int |
|
&a[0][0] |
int * |
|
&a[1][0] |
int * |
|
&a[2][0] |
int * |
|
**a |
int |
|
*(*(a + 1) + 0) |
int |
|
*(*(a + 2) + 0) |
int |
|
a[0] |
int * |
|
a[1] |
int * |
|
a[2] |
int * |
|
&a[0] |
int * |
|
&a[1] |
int * |
|
&a[2] |
int * |
|
*a |
int |
|
*(a + 1) |
int |
|
*(a + 2) |
int |
|
a |
int * |
|
a + 1 |
int * |
|
a + 2 |
int * |
|
&a |
int (*)[3][4] |
|
sizeof(expression) |
size |
Description |
|---|---|---|
sizeof(a[0][0]) |
4 |
a[0][0] is a integer |
sizeof(a[1][0]) |
4 |
a[1][0] is a integer |
sizeof(a[2][0]) |
4 |
a[2][0] is a integer |
sizeof(&a[0][0]) |
8 |
&a[0][0] is address / pointer |
sizeof(&a[1][0]) |
8 |
&a[1][0] is address / pointer |
sizeof(&a[2][0]) |
8 |
&a[2][0] is address / pointer |
sizeof(**a) |
4 |
**a is a integer |
sizeof(*(*(a + 1) + 0)) |
4 |
*(*(a + 1) + 0) is a integer |
sizeof(*(*(a + 2) + 0)) |
4 |
*(*(a + 2) + 0) is a integer |
sizeof(a[0]) |
16 |
a[0] is a single dimension array |
sizeof(a[1]) |
16 |
a[1] is a single dimension array |
sizeof(a[2]) |
16 |
a[2] is a single dimension array |
sizeof(&a[0]) |
8 |
&a[0] is address / pointer |
sizeof(&a[1]) |
8 |
&a[1] is address / pointer |
sizeof(&a[2]) |
8 |
&a[2] is address / pointer |
sizeof(*a) |
16 |
*a is a single dimension array |
sizeof(*(a + 1)) |
16 |
*(a + 1) is a single dimension array |
sizeof(*(a + 2)) |
16 |
*(a + 2) is a single dimension array |
sizeof(a) |
48 |
a is a double dimension array |
sizeof(a + 1) |
8 |
a + 1 is address / pointer |
sizeof(a + 2) |
8 |
a + 2 is address / pointer |
sizeof(&a) |
8 |
&a is address / pointer |
See the full program below
#include <stdio.h>
int main(void)
{
int a[3][4] = {
{ 1, 2, 3, 4 },
{ 10, 20, 30, 40 },
{ 100, 200, 300, 400 },
};
printf("sizeof(a[0][0]) = %d\n", (int) sizeof(a[0][0]) );
printf("sizeof(a[1][0]) = %d\n", (int) sizeof(a[1][0]) );
printf("sizeof(a[2][0]) = %d\n", (int) sizeof(a[2][0]) );
printf("sizeof(&a[0][0]) = %d\n", (int) sizeof(&a[0][0]) );
printf("sizeof(&a[1][0]) = %d\n", (int) sizeof(&a[1][1]) );
printf("sizeof(&a[2][0]) = %d\n", (int) sizeof(&a[2][0]) );
printf("sizeof(**a) = %d\n", (int) sizeof(**a));
printf("sizeof(*(*(a + 1) + 0)) = %d\n", (int) sizeof(*(*(a + 1) + 0)) );
printf("sizeof(*(*(a + 2) + 0)) = %d\n", (int) sizeof(*(*(a + 2) + 0)) );
printf("sizeof(a[0]) = %d\n", (int) sizeof(a[0]) );
printf("sizeof(a[1]) = %d\n", (int) sizeof(a[1]) );
printf("sizeof(a[2]) = %d\n", (int) sizeof(a[2]) );
printf("sizeof(&a[0]) = %d\n", (int) sizeof(&a[0]) );
printf("sizeof(&a[1]) = %d\n", (int) sizeof(&a[1]) );
printf("sizeof(&a[2]) = %d\n", (int) sizeof(&a[2]) );
printf("sizeof(*a) = %d\n", (int) sizeof(*a) );
printf("sizeof(*(a + 1)) = %d\n", (int) sizeof(*(a + 1)) );
printf("sizeof(*(a + 2)) = %d\n", (int) sizeof(*(a + 2)) );
printf("sizeof(a) = %d\n", (int) sizeof(a) );
printf("sizeof(a + 1) = %d\n", (int) sizeof(a + 1) );
printf("sizeof(a + 2) = %d\n", (int) sizeof(a + 2) );
printf("sizeof(&a) = %d\n", (int) sizeof(&a) );
return 0;
}
Output is as below on 64 bit OS
sizeof(a[0][0]) = 4
sizeof(a[1][0]) = 4
sizeof(a[2][0]) = 4
sizeof(&a[0][0]) = 8
sizeof(&a[1][0]) = 8
sizeof(&a[2][0]) = 8
sizeof(**a) = 4
sizeof(*(*(a + 1) + 0)) = 4
sizeof(*(*(a + 2) + 0)) = 4
sizeof(a[0]) = 16
sizeof(a[1]) = 16
sizeof(a[2]) = 16
sizeof(&a[0]) = 8
sizeof(&a[1]) = 8
sizeof(&a[2]) = 8
sizeof(*a) = 16
sizeof(*(a + 1)) = 16
sizeof(*(a + 2)) = 16
sizeof(a) = 48
sizeof(a + 1) = 8
sizeof(a + 2) = 8
sizeof(&a) = 8
If fun(x) is the function call, then fun(typeof(x)) is the prototype / definition
Function Call |
Function Definition |
Observations |
|---|---|---|
fun(a[0][0]) |
void fun(int x) {} |
|
fun(a[1][0]) |
void fun(int x) {} |
|
fun(a[2][0]) |
void fun(int x) {} |
|
fun(&a[0][0]) |
void fun(int *p) { } |
|
fun(&a[1][0]) |
void fun(int *p) { } |
|
fun(&a[2][0]) |
void fun(int *p) { } |
|
fun(**a) |
void fun(int x) {} |
|
fun(*(*(a + 1) + 0)) |
void fun(int x) {} |
|
fun(*(*(a + 2) + 0)) |
void fun(int x) {} |
|
fun(a[0]) |
void fun(int *p) { } |
|
fun(a[1]) |
void fun(int *p) { } |
|
fun(a[2]) |
void fun(int *p) { } |
|
fun(&a[0]) |
void fun(int (*p)[4]) { } |
|
fun(&a[1]) |
void fun(int (*p)[4]) { } |
|
fun(&a[2]) |
void fun(int (*p)[4]) { } |
|
fun(*a) |
void fun(int *p) { } |
|
fun(*(a + 1)) |
void fun(int *p) { } |
|
fun(*(a + 2)) |
void fun(int *p) { } |
|
fun(a) |
void fun(int (*p)[4]) { } |
|
fun(a + 1) |
void fun(int (*p)[4]) { } |
|
fun(a + 2) |
void fun(int (*p)[4]) { } |
|
fun(&a) |
void fun(int (*p)[3][4]) { } |
|
Read more about function calls and conventions of Functions and Integer Double Dimension Array
Other topics of character and functions
Current Module
Previous Module
Next Module
Other Modules