Basics of Character Triple Dimension Array
In this section, you are going to learn
What are the basic properties of a character triple dimension array ?
What are the different expressions of triple dimension array ?
What are synonymous expresions of triple dimension array ?
How to find sizeof() of expressions of triple dimension array ?
char array_name[Block][Row][Column];
Consider a character triple dimension array
char a[3][4][5];
Let us answer few basic questions in this array
How many characters can be stored in this array ?
See Answer
Number of Characters = 3 * 4 * 5 = 60
How many bytes are there in this array ?
See Answer
Number of Bytes = 3 * 4 * 5 = 60
What is the sizeof the array ?
See Answer
sizeof(a) = Number of Bytes = 3 * 4 * 5 = 60
How many single dimension arrays are present in this triple dimension array ?
See Answer
There are, 3 * 4 = 12 Single dimension arrays. Size of each single dimension array is 5 Bytes
How many double dimension arrays are present in this triple dimension array ?
See Answer
There are 3 Double dimension arrays. Size of each double dimension array is 4 * 5 = 20 Bytes
What are the names of double dimension arrays in this triple dimension array ?
See Answer
a[0]
a[1]
a[2]
What are the names of single dimension arrays in this triple dimension array ?
See Answer
a[0][0]
a[0][1]
a[0][2]
a[0][3]
a[1][0]
a[1][1]
a[1][2]
a[1][3]
a[2][0]
a[2][1]
a[2][2]
a[2][3]
How do you represent the first character ?
See Answer
a[0][0][0]
How do you represent the last character ?
See Answer
a[2][3][4]
How do you initialise the array at the time of declaration ?
See Answer
char a[3][4][5] = {
{
"lap0", "top0", "xxx0", "1230",
},
{
"gap0", "pop0", "yyy0", "4560" ,
},
{
"sap0", "gop0", "zzz0", "7890"
}
};
OR
char a[3][4][5] = {
{
{'l', 'a', 'p', '0'},
{'t', 'o', 'p', '0'},
{'x', 'x', 'x', '0'},
{'1', '2', '3', '0'},
},
{
{'g', 'a', 'p', '0'},
{'p', 'o', 'p', '0'},
{'y', 'y', 'y', '0'},
{'4', '5', '6', '0'} ,
},
{
{'s', 'a', 'p', '0'},
{'g', 'o', 'p', '0'},
{'z', 'z', 'z', '0'},
{'7', '8', '9', '0'}
}
};
Let us now explore basic examples of triple dimension array !
Step 1 : Define a Triple Dimension Array
char a[3][4][5] = {
{
"lap0", "top0", "xxx0", "1230",
},
{
"gap0", "pop0", "yyy0", "4560" ,
},
{
"sap0", "gop0", "zzz0", "7890"
}
};
Step 2 : Access and Print individual characters
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
printf("%c ", a[i][j][k] );
}
printf("\n");
}
printf("\n");
}
Step 3 : Access and Print individual strings
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%s", a[i][j] );
printf("\n");
}
printf("\n");
}
See the full program below
#include <stdio.h>
int main(void)
{
char a[3][4][5] = {
{
"lap0", "top0", "xxx0", "1230",
},
{
"gap0", "pop0", "yyy0", "4560" ,
},
{
"sap0", "gop0", "zzz0", "7890"
}
};
// Access individual characters
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
printf("%c ", a[i][j][k] );
}
printf("\n");
}
printf("\n");
}
// Access individual strings
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%s", a[i][j] );
printf("\n");
}
printf("\n");
}
return 0;
}
Output is as below
l a p 0
t o p 0
x x x 0
1 2 3 0
g a p 0
p o p 0
y y y 0
4 5 6 0
s a p 0
g o p 0
z z z 0
7 8 9 0
lap0
top0
xxx0
1230
gap0
pop0
yyy0
4560
sap0
gop0
zzz0
7890
Step 1 : Define a Triple Dimension Array
char a[3][4][5] = {
{
{'l', 'a', 'p', '0'},
{'t', 'o', 'p', '0'},
{'x', 'x', 'x', '0'},
{'1', '2', '3', '0'},
},
{
{'g', 'a', 'p', '0'},
{'p', 'o', 'p', '0'},
{'y', 'y', 'y', '0'},
{'4', '5', '6', '0'} ,
},
{
{'s', 'a', 'p', '0'},
{'g', 'o', 'p', '0'},
{'z', 'z', 'z', '0'},
{'7', '8', '9', '0'}
}
};
Step 2 : Access and Print individual characters
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
printf("%c ", a[i][j][k] );
}
printf("\n");
}
printf("\n");
}
Step 3 : Access and Print individual strings
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%s", a[i][j] );
printf("\n");
}
printf("\n");
}
See the full program below
#include <stdio.h>
int main(void)
{
char a[3][4][5] = {
{
{'l', 'a', 'p', '0'},
{'t', 'o', 'p', '0'},
{'x', 'x', 'x', '0'},
{'1', '2', '3', '0'},
},
{
{'g', 'a', 'p', '0'},
{'p', 'o', 'p', '0'},
{'y', 'y', 'y', '0'},
{'4', '5', '6', '0'} ,
},
{
{'s', 'a', 'p', '0'},
{'g', 'o', 'p', '0'},
{'z', 'z', 'z', '0'},
{'7', '8', '9', '0'}
}
};
// Access individual characters
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
printf("%c ", a[i][j][k] );
}
printf("\n");
}
printf("\n");
}
// Access individual strings
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%s", a[i][j] );
printf("\n");
}
printf("\n");
}
return 0;
}
Output is as below
l a p 0
t o p 0
x x x 0
1 2 3 0
g a p 0
p o p 0
y y y 0
4 5 6 0
s a p 0
g o p 0
z z z 0
7 8 9 0
lap0
top0
xxx0
1230
gap0
pop0
yyy0
4560
sap0
gop0
zzz0
7890
Let us now explore Triple 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][0] |
|
a[1][0][0] |
|
a[2][0][0] |
|
&a[0][0][0] |
|
&a[1][0][0] |
|
&a[2][0][0] |
|
***a |
|
*(*(*(a + 1) + 0) + 0) |
|
*(*(*(a + 2) + 0) + 0) |
|
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][0] |
|
a[1][0][0] |
|
a[2][0][0] |
|
&a[0][0][0] |
|
&a[1][0][0] |
|
&a[2][0][0] |
|
***a |
|
*(*(*(a + 1) + 0) + 0) |
|
*(*(*(a + 2) + 0) + 0) |
|
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 |
|
Finding the type of an expression is easy. See below
Expression |
Type |
Description |
|---|---|---|
a[0][0][0] |
char |
|
a[1][0][0] |
char |
|
a[2][0][0] |
char |
|
&a[0][0][0] |
char |
|
&a[1][0][0] |
char |
|
&a[2][0][0] |
char |
|
***a |
char |
|
*(*(*(a + 1) + 0) + 0) |
char |
|
*(*(*(a + 2) + 0) + 0) |
char |
|
a[0][0] |
char * |
|
a[1][0] |
char * |
|
a[2][0] |
char * |
|
&a[0][0] |
char (*)[5] |
|
&a[1][0] |
char (*)[5] |
|
&a[2][0] |
char (*)[5] |
|
**a |
char * |
|
*(*(a + 1) + 0) |
char * |
|
*(*(a + 2) + 0) |
char * |
|
a[0] |
char (*)[5] |
|
a[1] |
char (*)[5] |
|
a[2] |
char (*)[5] |
|
&a[0] |
char (*)[4][5] |
|
&a[1] |
char (*)[4][5] |
|
&a[2] |
char (*)[4][5] |
|
*a |
char (*)[5] |
|
*(a + 1) |
char (*)[5] |
|
*(a + 2) |
char (*)[5] |
|
a |
char (*)[4][5] |
|
a + 1 |
char (*)[4][5] |
|
a + 2 |
char (*)[4][5] |
|
&a |
char (*)[3][4][5] |
|
sizeof(expression) |
size |
Description |
|---|---|---|
sizeof(a[0][0][0]) |
1 |
a[0][0][0] is a character |
sizeof(a[1][0][0]) |
1 |
a[1][0][0] is a character |
sizeof(a[2][0][0]) |
1 |
a[2][0][0] is a character |
sizeof(&a[0][0][0]) |
8 |
&a[0][0][0] is address / pointer |
sizeof(&a[1][0][0]) |
8 |
&a[1][0][0] is address / pointer |
sizeof(&a[2][0][0]) |
8 |
&a[2][0][0] is address / pointer |
sizeof(***a) |
1 |
***a is a character |
sizeof(*(*(*(a + 1) + 0) + 0)) |
1 |
*(*(*(a + 1) + 0) + 0) is a character |
sizeof(*(*(*(a + 2) + 0) + 0)) |
1 |
*(*(*(a + 2) + 0) + 0) is a character |
sizeof(a[0][0]) |
5 |
a[0][0] is a Single Dimension Array |
sizeof(a[1][0]) |
5 |
a[1][0] is a Single Dimension Array |
sizeof(a[2][0]) |
5 |
a[2][0] is a Single Dimension Array |
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) |
5 |
**a is a Single Dimension Array |
sizeof(*(*(a + 1) + 0)) |
5 |
*(*(a + 1) + 0) is a Single Dimension Array |
sizeof(*(*(a + 2) + 0)) |
5 |
*(*(a + 2) + 0) is a Single Dimension Array |
sizeof(a[0]) |
20 |
a[0] is a Double Dimension Array |
sizeof(a[1]) |
20 |
a[1] is a Double Dimension Array |
sizeof(a[2]) |
20 |
a[2] is a Double 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) |
20 |
*a is a Double Dimension Array |
sizeof(*(a + 1)) |
20 |
*(a + 1) is a Double Dimension Array |
sizeof(*(a + 2)) |
20 |
*(a + 2) is a Double Dimension Array |
sizeof(a) |
60 |
a is a triple 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)
{
char a[3][4][5] = {
{
"lap0", "top0", "xxx0", "1230",
},
{
"gap0", "pop0", "yyy0", "4560" ,
},
{
"sap0", "gop0", "zzz0", "7890"
}
};
printf("sizeof(a[0][0][0]) = %d\n", (int) sizeof(a[0][0][0]) );
printf("sizeof(a[1][0][0]) = %d\n", (int) sizeof(a[1][0][0]) );
printf("sizeof(a[2][0][0]) = %d\n", (int) sizeof(a[2][0][0]) );
printf("sizeof(&a[0][0][0]) = %d\n", (int) sizeof(&a[0][0][0]) );
printf("sizeof(&a[1][0][0]) = %d\n", (int) sizeof(&a[1][0][0]) );
printf("sizeof(&a[2][0][0]) = %d\n", (int) sizeof(&a[2][0][0]) );
printf("sizeof(***a) = %d\n", (int) sizeof(***a) );
printf("sizeof(*(*(*(a + 1) + 0) + 0)) = %d\n", (int) sizeof(*(*(*(a + 1) + 0) + 0)) );
printf("sizeof(*(*(*(a + 2) + 0) + 0)) = %d\n", (int) sizeof(*(*(*(a + 2) + 0) + 0)) );
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][0]) = 1
sizeof(a[1][0][0]) = 1
sizeof(a[2][0][0]) = 1
sizeof(&a[0][0][0]) = 8
sizeof(&a[1][0][0]) = 8
sizeof(&a[2][0][0]) = 8
sizeof(***a) = 1
sizeof(*(*(*(a + 1) + 0) + 0)) = 1
sizeof(*(*(*(a + 2) + 0) + 0)) = 1
sizeof(a[0][0]) = 5
sizeof(a[1][0]) = 5
sizeof(a[2][0]) = 5
sizeof(&a[0][0]) = 8
sizeof(&a[1][0] = 8
sizeof(&a[2][0]) = 8
sizeof(**a) = 5
sizeof(*(*(a + 1) + 0)) = 5
sizeof(*(*(a + 2) + 0)) = 5
sizeof(a[0]) = 20
sizeof(a[1]) = 20
sizeof(a[2]) = 20
sizeof(&a[0]) = 8
sizeof(&a[1]) = 8
sizeof(&a[2]) = 8
sizeof(*a) = 20
sizeof(*(a + 1)) = 20
sizeof(*(a + 2)) = 20
sizeof(a) = 60
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][0]) |
void fun(char x) {} |
|
fun(a[1][0][0]) |
void fun(char x) {} |
|
fun(a[2][0][0]) |
void fun(char x) {} |
|
fun(&a[0][0][0]) |
void fun(char *p) {} |
|
fun(&a[1][0][0]) |
void fun(char *p) {} |
|
fun(&a[2][0][0]) |
void fun(char *p) {} |
|
fun(a[0][0]) |
void fun(char *p) {} |
|
fun(a[1][0]) |
void fun(char *p) {} |
|
fun(a[2][0]) |
void fun(char *p) {} |
|
fun(&a[0][0]) |
void fun(char (*p)[5]) {} |
|
fun(&a[1][0]) |
void fun(char (*p)[5]) {} |
|
fun(&a[2][0]) |
void fun(char (*p)[5]) {} |
|
fun(**a) |
void fun(char *p) {} |
|
fun(*(*(a + 1) + 0)) |
void fun(char *p) {} |
|
fun(*(*(a + 2) + 0)) |
void fun(char *p) {} |
|
fun(a[0]) |
void fun(char (*p)[5]) {} |
|
fun(a[1]) |
void fun(char (*p)[5]) {} |
|
fun(a[2]) |
void fun(char (*p)[5]) {} |
|
fun(&a[0]) |
void fun(char (*p)[4][5]) {} |
|
fun(&a[1]) |
void fun(char (*p)[4][5]) {} |
|
fun(&a[2]) |
void fun(char (*p)[4][5]) {} |
|
fun(*a) |
void fun(char (*p)[5]) {} |
|
fun(*(a + 1)) |
void fun(char (*p)[5]) {} |
|
fun(*(a + 2)) |
void fun(char (*p)[5]) {} |
|
fun(a) |
void fun(char (*p)[4][5]) {} |
|
fun(a + 1) |
void fun(char (*p)[4][5]) {} |
|
fun(a + 2) |
void fun(char (*p)[4][5]) {} |
|
fun(&a) |
void fun(char (*p)[3][4][5]) {} |
|
Read more about function calls and conventions of Functions and Character Triple Dimension Array
Other topics of character and functions
Current Module
Previous Module
Next Module
Other Modules