Download to read offline
![210 Basic C
#endif
11 #endif /* SUM_H */
✌
✆
Codes of sum function is define in the file ‘sum.c’.
✞
1 /* sum_f() function for adding two numbers */
int sum_f(int a, int b) {
3 int c;
c = a + b;
5 return c;
}
✌
✆
Main function for calling a procedure is defined in ‘main.c’ file as
✞
#include <stdio.h>
2 /* sum.h header contains sum_f() function *
* that should be indentified and called. */
4 #include "sum.h"
6 int main (void ){
int a=2,b=3;
8 /* sum_f() function is called from *
*sum.c and identified via sum.h */
10 int c=sum_f(a,b);
printf("The sum of 2 and 3 is %d.",c);
12 return 0;
}
✌
✆
When program is compiled and run the output is
✞
The sum of 2 and 3 is 5.
✌
✆
If a macro produces multiple statements, or declares variables, it can be wrapped in
a do { ... } while(0) loop, with no terminating semicolon. This allows the macro to be
used like a single statement in any location.
✞
1 #define FREE (p) free (p); p = NULL ; /* Bad practice .*/
#define FREE (p) do { free (p); p = NULL ; } while(0) /* Good
practice .*/
✌
✆
1.10.7 Type Converter
Following is an example of string to integer conversion.
✞
#include <stdio.h>
2 #include <string.h>
4 int main (int argc , char *argv [ ]) {
char st [10] = "This ";
6 printf("String ’%s’ = integer %d.n", st , (int) st);](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-11-2048.jpg)
![1.11. PARSING ARGUMENTS 211
return 0;
8 }
✌
✆
✞
String ’This ’ = integer 2280640.
✌
✆
1.11 Parsing Arguments
When a program is being executed via another program internally, arguments are required
to be passed to the executable ie the program. These arguments are considered as inputs
for the executable. To pass the values we define main() function as
✞
1 int main (int argc , char *argv [ ])
✌
✆
Here argc counts the number of arguments in an array and argv assigns the values to
each respective counter.
✞
1 #include <stdio.h>
#include <string.h>
3 #include <stdlib.h>
5 /* main function is modified according to*
*receive the arguments in command line */
7 int main (int argc , char *argv [ ]) {
int argnum = 0;
9 /* Starting from zero */
while (argc > ++ argnum)
11 printf("Argument %d of arguments %d is %c.n",
argnum ,
13 argc ,
*argv [argnum ]);
15 exit ( EXIT_SUCCESS );
}
✌
✆
After compiling and executing the executable as
✞
executable .exe a b c
✌
✆
Output is
✞
Argument 1 of supplied four arguments is a.
Argument 2 of supplied four arguments is b.
Argument 3 of supplied four arguments is c.
✌
✆
Here executable.exe in command-line is also considered as an argument. This is why
there are four arguments and first argument, ie 0th
argument, is executable.exe itself and
rest of the arguments are a, b and c respectively. An other example is given below](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-12-2048.jpg)
![212 Basic C
✞
1 #include <stdio.h>
3 int main (int argc , char ** argv ) {
size_t i;
5
for (i = 0; i < argc ; i++) {
7 /* get all the arguments as options *
*and initialize option pointer . */
9 char const *option = argv [i];
/* Get first character of an option argument */
11 if (option [0] == ’-’) {
/*If first character of an option argument *
13 *is ’-’, then following character is a flag */
printf("Flagged option.n");
15 /* get the second character of an option argument .*/
switch (option [1]) {
17 /*If second char of an option argument *
*is ’e’, then print encryption */
19 case ’e’:
printf("You have chosen %c:ENCryption . n",
option [1]) ;
21 break;
/*If second char of an option argument *
23 *is ’d’, then print decryption */
case ’d’:
25 printf("You have chosen %c:DECryption . n",
option [1]) ;
break;
27 /*If second char of an option argument *
*is ’f’, then print filename */
29 case ’f’:
printf("Your have chosen file name %c.n",
option [1]) ;
31 break;
/* other wise */
33 default :
printf("I can not understand your option %sn",
option);
35 break;
}
37 } else {
printf("No Flagged Options .n");
39 }
}
41 return 0;
}
✌
✆
When above example is compiled and executed like
✞
executable .exe -e -f
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-13-2048.jpg)
![1.11. PARSING ARGUMENTS 213
The output at console is
✞
No Flagged Option.
Flagged Option.
You have chosen e:ENCryption .
Flagged Option.
You have chosen filename f.
✌
✆
The first output “No Flagged Option” is appeared at the console at first as ‘exe-
cutable.exe’ is considered as first parsing argument and it is not prefixed with ‘–’. Using
array and pointer we do reverse to a parsed string via command line is given below.
✞
1 #include <stdio.h>
#include <stdlib.h>
3 /* String Length*/
#define SLen 4
5
int main (int argc , char *argv [ ]) {
7 /* Get the commandline string*/
char *name = argv [1];
9 char nameR [10];
int i;
11 for (i = 0; i < SLen ; i++)
/* Store each character of string in array*/
13 nameR[i] = name [i];
15 for (i = 4; i > 0; --i)
/* Print each character of stored string in array*/
17 printf("%c", nameR[i - 1]);
exit ( EXIT_SUCCESS );
19 }
✌
✆
Similarly the string length of given string can also be obtain by using following example
✞
1 #include <stdio.h>
3 int main (int argc , char *argv [ ]) {
if (argv [1] == NULL ) {
5 printf("Use <utility .exe > <string in quote or double
quote >.n");
exit (0);
7 }
/* Get the commandline string*/
9 char *name = argv [1];
int i = 0;
11 while (name [i] != NULL )
i++;
13 printf("The length of string is %d", i);
return 0;
15 }
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-14-2048.jpg)
![214 Basic C
1.11.1 Array To Integer
atoi() function is used to convert an array into integer. This function is very useful for
the conversion of number arguments passed as array or pointer into integer value. The
use of syntax is explained in the following example.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (int argc , char *argv [ ]) {
5 if (argv [1] == NULL ) {
printf("Use <utility .exe > <string >.n");
7 exit (0);
}
9 int i;
i = atoi (argv [1]) ;
11 printf("Array to integer is %d.", i);
exit ( EXIT_SUCCESS );
13 }
✌
✆
Without atoi(), we can also convert an array into integer by using simple mathematics
as explained in the following example.
✞
1 #include <stdio.h>
3 int main () {
char intg [ ] = "1234 ";
5 int i = 0, res = 0;
/* Here res must be initialized . Otherwise *
7 *product of res and 10 shall be null value*/
while (intg [i] != ’0’) {
9 /* Product of res with 10. res must not be null .*
* (intg [i] % 48) is used to convert integer *
11 * charcode into integer value. Charcode of 0 is*
* 48. Similarly , charcode of 1 is 49 and so on */
13 res = res * 10 + (intg [i] % 48);
i++;
15 }
printf("%dn", res);
17 return 0;
}
✌
✆
✞
1234
✌
✆
We can also used pointers for array to integer conversion. Above example is modified as
it is given below:
✞
1 #include <stdio.h>
3 int main () {
char *intg = "1234 ";](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-15-2048.jpg)
![1.12. MATHEMATIS 215
5 int i = 0, res = 0;
/* Here res must be initialized . Otherwise *
7 *product of res and 10 shall be null value*/
while (* intg != ’0 ’) {
9 /* Product of res with 10. res must not be null .*
* (intg [i] % 48) is used to convert integer *
11 * charcode into integer value. Charcode of 0 is*
* 48. Similarly , charcode of 1 is 49 and so on */
13 res = res * 10 + (* intg % 48);
intg ++;
15 }
printf("%dn", res);
17 return 0;
}
✌
✆
atoi() function is used to convert an integer array into integer value. Integer value “1234”
as string is stored in memory as a group of characters. Each character is one byte long.
1 2 3 4
i :
Value at byte :
00000001 00000010 00000011 00000100
Integer value “1234” in numeric form is stored in 4 bytes long memory space, allocated
for solely storing of integer.
i :
Num value :
00000000 00000000 00000100 11010010
1234
1.12 Mathematis
In C programming addition, subtraction, multiplication and division mathematical op-
erators can be directly used. Modulus is another mathematical operators that gives the
remainder value. Application of these operators are a + b, a − b, a ∗ b, a/b and a%b
respectively.
✞
#include <stdio.h>
2 #include <string.h>
int a, b;
4
int main (void ) {
6 int a = 5;
int b = 2;
8 int add = a + b;
int sub = a - b;
10 int mul = a*b;
int div = a / b;
12 int mod = a % b;](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-16-2048.jpg)
![216 Basic C
printf("Addition of %d and %d is : %d n", a, b, add);
14 printf("Subtraction of %d and %d is : %d n", a, b, sub);
printf("Multiplication of %d and %d is : %d n", a, b, mul);
16 printf("Division of %d and %d is : %d n", a, b, div);
printf("Modulus of %d and %d is : %d n", a, b, mod);
18 return 0;
}
✌
✆
Output of above program is
✞
Addition of 5 and 2 is : 7
Subtraction of 5 and 2 is : 3
Multiplication of 5 and 2 is : 10
Division of 5 and 2 is : 2
Modulus of 5 and 2 is : 1
✌
✆
A pointer can also be used in the addition, subtraction, multiplication and division of
two or more numbers.
✞
1 #include <stdio.h>
3 func (int *i, int*j) {
*i = *i * *i;
5 *j = *j* *j;
}
7
main () {
9 int i = 5, j = 2;
func (&i, &j);
11 printf("%d %d", i, j);
return 0;
13 }
✌
✆
✞
25, 4
✌
✆
1.12.1 Trigonometric Functions
“math.h” preprocessor file provides the mathematical functions that can be used directly
in the program. Some of them are defined in following sections.
cos, sin & tan
The cos, sin, and tan functions return the cosine, sine, and tangent of the argument,
expressed in radians. The domain of arguments of sin, cos and tan are [−π/2, π/2], [0, π]
and [−π/2, π/2] respectively. The numerical range of sin, cos and tan are [−1, 1], [−1, 1]
and [−∞, ∞].
✞
1 #include <math .h>
double cos(double x);](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-17-2048.jpg)
![218 Basic C
acos, asin & atan
The acos() functions return the arccosine of their arguments in radians, and the asin()
functions return the arcsine of their arguments in radians. All functions expect the
argument in the range [−1, +1]. The arccosine returns a value in the range [0, π]; the
arcsine returns a value in the range
h
−
π
2
,
π
2
i
. The atan() returns their argument value
in radian in the range
h
−
π
2
,
π
2
i
. Method of use of inverse function in following systems.
✞
1 #include <math .h>
double asin (double x);
3 double acos (double x);
double atan (double x);
✌
✆
A simple example is
✞
#include <stdio.h>
2 #include <math .h>
4 int main (void ) {
printf("Arc cosine at argument 0.5 is : %f n", acos (0.5));
6 printf("Arc sine at argument 0.5 is : %f n", asin (0.5));
printf("Arc tangent at argument 1.5 is : %f n", atan (1.5));
8 return 0;
}
✌
✆
✞
Arc cosine at argument 0.5 is : 1.047198
Arc sine at argument 0.5 is : 0.523599
Arc tangent at argument 1.5 is : 0.982794
✌
✆
cosh, sinh & tanh
The cosh(), sinh() and tanh() functions compute the hyperbolic cosine, the hyperbolic
sine and the hyperbolic tangent of the argument respectively.
✞
1 #include <math .h>
double cosh (double x);
3 double sinh (double x);
double tanh (double x);
✌
✆
A simple example is
✞
#include <stdio.h>
2 #include <math .h>
4 int main (void ) {
printf("Hyperbolic cosine of 0.5 is : %f n", cosh (0.5));
6 printf("Hyperbolic sine of 0.5 is : %f n", sinh (0.5));
printf("Hyperbolic tangent of 1.5 is : %f n", tanh (1.5));
8 return 0;](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-19-2048.jpg)
![1.12. MATHEMATIS 231
Contrast to these types of functions, fraction functions diverge to ∞ when x → 0. See
the following limit equation for function y = 1/x,
lim
x→0
y = lim
x→0
1
x
= ∞
Now, it is not possible to use this function with other functions in mathematical op-
erations. To avoid it, we take approaching limit to point ‘0’ of the function as given
below:
lim
x→0
y = lim
x→0
1
x
= ∞; when [−∞, 0) < x < (0, ∞]
x
y
b
(0, 0)
Here, ±∞ is acceptable as 1/ ± ∞ = 0, which is a finite value.
1.12.6 Random Number Generator
Following C program is used to generate random numbers. A user defined seed control
the initial random number and subsequent random numbers are used as seed for next
random number. This program given first five random number against a seed value.
✞
#include <stdio.h>
2 extern void SeedToNew (unsigned int x);
extern int MyRand(void );
4
int main (void ) {
6 int count;
unsigned seed ;
8 printf("Please enter seed .n");
while (scanf("%u", &seed ) == 1) {
10 SeedToNew (seed );
for (count = 0; count < 5; count ++)
12 printf("%hdn", MyRand());
printf("Please enter newSeed (q to quit ):n");
14 }
printf("Done n");
16 return 0;
}
18](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-46-2048.jpg)
![2.1. ARRAY 233
2Array & Pointer
2.1 Array
Arrays in C stores data in a single variable name with an index, also known as a subscript.
It is simply a list or ordered grouping for variables of the same type. Arrays often help a
programmer in organize collections of data efficiently and intuitively. A character array
takes one byte for each character while an integer array takes 4 bytes for one integer.
Other datatypes takes appropriate bytes to stores that data type value.
A B C D E F ‘0’
myStrA
Figure 2.1: Array of first six alphabetic characters stored in memory and pointed by
variable ‘myStrA’.
00000001 00000010
myNumA myNumA[0] myNumA[1]
Figure 2.2: Array of two integers pointed by variable ‘myNumA’ are stored in memory
as shown this figure. Each integer needs four bytes memory space.
2.1.1 Uni-Dimensional Array
Arrays are declared by two ways, (i) static and (ii) dynamic. Static arrays are declared
using square brackets containing size of array. Dynamic arrays are declared with pointers.
In static declaration, compiler creates space required for storing of data at declaration
and then returns the address of memory space created. In case of string, one extra
space for null terminator is also reserved. In case of dynamic declaration only address
of proposed memory space is returned where proposed data may be stored. It does not
reserve memory space. To create memory space, function malloc is used. Note that only
string arrays have terminating marker (0). Other type of arrays must be controlled by
array size. muArrays are declared and initialized like
✞
1 int numbers [6]; // array declared & space created
int point [6]={0 ,0 ,1 ,0 ,0 ,0}; // array declared , space
3 // created and initialized
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-48-2048.jpg)
![234 Array & Pointer
Remember that the initialization of static array is take place alongwith its declaration.
Otherwise initialization of an array shows compile time error.
✞
1 char myS [];
myS="My String"; /* Illegal initialization .*/
3 // Actually , above action was copying of data to
// array , not initialisation . Copying of data done
5 // by copying character one by one in memory space
char myStr []="My String"; /* Legal initialization .*/
✌
✆
Initialisation of array with pointer after declaration is compiler dependent.
✞
#include <stdio.h>
2
int main () {
4 char *c = "This ";
c = "That ";
6 printf("%s", c);
return 0;
8 }
✌
✆
✞
That
✌
✆
The brackets ([ ]) identify ‘numbers’ or ‘points’ and the number enclosed in the brackets
indicates the number of elements in the array. An element of the array can be accessed by
its index number i.e. subscripts of the array. When square bracket symbol in static array
declaration does not contain size of array then it is called dynamic declaration of array.
Dynamic array declaration is permitted if it is initialised at the time of declaration. In
following example, each element of the array is accessed by its index number.
✞
1 #include <stdio.h>
3 int main (void ) {
int ix;
5 short anArray[ ] = {3, 6, 9, 12, 15};
for (ix = 0; ix < ( sizeof (anArray ) / sizeof ( short)); ++ix) {
7 printf("The array value is %d.n", anArray [ix]);
}
9 }
✌
✆
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
Figure 2.3: Head integer value consumes 4 byte memory space. in represents to the index
of elements of array ‘days’. Total bytes of memory used to store data is 5 × 4 = 20.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-49-2048.jpg)
![2.1. ARRAY 235
In the above example, the size of the array was not explicitly specified. The compiler
knows the size of array from the initialized list. The size of ‘anArray’ is ‘5’ because
‘anArray’ has five elements. Addition of an additional element to the list will increase its
size to six. Static declaration of the size of an array, the array list will be overflow. To
overcome this problem sizeof expression is used as
✞
1 size = sizeof(anArray)/ sizeof(short)
✌
✆
As the sizeof expression in the for loop, the script is automatically adjusted to this
change. Designated initializer is allow to pick and choose the initialized elements. If the
last element of an array is initialized then in the initialization syntax of traditional C,
there is a requirement of initialization of every element preceding to the last one. An
array, if initialized, then each element value is index from 0 to n − 1, where n is size of
the array. For example,
✞
1 int count[] = {31, 28, 30, 29, 32, 27}; // array size is 6
✌
✆
has six elements. The element value at index 0 is 31, element value at index 1 is 28 and
so on. The index of array element may be redefined inside the array as the method given
in following syntax
✞
1 /* int count[] = {[<new index >]=< array element value >};*/
int count[] = {31, [2] = 28, 30, 29, 32, 27};
✌
✆
Here, the index of second element is 2, i.e. element shall be stored at third place of
memory of integer data type. Elements of an array are overridable, i.e. new element
value at index 4 can be override the old value of the element at the index 4 if any other
element is assigned the index value 4.
✞
#include <stdio.h>
2 #define MONTHS 12
4 int main (void ) {
int days [MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29};
6 int i;
for (i = 0; i < MONTHS; i++)
8 printf("%2d %dn", i + 1, days [i]);
return 0;
10 }
✌
✆
In above program example, array ‘days’ has first element (at index position 0) 31, second
element (at index position 1) is 28. Next element, 30, of the array ‘days’ is declared for
index 4, i.e. for 5th
position. Next element is 30 in the array ‘days’. Its position shall
be next to the previous element, i.e. after 5th
position, therefore this element will be at
6th
position or at index position 5. Element for index position 6 is 31. Last element is
defined for index position 1. Hence previous element, 28, which was at the index position
1 shall be replaced by value 29. The final arrangement of the array data in the memory
shall be as shown in the below figure.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-50-2048.jpg)
![236 Array & Pointer
i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 i10 i11
31 29 0 0 31 30 31 0 0 0 0 0
days
Figure 2.4: Arrangement of elements of array ‘days’ in memory. Here, each block rep-
resents to an integer data byte (i.e. group of four memory bytes). in represents to the
index of elements of array ‘days’.
✞
1 31
2 29
3 0
4 0
5 31
6 30
7 31
8 0
9 0
10 0
11 0
12 0
✌
✆
An array initialised with ‘[ ]’ is called expandable array. When an array is declared
without its size, compiler first count the array elements and then it grows the array upto
a size so that all the elements can stored in the array.
✞
/* Array with growing size . */
2 int days [ ] = {31, 28, [4] = 31, 30, 31, [1] = 29};
✌
✆
✞
#include <stdio.h>
2
int main (void ) {
4 int days [] = {31, 28, [4] = 31, 30, 31, [1] = 29};
int i;
6 printf("Size of array is %dn", sizeof (days ) / sizeof (int));
/* Here sizeof (days ) / sizeof (int) is not*
8 *grouped as ‘/’ higher precedence to ‘<’ */
for (i = 0; i < sizeof (days ) / sizeof (int); i++)
10 printf("%2d %dn", i , days [i]);
return 0;
12 }
✌
✆
✞
Size of array is 7
0 31
1 29
2 0
3 0
4 31
5 30](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-51-2048.jpg)
![2.1. ARRAY 237
6 31
✌
✆
2.1.2 Multi-Dimensional Array
An array declaration in C is given by
✞
int myA[m][n];/*m rows and n cols .*/
✌
✆
If the size of integer type array is fixed as shown above, compiler reserves m× n× k bytes
memory. Here, k is size of variable data type. For integer it is 4 as integer is 4 bytes long
data type. Hence, memory size allocated for integer array of type m × n is 4mn. Assume
a 2 × 2 integer array as shown below
✞
1 int myA [2][2] = {
{10, 20},
3 {15, 2}
};
✌
✆
The memory allocated for this array is 2 × 2 × 4 = 16 bytes. As column size of this array
is 2, hence 8 bytes are taken in a group for two columns, in which each column uses 4
bytes for storing integer data. Remember that, in following figures, each cell represents
to one byte. This is why, an integer is represented here as a group of four bytes. It is
done, for convenient to calculate the number of bytes required to store an array data.
And in computer, the index counting is started from ‘0’ instead of ‘1’.
10 0 0 0 20 0 0 0
15 0 0 0 2 0 0 0
myA c0 c1
r0
r1
In above figure, the byte position of array data is shown into two rows and two column.
Practically above data is stored in memory as continuous data bytes.
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0
myA
1st
row 2nd
row
1st
col 2nd
col 1st
col 2nd
col
From the above arrangement of data, in a multi-dimensional array, number of rows
may be constant or variable but number of columns must be constant. The reason is
that, elements of an array are arranged one by one sequentially, so if column size is not
fixed then pointer-to-array variable will not be able to identify the starting of next row
of the array. See the example below:](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-52-2048.jpg)
![238 Array & Pointer
✞
#include <stdio.h>
2
int main () {
4 int i;
int myA [2][2] = {/* 2X2X4 =16 bytes */
6 {10, 20},
{15, 2}
8 };
printf("Size of array is %dn", sizeof (myA));
10 char *p = (char *) &myA; // Cast int into char ptr
for (i = 0; i < sizeof (myA); i++) {
12 printf("%d ", p[i]);// print all 16 bytes
}
14 return 0;
}
✌
✆
✞
Size of array is 16
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0
✌
✆
Now, an array having two columns but dynamic rows is declared and assigned as the
syntax is given below:
✞
int myB[ ][2] = {
2 {10, 20},
{15, 2},
4 {1, 4}
};
✌
✆
The memory allocated for this array is dynamic. This array has two columns hence
memory is allocated in the multiple of 2 × 4 = 8 bytes. If there are two rows then
memory allocation will be expanded to 8 × 2 = 16 bytes. Similarly if there are three
rows then memory allocation will be expanded to 8 × 3 = 24 bytes and so on, subject to
memory sharing is not violated.
myA
10 0 0 0 20 0 0 0
15 0 0 0 2 0 0 0
1 0 0 0 4 0 0 0
c0 c1
r0
r1
r2
See the example below:
✞
1 #include <stdio.h>](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-53-2048.jpg)
![2.1. ARRAY 239
3 int main () {
int i;
5 /* Array has fixed cols & dynamic rows */
int myB[ ][2] = {
7 {10, 20},
{15, 2},
9 {1, 4}
};
11 printf("Size of array is %dn", sizeof (myB));
char *p = (char *) &myB;
13 for (i = 0; i < sizeof (myB); i++) {
printf("%d ", p[i]);
15 }
return 0;
17 }
✌
✆
✞
Size of array is 24
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 1 0 0 0 4 0 0 0
✌
✆
An array having two rows and three columns is declared and initialized as shown in the
syntax given below:
✞
int two_d [2][3] = {{ 5, 2, 1 },
2 { 6, 7, 8 }};
✌
✆
Where [2] represents to the number of rows and [3] represents to the number of columns of
the two dimensional array. A three dimensional array is declared as given in the following
syntax:
✞
int myA[ ][3][2];
2 /* | | | *
* l r c */
✌
✆
This array has two columns (y-axis represented as ‘c’ here), three rows (x-axis represented
as ‘r’ here) and variable number of layers (z-axis represented as ‘l’ here). In C programs,
which contains three dimensional array, the z-axis (i.e. third dimension) is always outer-
most loop. Practically, three dimensional array is layers of two dimensional arrays. As
shown in the following figure, a 3 × 2 array is placed in four layers and collectively, they
form a 3 × 2 × 4 three dimensional array.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-54-2048.jpg)
![240 Array & Pointer
l0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l2
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l3
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
A three dimensional array is arranged in patterns as shown in below figure.
myA
l0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
The memory arrangement of three dimensional array is given in the following figure.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
myA
r0 of l0 r1 of l0
c0 of r0 c1 of r0 c0 of r1 c1 of r1
Multi-dimensional array can be used to add, subtract and product (either dot or cross)
of two vectors or matrices. Following is an example using an array of 5 × 5 dimension.
This example requires 5 × 5 × 4 = 100 bytes.
✞
1 #include <stdio.h>
#define X 5
3 #define Y 5
5 int main (void ) {
int ix , iy;
7
short anArray[X][Y]; /* 100 bytes memory requirement .*/
9 for (ix = 0; ix < X; ++ix) {
for (iy = 0; iy < Y; ++iy) {](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-55-2048.jpg)
![2.1. ARRAY 241
11 anArray[ix][ iy] = ix * iy;
};
13 }
for (ix = 0; ix < X; ++ix) {
15 for (iy = 0; iy < Y; ++iy) {
printf("%2dt", anArray[ix][iy]);
17 };
printf("n");
19 }
}
✌
✆
✞
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 4 8 12 16
✌
✆
Multidimentional array can be extended in matrix manipulations, additions, subtractions,
multiplications and divisions. In the following example, two matrices are added and
subtracted element-wise. The element-wise addition and subtraction is given by
Cij = Aij ± Bij
✞
1 #include <stdio.h>
3 /* Random number generator between 0 to 10.*/
int rand_num (int a, int b) {
5 return ((a * 97 + b*21) & 10);
}
7
int main () {
9 int i/* row*/,
j/* col*/;
11 int A [3][3]/* First Matrix*/,
B [3][3]/* Second Matrix*/,
13 C [3][3]/* Third Matrix*/;
printf("First Random Matrix is :n");
15 /* For each of three rows */
for (i = 0; i < 3; i++) {
17 /* There are three columns.*/
for (j = 0; j < 3; j++) {
19 /* Assign a random matrix elements .*/
A[i][j] = rand_num (i*j, j);
21 printf("%3dt", A[i][j]);
}
23 /* Print new line after completion of each row*/
printf("nn");
25 }
printf("nSecond Random Matrix is :n");
27 /* For each of three rows */](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-56-2048.jpg)
![242 Array & Pointer
for (i = 0; i < 3; i++) {
29 /* There are three columns.*/
for (j = 0; j < 3; j++) {
31 /* Assign a random matrix elements .*/
B[i][j] = rand_num (i, i*j);
33 printf("%3dt", B[i][j]);
}
35 /* Print new line after completion of each row*/
printf("nn");
37 }
printf("nElementwise Addition of Matrix is :n");
39 /* For each of three rows */
for (i = 0; i < 3; i++) {
41 /* There are three columns.*/
for (j = 0; j < 3; j++) {
43 /* Add matrices elementwise .*/
C[i][j] = A[i][j] + B[i][j];
45 printf("%3dt", C[i][j]);
}
47 /* Print new line after completion of each row*/
printf("nn");
49 }
printf("nElementwise Subtraction of Matrix is :n");
51 /* For each of three rows */
for (i = 0; i < 3; i++) {
53 /* There are three columns.*/
for (j = 0; j < 3; j++) {
55 /* Subtract matrices elementwise .*/
C[i][j] = A[i][j] - B[i][j];
57 printf("%3dt", C[i][j]);
}
59 /* Print new line after completion of each row*/
printf("nn");
61 }
return 0;
63 }
✌
✆
✞
First Random Matrix is :
0 0 10
0 2 8
0 2 10
Second Random Matrix is :
0 0 0
0 2 10
2 8 2
Elementwise Addition of Matrix is :
0 0 10
0 4 18
2 10 12
Elementwise Subtraction of Matrix is :
0 0 10](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-57-2048.jpg)
![2.1. ARRAY 243
0 0 -2
-2 -6 8
✌
✆
The vector and scalar products between two matrices can also be done. The dot product
of two matrices is given by
Cij = ~
Aij · ~
Bij
In the following example, dot products between to matrices is performed.
✞
#include <stdio.h>
2
/* Random number generator between 0 to 10.*/
4 int rand_num (int a) {
return ((a * 1011457789 + 12345) & 10);
6 }
8 int main () {
int i/* row*/,
10 j/* col*/;
int A [3][3]/* First Matrix*/,
12 B [3][3]/* Second Matrix*/,
C [3][3]/* Dot Matrix */;
14 printf("First Random Matrix is :n");
/* For each of three rows */
16 for (i = 0; i < 3; i++) {
/* There are three columns.*/
18 for (j = 0; j < 3; j++) {
/* Assign a random matrix elements .*/
20 A[i][j] = rand_num (i + j);
printf("%dt", A[i][j]);
22 }
/* Print new line after completion of each row*/
24 printf("nn");
}
26 printf("nSecond Random Matrix is :n");
/* For each of three rows */
28 for (i = 0; i < 3; i++) {
/* There are three columns.*/
30 for (j = 0; j < 3; j++) {
/* Assign a random matrix elements .*/
32 B[i][j] = rand_num (i * j);
printf("%dt", B[i][j]);
34 }
/* Print new line after completion of each row*/
36 printf("nn");
}
38 printf("nDot Product Matrix is :n");
/* For each of three rows */
40 for (i = 0; i < 3; i++) {
/* There are three columns.*/
42 for (j = 0; j < 3; j++) {
/* Elementwise dot product of matrices .*/](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-58-2048.jpg)
![244 Array & Pointer
44 C[i][j] = A[i][j] * B[i][j];
printf("%dt", C[i][j]);
46 }
/* Print new line after completion of each row*/
48 printf("nn");
}
50 return 0;
}
✌
✆
✞
First Random Matrix is :
8 2 2
2 2 0
2 0 8
Second Random Matrix is :
8 8 8
8 2 2
8 2 8
Dot Product Matrix is :
64 16 16
16 4 0
16 0 64
✌
✆
The cross product (vector product) of two matrices is given by
~
C = ~
A × ~
B
✞
#include <stdio.h>
2
/* Random number generator between 0 to 10.*/
4 int newseed =10;
int seed (int a){
6 newseed =newseed+a;
return newseed;
8 }
int rand_num (int a) {
10 seed (a);
return (( newseed * 99991 + 12345) & 10);
12 }
14 int main () {
int i/* row*/;
16 int A[3]/* First Vector */,
B[3]/* Second Vector */,
18 C[3]/* Dot Vector */;
printf("First Random Vector is :n");
20 /* For each of three rows */
for (i = 0; i < 3; i++) {
22 /* Assign a random vector elements .*/
A[i] = rand_num (i);
24 printf("%dt", A[i]);](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-59-2048.jpg)
![2.1. ARRAY 245
}
26 /* Print new line after completion of each row*/
printf("n");
28
printf("nSecond Random Vector is :n");
30 /* For each of three rows */
for (i = 0; i < 3; i++) {
32 /* Assign a random vector elements .*/
B[i] = rand_num (i);
34 printf("%dt", B[i]);
/* Print new line after completion of each row*/
36 }
printf("n");
38
printf("nCross Product Vector is :n");
40 /* For each of three rows */
for (i = 0; i < 3; i++) {
42 /* Elementwise cross product of matrices .*/
C[i] = pow(-1,2* i)* (A[(i+1) %3] * B[(i+2) %3]
44 - B[(i+1) %3] * A[(i+2) %3]) ;
printf("%dt", C[i]);
46 }
/* Print new line after completion of each row*/
48 printf("nn");
50 return 0;
}
✌
✆
✞
First Random Vector is :
10 2 0
Second Random Vector is :
0 10 8
Cross Product Vector is :
16 -80 100
✌
✆
Arrays can be passed to a function as its parameter (argument) as shown in the example
given below:
✞
#include <stdio.h>
2 /*+- Array pointer with **
**| expandable size */
4 void init_array (int a[ ], int count) {
int i;
6 for (i = 0; i < count; i++)
a[i] = i * 10;
8 for (i = 0; i < count; i++)
printf("The a value is %d.n", a[i]);
10 }
12 int main (void ) {
int mydata [10];](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-60-2048.jpg)
![246 Array & Pointer
14 init_array (mydata , 5);
return 0;
16 }
✌
✆
✞
The a value is 0.
The a value is 10.
The a value is 20.
The a value is 30.
The a value is 40.
✌
✆
For multidimensional array, there is no limit of dimension in C. Here, a four dimensional
matrix is represented by
✞
1 int myData [2][3][2][4]
✌
✆
A new dimension in array declaration is always grouped by curly braces. One dimensional
array has one curly braces, i.e. one row. In two dimensional array, there are two one
dimensional rows both separated by comma (,) operator. These two rows are enclosed by
another curly braces. In three dimensional systems of arrays, two 2-dimensional arrays
are placed one over another. In the following example, two, three and four dimensional
arrays are declared.
✞
1 #include <stdio.h>
3 int main () {
char a[2][2] = {
5 // cols
{1, 2}, // row
7 {5, 6} // row
};
9 char b[2][2][2] = {
{
11 // cols
{1, 2}, // row
13 {5, 6} // row
},
15 {// height
{4, 3},
17 {8, 9}
}
19 };
char c[2][2][2][2] = {
21 {
{
23 // cols
{1, 2}, // row
25 {5, 6} // row
},
27 {// height
{1, 2},](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-61-2048.jpg)
![2.1. ARRAY 247
29 {5, 6}
}
31 },
{// time
33 {
{4, 1},
35 {7, 6}
},
37 {
{4, 4},
39 {9, 1}
}
41 }
};
43 int i, j, k, l;
printf("Elements of matrix a are n");
45 for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
47 printf("Element a[%d][%d] is : %dn",
i+1, j+1, a[i][j]);
49 }
}
51 printf("Elements of matrix b are n");
for (i = 0; i < 2; i++) {
53 for (j = 0; j < 2; j++) {
for (k = 0; k < 2; k++) {
55 printf("Element b[%d][%d][%d] is : %dn",
i+1, j+1, k+1, b[i][j][k]);
57 }
}
59 }
printf("Elements of matrix c are n");
61 for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
63 for (k = 0; k < 2; k++) {
for (l = 0; l < 2; l++) {
65 printf("Element c[%d][%d][%d][%d] is : %dn",
i+1, j+1, k+1, l+1, c[i][j][k][l]);
67 }
}
69 }
}
71 return 0;
}
✌
✆
It is an example of the two dimensional matrix in which total and average marks of each
student is calculated.
✞
#include <stdio.h>
2 #define STUDENT 3 // number of STUDENTS
#define SUBJECT 5 // number of SUBJECT](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-62-2048.jpg)
![248 Array & Pointer
4
int main (void ) {
6 // marks of five stus
const float marks[STUDENT ][ SUBJECT ] = {
8 // subs ->
{9.9, 8.0, 8.3, 4.2, 6.0}, // stu row
10 {9.0, 7.0, 7.3, 2.0, 5.0}, // stu row
{9.6, 8.0, 8.8, 2.1, 5.5}, // stu row
12 };
int stu , sub;
14 float subtot , total;
printf("Student Marks (Max 50)n");
16
/* for each stu , sum marks for each sub */
18 total = 0;
for (stu = 0; stu < STUDENT; stu ++) {
20 for (sub = 0, subtot = 0; sub < SUBJECT; sub ++) {
subtot += *(*( marks + stu) + sub);
22 }
printf("%s %d %20.1fn", "Stu", stu + 1, subtot);
24 total += subtot; /* total for all stus */
}
26 printf("nThe student average is %.1f.nn",
total / STUDENT );
28
printf("Subject Average :n");
30 printf("Sub_1 Sub_2 Sub_3 Sub_4 Sub_5n");
32 /* for each sub , sum marks over stus */
for (sub = 0; sub < SUBJECT; sub ++) {
34 subtot = 0;
for (stu = 0; stu < STUDENT; stu ++) {
36 subtot += *(*( marks + stu) + sub);
}
38 printf("%5.1 f ", subtot / STUDENT );
}
40 printf("n");
return 0;
42 }
✌
✆
✞
Student Marks (Max 50)
Stu 1 36.4
Stu 2 30.3
Stu 3 34.0
The student average is 33.6.
Subject Average :
Sub_1 Sub _2 Sub_3 Sub_4 Sub_5
9.5 7.7 8.1 2.8 5.5
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-63-2048.jpg)
![2.1. ARRAY 249
A multidimensional array may also be returned by a function, if function is used as a
pointer. An example for two dimensional array as a returned value of a function is given
below:
✞
#include <stdio.h>
2
int (* myF(int arr [3][3] , int n))[3] {
4 int i, j;
for (i = 0; i < 3; i++) {
6 for (j = 0; j < 3; j++) {
arr[i][j] = i + j;
8 }
}
10 return arr;
}
12
int main () {
14 int arr [3][3];
int (*q)[3] = myF(arr , 3);
16 int i, j;
for (i = 0; i < 3; i++) {
18 for (j = 0; j < 3; j++) {
printf(" %d", q[i][j]);
20 }
printf("n");
22 }
}
✌
✆
✞
0 1 2
1 2 3
2 3 4
✌
✆
2.1.3 Array of Strings
It is very simple to declara an array for integers, float, characters datatypes as they has
fixed size. But, in case of string, declaration of array is complex as size of string, being
stored in array like matrix form, is variable. For example, at a particular cell, we can store
string “me” or string “our”. Here, both words have different size. So, declaration of an
array for string needs special caution and care. Here, we shall discuss about the storing of
string data in an array, starting from one dimensional array to multi-dimensional array.
Suppose we have to store string “This”. We declare array like
✞
1 char myArr [];
✌
✆
Here, ‘[]’ controls the size of declared variable ‘myArr’ as dynamic and memory is allocated
and reallocated by compiler at run time according to the size of input string being stored.
Now, we store string “This” in this array, and appended by null terminator. The memory
data shall be looked like-](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-64-2048.jpg)
![250 Array & Pointer
0×0012 0×0013 0×0014 0×0015 0×0016 0×0017 0×0018 0×0019
myArr
T h i s 0
Figure 2.5:
But what happens if we declare an fixed size one dimensional array as shown below:
✞
1 char myArr [10];
✌
✆
It means, above array may store only 10 characters including null terminator.
✞
1 #include <stdio.h>
#include <string.h>
3
int main () {
5 char myArr[]="This ";
printf("String is ’%s ’n",myArr);
7 return 0;
}
✌
✆
✞
String is ’This ’
✌
✆
If we try to store string of size more than 10 characters, data shall be overflow. From
figure 2.5, it is seen that each character of string ‘This’ is column of one row vector.
Therefore, when we declare a two dimensional array, one new parameter is required for
rows of the array alongwith other size of string parameter.
✞
1 char myArr[<rows >][< string size in each row >]
✌
✆
For example, an array
✞
1 char myArr [3][5]
✌
✆
tells us that, there are three rows and each row may store strings of five characters
including null terminator. Note that, the declaration parameter ‘[<string size in each
row >]’ is required only at the time of array declaration. When storing and retrieving of
strings, we just ignore it or just replace it by ‘[0]’ only.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-65-2048.jpg)
![2.1. ARRAY 251
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
i s 0
m y 0
0×0312 0×0313 0×0314 0×0315 0×0316
p e t 0
myArr[0]
myArr[1]
myArr[3]
Figure 2.6:
✞
1 #include <stdio.h>
#include <string.h>
3
int main () {
5 char myArr [4][5]={ "This ","is","my","pet"};
printf("String is ’%s ’n",myArr[0]) ;
7 printf("String is ’%s ’n",myArr[1]) ;
printf("String is ’%s ’n",myArr[2]) ;
9 printf("String is ’%s ’n",myArr[3]) ;
return 0;
11 }
✌
✆
✞
String is ’This ’
String is ’is ’
String is ’my ’
String is ’pet ’
✌
✆
Note that, a string variable is pointer of itself and points to address where data is stored.
So, use of ‘&’ symbol is optional. It also points to the address of first character of string,
so use of ‘[0]’ is also optional. So that, ‘myArr’ and ‘myArr[0]’ both return the string
‘This’.
✞
#include <stdio.h>
2 #include <string.h>
4 int main () {
char myArr [4][5]={ "This ","is","my","pet"};
6 printf("String is ’%s ’n",myArr);
printf("String is ’%s ’n",myArr[1]) ;
8 printf("String is ’%s ’n",myArr[2]) ;
printf("String is ’%s ’n",myArr[3]) ;
10 return 0;
}
✌
✆
✞
String is ’This ’](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-66-2048.jpg)
![252 Array & Pointer
String is ’is ’
String is ’my ’
String is ’pet ’
✌
✆
We can also declare an array that is arranged in rows and columns and each column is of
fixed size for storing of strings.
✞
char myArr[<rows >][< cols >][< string size >]
✌
✆
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0017 0×0018 0×0019 0×0020 0×0021
T h a t 0
i s 0 w a s 0
m y 0 m y 0
0×0312 0×0313 0×0314 0×0315 0×0316
p e t 0
0×0317 0×0318 0×0319 0×0320 0×0321
p e n 0
myArr[0][0]
myArr[1][0]
myArr[3][0]
myArr[0][1]
Figure 2.7:
See the example below:
✞
1 #include <stdio.h>
#include <string.h>
3
#define ROWS 4
5 #define COLS 2
#define STRING_SIZE 5
7
int main () {
9 char myArr[ROWS ][ COLS ][ STRING_SIZE ] = {
{"This ", "That "},
11 {"is", "was"},
{"my", "my"},
13 {"pet", "pen"}
};
15 int i;
printf("Data matrix is : n");
17 for (i = 0; i < ROWS ; i++) {
printf("%5s t %5sn", myArr[i][0], myArr[i][1]);
19 }
return 0;
21 }
✌
✆
✞
Data matrix is :
This That
is was](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-67-2048.jpg)
![2.1. ARRAY 253
my my
pet pen
✌
✆
We can add new strings in this array by using strcpy function by indicating the address
of matrix cell.
✞
1 /*At fifth row , first column */
strcpy(arr [4][0] , "Hi");
3 /*At fifth row , second column*/
strcpy(arr [4][1] , "His");
✌
✆
While we use scanf function to add user’s input from input stream, we should exactly
known to the address of memory byte where data is to be stored.
✞
#include <stdio.h>
2 #include <string.h>
4 #define ROWS 5
#define COLS 2
6 #define STRING_SIZE 5
8 int main () {
char myArr[ROWS ][ COLS ][ STRING_SIZE ] = {
10 {"This ", "That "},
{"is", "was"},
12 {"my", "my"},
{"pet", "pen"}
14 };
int i;
16 printf("Enter data for 5th row 1st column :");
scanf("%s", myArr [4][0]) ;
18 printf("Enter data for 5th row 2nd column :");
scanf("%s", &myArr [4][1][0]) ;/* last [0] is optional */
20 printf("Data matrix is : n");
for (i = 0; i < ROWS ; i++) {
22 printf("%5s t %5sn", myArr[i][0], myArr[i][1]);
}
24 return 0;
}
✌
✆
✞
Enter data for 5th row 1st column :hi
Enter data for 5th row 2nd column :his
Data matrix is :
This That
is was
my my
pet pen
hi his
✌
✆
We can also declare a static multidimensional array by using pointers. It is declared as](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-68-2048.jpg)
![254 Array & Pointer
✞
char * myArr[<rows >]
✌
✆
Data should be assigned at the time of declaration. Pointer character ‘*’ is responsible
for dynamic allocation of memory of suitable size so that assigned data is stored in the
array. See the example below:
✞
1 #include <stdio.h>
3 int main () {
/* Static array declaration */
5 char * myArr[2] = {"This ", "is"};
printf("First row string is : %sn", myArr[0]) ;
7 printf("Second row string is : %s", myArr[1]) ;
return 0;
9 }
✌
✆
✞
First row string is : This
Second row string is : is
✌
✆
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0112 0×0113 0×0114 0×0115 0×0116
i s 0
myArr[0]
myArr[1]
Here, two strings have static storage prior to the program startup. In the initializer, the
arrays are converted to pointers to char and the words array is initialized with the pointer
values. It can not be modified during the program run. It has its own advantages as we
can access to character of string by using pointers.
✞
#include <stdio.h>
2
int main () {
4 char * myArr[3] = {"This ", "is"};
printf("First row string is : %sn", myArr[0]) ;
6 printf("Same from index 1 is : %s n", (myArr [0]+1));
return 0;
8 }
✌
✆
✞
First row string is : This
First row string from index 1 is : his
✌
✆
Here, ‘myArr[0]+1’ means pointer points to the first row string at index ‘0’ and pointer
position is changed by one character position rather than next row.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-69-2048.jpg)
![2.1. ARRAY 255
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0112 0×0113 0×0114 0×0115 0×0116
i s 0
myArr[0]+1
myArr[1]
Using pointer, we can access whole string or its part of string. For example, ‘*myArry’
is the same as myArry[0]. ‘(*myArry)[0]’ is the same as **myArry, which is the first
character of the string and not the address of the string.
✞
#include <stdio.h>
2
int main () {
4 char * myArr[2] = {"This ", "Home "};
printf("For ’This ’ : %sn", myArr [0]) ;
6 printf("For ’Home ’ : %sn", myArr [1]) ;
/* Address of ’This ’ pointed by * myArr and*
8 *it points to address of character ’T’ */
printf("For ’This ’ : %sn", *myArr);
10 /* Dereference to pointer that is pointing *
*to address where string ’This ’ is stored. *
12 *Pointer points to location of character ’T ’.*/
printf("For ’T’ : %c n", ** myArr);
14 /* same as above*/
printf("For ’T’ : %c n", (* myArr)[0]) ;
16 /* Dereference to pointer that is pointing *
*to address where string ’This ’ is stored.*
18 *Pointer in incremented by one , and now , *
*it points to location of character ’h ’. */
20 printf("For ’h’ : %c n", (* myArr)[1]) ;
/* same as above*/
22 printf("For ’h’ : %c n", *(* myArr +1));
return 0;
24 }
✌
✆
✞
For ’This ’ : This
For ’Home ’ : Home
For ’This ’ : This
For ’T’ : T
For ’T’ : T
For ’h’ : h
For ’h’ : h
✌
✆
2.1.4 Array in Function
In functions arguments are passed to it as value unless the function needs alter the
argument. If function needs update the argument, argument should be passed to function
as its argument. Arrays can also passed to functions as pointers. If an array is passed to](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-70-2048.jpg)
![256 Array & Pointer
the function, function would have to allocate enough space to hold a copy of the original
array and then copy all the data from the original array to the new array. It is much
quicker to pass the address of the array rather than array itself and have the function
work with the original data. Prototype for the passing of an array to the function is
✞
1 int sum(int arr[ ])
/*Or*/
3 int sum(int *arr)
✌
✆
sum()
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
S
Figure 2.8: Passing of address of array to sum() function. Array is pointed by the
pointer/variable ‘anArray’.
In C, array parameters are always treated as pointers. C compilers do not check the
size of the array passed to the function hence for good programming, the function should
know the limits of actions on the array. This is why a new parameter of array size as ‘n’
is passed to the function as
✞
1 int sum(int arr[ ], int n)
✌
✆
sum()
for(i=0; i<n; i++){
S += anArray[i];
}
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
n
S
Figure 2.9: Passing of address of array as well as element size of the array to sum()
function. Array is pointed by the pointer/variable ‘anArray’.
Because the name of an array is the address of the first element, an actual argument of
an array name requires that the matching formal argument be a pointer. In this context
int arr[ ] to mean the same as the int * arr. First bracket in the multidimensional array
may be empty or not but other brackets should contains the valid integers for the size of
the array dimension. For example](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-71-2048.jpg)
![2.1. ARRAY 257
✞
1 int sum(int arr[ ][ ], int rows ); // faulty declaration
✌
✆
is a faulty declaration. Recall that the compiler converts array notation to pointer no-
tation. It means, that arr[1] will become arr+1. For the compiler to evaluate this, it
needs to know the size of object to which ‘arr’ points. The declaration
✞
1 int sum2 (int arr[ ][4], int rows ); // valid declaration
✌
✆
says that ‘arr’ points to an array of four integers, so ‘arr+1’ means “add 16 bytes to the
address”. If first bracket contains a number then it will be ignored.
✞
1 int sum2 (int ar [3][4] , int rows ); // valid declaration , 3 ignored
✌
✆
✞
1 #include <stdio.h>
#define ROWS 3
3 #define COLS 4
int sum(int rows , int cols , int ar[rows ][ cols ]);
5
int main (void ) {
7 int i,j;
int varr [ROWS ][ COLS ];
9 for (i = 0; i < ROWS ; i++)
for (j = 0; j < COLS ; j++)
11 varr [i][j] = i * j + j;
printf("3x4 Array n");
13 printf("Sum of all elements = %dn",
sum(ROWS , COLS , varr ));
15 return 0;
}
17 int sum(int rows , int cols , int ar[rows ][ cols ]) {
int r;
19 int c;
int tot = 0;
21 for (r = 0; r < rows ; r++)
for (c = 0; c < cols ; c++)
23 tot += ar[r][c];
return tot;
25 }
✌
✆
✞
3x4 Array
Sum of all elements = 36
✌
✆
An array can passed to a function by using function prototype as shown in syntax given
below:
✞
#include <stdio.h>
2
void PrintIt (char Str[ ]) {
4 printf("%sn", Str);](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-72-2048.jpg)
![258 Array & Pointer
}
6
int main () {
8 char label[ ] = "Allora Caves.";
PrintIt (label);
10 return 0;
}
✌
✆
The output is
✞
Allora Caves.
✌
✆
Function PrintIt() expects a character array. When an array is declared as the
parameter to a function, it really gets a pointer. Arrays are always automatically passed
by reference. Similarly a pointer can also pass to a function as an array or as a pointer.
✞
1 #include <stdio.h>
3 void PrintIt (char Str[ ]) {
printf("%sn", Str);
5 }
7 int main () {
char * label = "Allora Caves.";
9 PrintIt (label);
return 0;
11 }
✌
✆
The output is
✞
Allora Caves.
✌
✆
✞
1 #include <stdio.h>
3 void PrintIt (char *Str) {
printf("%sn", Str);
5 }
7 int main () {
char * label = "Allora Caves.";
9 PrintIt (label);
return 0;
11 }
✌
✆
The output is
✞
Allora Caves.
✌
✆
Unfortunately, (in C and C++) the length of the array cannot be obtained from an
array passed to a function at run time, because the size of an array is not stored anywhere.
The compiler always replaces sizeof () with a constant. See the following example](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-73-2048.jpg)
![2.1. ARRAY 259
✞
1 #include <stdio.h>
#include <string.h>
3
#define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
5
int sum(int input_array [ ]) {
7 int sum_so_far = 0;
int i;
9 /* Would NOT Work ; input_array was*
*not defined in this function . */
11 for (i = 0; i < NUM_ELEM (input_array ); i++){
sum_so_far += input_array [i];
13 };
return ( sum_so_far );
15 }
17 int main (int argc , char *argv [ ]) {
int left_array [ ] = {1, 2, 3};
19 int right_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
int the_sum = sum(left_array );
21 printf("the sum of left_array is: %d n", the_sum );
the_sum = sum(right_array );
23 printf("the sum of right_array is: %d n", the_sum );
25 return 0;
}
✌
✆
When this example is run, it gives output as shown below
✞
the sum of left _array is 1
the sum of right_array is 10
✌
✆
whatever the values are passed as argument in the sum function. This ‘sum()’ routine
needs to handle more than just one constant length of an array. There are some common
ways to work around this fact:
1. Write the function as required, for each array parameter and parameter “length”
which has type “size t”. We can use sizeof () at the point where this function is
called.
2. Use of a null-terminated string to mark the end of the array if array is string. Arrays
representing to numbers does not need the null-terminating string to mark of the
end of array. Instead it, number arrays are passed to the function along with its
element size.
3. Pass the arrays as well as array length parameter to the function. We can pass
the pointer-to-array if required. Evaluate the data as per rules set by function
statements or expressions.
Using these facts, above example is now modified as given below.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-74-2048.jpg)
![260 Array & Pointer
✞
#include <stdio.h>
2
#define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
4
int mySum(int array[ ], size_t length) {
6 int sum = 0;
int i;
8 for (i = 0; i < length; i++) {
sum += array[i];
10 };
return ( sum);
12 }
14 int main (int argc , char *argv [ ]) {
int sum;
16 int i_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
/* Works here , because the size of right_array *
18 *is passed to the sum function as argument */
sum = mySum(i_array , NUM_ELEM (i_array ));
20 printf("The sum is : %d.n", sum);
22 return 0;
}
✌
✆
Output of above example is
✞
the sum is : 55
✌
✆
The same method of passing an array to a function and getting sum of all array element
is also possible with other number datatypes. Above example is suitable modified for array
contains floating type numbers.
✞
1 #include <stdio.h>
3 #define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
5 /* Function returns floating data . So mySum()*
*should be declared as floating data type . */
7 float mySum(float in_array [ ], size_t length) {
float sum = 0;
9 int i;
for (i = 0; i < length; i++) {
11 sum += in_array [i];
};
13 return ( sum);
}
15
int main (int argc , char *argv [ ]) {
17 float sum;
float array[ ] = {10.10 , 50.50 , 4.57, 1.21};
19 sum = mySum(array , NUM_ELEM (array));](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-75-2048.jpg)
![2.1. ARRAY 261
printf("The sum is : %fn", sum);
21 return 0;
}
✌
✆
✞
The sum is : 66.379997
✌
✆
It’s worth mentioning that sizeof () operator has two variations: sizeof (type) and sizeof (<expression>).
An example using sizeof () function to a pointer is shown below.
✞
1 #include <stdio.h>
#include <string.h>
3
int main (int argc , char *argv [ ]) {
5 char buffer [10];
if (argc < 2) {
7 fprintf (stderr , "USAGE: %s stringn", argv [0]) ;
return 1;
9 }
strncpy (buffer , argv [1], sizeof ( buffer));
11 buffer[sizeof (buffer) - 1] = ’0 ’;
return 0;
13 }
✌
✆
Output of the script is
✞
USAGE: executable .exe string
✌
✆
2.1.5 String As Array
C has no built in string handling facilities. Consequently, string is defined as array of
characters. C allows a character array to be represented by a character string rather than
a list of characters, with the null terminating character, automatically added to the end.
Example of string array is shown below.
✞
1 char s[ ] = {’A’, ’p’, ’p’, ’l’, ’e’, ’s’, ’0’};
✌
✆
A p p l e s 0
s
Figure 2.10: Array of characters constructing word ‘Apples’ is stored in memory and
pointed by variable ‘s’.
Normally size of string array is controlled at initialisation. An string array can store only
the number of characters upto its length. Rest of the characters are ignored. In following
example only ten characters will be stored in the string array ‘mystr’.](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-76-2048.jpg)
![262 Array & Pointer
✞
1 char mystr [10] = "Apple is red.";
✌
✆
It is convenient to let the compiler determine the array size. If one omits the size in an
initializing declaration, the compiler determines the size for supplied string. In following
example, compiler set the string length of thirteen characters.
✞
1 char mystr[ ] = "Apple is red.";
✌
✆
A pointer notation may aslo be set up to represent a string. In pointer notation, above
example will be look like
✞
1 const char *ptrstr = "Delhi";
✌
✆
D e l h i 0
ptrstr
Figure 2.11: Character array ‘Delhi’ stored in memory. ‘ptrstr’ points to the character
array ‘Delhi’.
Both declarations amount to saying that ‘ptrstr’ is a pointer to the indicated string.
Strings as array or pointer, are same but only the pointer version can use the increment
operator while array version does not support increment operator. To create an extra long
string, string is splitted into multiple sections, by closing the first section with a quote,
and recommencing the string on the next line (also starting and ending in a quote):
✞
1 char string[ ] = "This is a very , very long "
"string that requires two lines.";
✌
✆
See the example below
✞
#include <stdio.h>
2
int main () {
4 char ch;
char string[ ] = "Two lines "
6 "string.";
int i = 0;
8 while (string[i] != ’0’) {
ch = string[i];
10 printf("%c.", ch);
i++;
12 }
return (0);
14 }
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-77-2048.jpg)
![2.1. ARRAY 263
✞
T.w.o. .l.i.n.e.s. .s.t.r.i.n.g...
✌
✆
When an array is assigned the characters to get the string, there must be a terminating
null character. Otherwise there shall be garbage output. For example following syntax
has no terminating null character. It is not in standard format.
✞
1 char a[10];
a[0]= ’a’;
3 a[1]= ’r’;
a[2]= ’u’;
✌
✆
This format should be like
✞
char a[10];
2 a[0]= ’a’;
a[1]= ’r’;
4 a[2]= ’u’;
a[3]= ’0’;
✌
✆
See following two examples, in which string is terminating without and with null character.
First example gives garbage output (see below).
✞
1 #include <stdio.h>
3 int main () {
char a[10];
5 a[0]= ’a’;
a[1]= ’r’;
7 a[2]= ’u’;
printf("%s",a);
9 return 0;
}
✌
✆
✞
<garbage output >
✌
✆
In this second example, string is terminated with null character. This example gives
output what we required.
✞
1 #include <stdio.h>
3 int main () {
char a[10];
5 a[0]= ’a’;
a[1]= ’r’;
7 a[2]= ’u’;
a[3]= ’0’;
9 printf("%s",a);
return 0;
11 }
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-78-2048.jpg)
![264 Array & Pointer
✞
aru
✌
✆
Size of static array should be larger by one to the original data size being stored in the
array. This extra byte is for NULL terminator, i.e. 0. To store one byte data, array size
should be larger than one. For storing n byte data, array size should be > n. Here two
examples are given. In first example, array size is equal to the data size and in second
example, array size is larger than data size by one. This extra one byte is used to store
null terminating character.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (void ) {
5 /* Deficient static array *
* size declared as char c.*/
7 char c[1];
printf("Enter char ’e’ : ");
9 gets (c);
if (( strcmp(c, "e") == 0))
11 printf("%sn", c);
return 0;
13 }
✌
✆
On compilation, it gives error while following example gives desired output.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (void ) {
5 /* Suficient static array *
* size declared as char c.*/
7 char c[2];
printf("Enter char ’e’ : ");
9 gets (c);
if (( strcmp(c, "e") == 0))
11 printf("%sn", c);
return 0;
13 }
✌
✆
✞
e
✌
✆
In first example, array ‘c’ can store only character ‘c’. There is no extra space to store
null terminating character. It makes that array ‘c’ does not hold string in proper format.
In second example, array ‘c’ can store one character as well as null terminating character.
By this way it holds string in proper format.
2.1.6 Size of Array
C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated
at run-time). The length of a dynamic array cannot be acquired from the array itself -](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-79-2048.jpg)
![2.1. ARRAY 265
its length must be stored elsewhere. The size of static array is computed as
✞
1 int length = sizeof(<array name >) / sizeof(<array element >);
✌
✆
Preprocessor ways for array length is defined as
✞
1 #define ARRAY_LENGTH (A) (sizeof(A) / sizeof(A[0]) )
✌
✆
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
n
Figure 2.12: Size of ‘anArray’ is the number of elements pointed by ‘anArray’. Here
remember that array is of integer type, hence each element shown in this figure needed
4 bytes long memory space. There are 5 elements in this array, so size of ‘anArray’ is 5
(n = 5) and these elements needed 5 × 4 = 20 bytes long memory space.
Array becomes pointer when it is passed as a parameter to a function. Thus, the length of
an array parameter may not require directly but a dedicated length parameter is required
and should be passed to the function. See the following example is given string array
‘fruit’ is declared with static size of 2 elements in each row while each row is pointed by
‘fruit’ pointer itself. Hence the element size is fixed so, there is no need to calculate the
length size of array. But in this example, length is computed by using above syntax.
✞
1 #include <stdio.h>
3 int main (){
const char *fruit[2] = { "apples", "oranges" };
5
/* Length of the array by dividing *
7 *the size of all elements by the*
*size of the first element. */
9
int length = sizeof(fruit) / sizeof(fruit[0]) ;
11
printf("%dn", length);
13
return 0;
15 }
✌
✆
✞
2
✌
✆
In above example, length of the array is obtained by dividing the size of all elements
(found with sizeof (fruit)) by the size of the first element. Note that since the array
elements are pointers to null-terminated character arrays, the size of the first element is
actually the size of the pointer type - not the length of the string. This size, regardless
of the type being pointed to, is 8 bytes, 4 bytes, or 2 bytes on 64-bit, 32-bit, or 16-bit](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-80-2048.jpg)
![266 Array & Pointer
platforms respectively. Pointer can be used for variable size array as shown in example
below.
✞
1 #include <stdio.h>
/* Variable size array.*/
3 char *name ;
int main () {
5 name ="My School!!";
int i=0;
7 while(name [i] !=’0 ’){
printf("%cn",name [i]);
9 i++;
}
11 return 0;
}
✌
✆
✞
M
y
S
c
h
o
o
l
!
!
✌
✆
2.1.7 Vector & Matrix
Vector is a one dimensional array or a matrix having one rows and multiple columns. A
vector is represented by A = [1, 2, 3, 5]. A matrix is vertical arrangement of vectors. Vec-
tors are one dimensional arrangement of coefficients of variables of an algebraic equation.
Let an algebraicequation ax + by = k, that is written as
ax + by − k = 0
Now, vector u for this algebraic equation is given by
u = [a, b, −k]
If there is a set of two algebraic equations,
ax + by − k = 0
cx + dy − l = 0
Then two vectors of these two algebraic equations are u and v respectively as
u = [a, b, −k]; v = [c, d, −l]](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-81-2048.jpg)
![2.1. ARRAY 267
The matrix arrangement like AX = B is
a b −k
c d −l
x
y
1
=
0
0
Here, matrix A is row arrangement of two vectors u and v. Similarly, for example, vectors
A = [1, 2, 3, 5] and B = [5, 4, 3, 2] form a matrix when these vectors are arranged vertically.
C =](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-82-2048.jpg)
![Here, C is a 2 × 4 matrix. A one dimensional vector is defined in C like
✞
#include stdio.h
2
int main (void ) {
4 int A[5];
int i;
6 for (i = 1; i 5; i++) {
A[i] = i;
8 }
for (i = 1; i 5; i++) {
10 printf(%dt, A[i]);
}
12 return 0;
}
✌
✆
✞
1 2 3 4
✌
✆
A matrix is defined in C like
✞
1 #include stdio.h
3 int main (void ) {
int A [2][5];
5 int i, j;
for (i = 0; i 2; i++) {
7 for (j = 0; j 4; j++) {
A[i][j] = i + j;
9 }
}
11 for (i = 0; i 2; i++) {
for (j = 0; j 4; j++) {
13 printf(%dt, A[i][j]);
}
15 printf(nn, A[i][j]);
}
17 return 0;
}
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-90-2048.jpg)
![268 Array Pointer
✞
0 1 2 3
1 2 3 4
✌
✆
In C, arrays, vectors and matrices are defined in same ways.
2.1.8 Sparse Matrix
A sparse matrix is one which have majority number of zeros along rows and columns. For
example a sparce matrix is
S =
0 0 0 0 0
0 1 2 0 1
0 2 1 0 2
0 0 0 0 0
0 1 2 0 1
C program for sparse matrix is given below:
✞
1 #include stdio.h
#include time .h
3
int main () {
5 time_t t1 , t2;
t1 = time (NULL );
7 static int array [10][10];
int i, j, m = 5, n = 5;
9 int counter = 0;
for (i = 0; i m; ++i) {
11 for (j = n; j 0; --j) {
t2 = time (NULL );
13 array[i][j] = (i * j + t2) % (t1 % 5 + 1);
if (array[i][j] == 0) {
15 ++ counter ;
}
17 }
}
19 printf(Matrix is : n);
for (i = 0; i m; ++i) {
21 for (j = 0; j n; ++j) {
printf(%dt, array[i][j]);
23 }
printf(n);
25 }
if (counter ((m * n) / 2)) {
27 printf(Matrix is sparse matrix n);
} else {
29 printf(Matrix is not a sparse matrix n);
}
31 printf(There are %d number of zeros.n, counter );](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-91-2048.jpg)
![270 Array Pointer
In which, each memory cell or memory location is identified by its address and it
contains a value. See an example given below. Read program line-by-line alongwith
comments carefully.
✞
#include stdio.h
2 int main (){
/*i points to memory location where 10 is stored. */
4 int i=10;
6 /* Pointer j points to a random address */
int *j;
8
/* Now j points to same address as i is pointing . */
10 j=i; // i and j points to same address.
12 /*j stored value at its address.*/
*j=20;
14
/*As i and j points to same memory location *
16 *( addresses ) therefore , values of i and j *
*are equal. So , i = 20. */
18 printf(%d,i); //i has same value as j;
return 0;
20 }
✌
✆
✞
20
✌
✆
An array name is also the address of the first element of the array. That is, if ‘arr’ is an
array, then
✞
1 arr == arr [0]; // name of array is the
// address of the first element
✌
✆
Both ‘arr’ and ‘arr[0]’ represent the memory address of first element of the array. It is
also called the reference of the array ‘arr’. A pointer can points to any element of the
array, if the pointer is assigned address of that element. In the following example, pointer
‘x’ points to the address of first element of the array ‘i’.
✞
#include stdio.h
2
int main () {
4 int i[5] = {10, 20, 30, 40, 50};
int *x = i[0]; /* Points to first element.*/
6 printf(%d, *x);
return 0;
8 }
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-93-2048.jpg)
![2.2. POINTER 271
0×10
10
0×11
20
0×12
30
0×13
40
0×14
50
i[ ]
x
The output of above program shall be
✞
10
✌
✆
If above example is modified as given below, then the pointer ‘x’ points to the 3rd
element of the array ‘i’.
✞
1 #include stdio.h
3 int main () {
int i[5] = {10, 20, 30, 40, 50};
5 int *x = i[2]; /* Points to third element.*/
printf(%d, *x);
7 return 0;
}
✌
✆
0×0
10
0×1
20
0×2
30
0×3
40
0×4
50
i[ ]
x
The output of above program shall be
✞
30
✌
✆
If an integer is pointed by a pointer-to-char variable, then this variable can points to
the address of each byte of the integer variable (integer variable is 4 bytes long).
✞
1 #include stdio.h
3 int main () {
/* 1000 D = 1111101001 B*/
5 int i = 1001;
/* Pointer casting from integer to character .*/
7 char *x = (char *) i;
/* Little endian is x[0]=11101001 B*
9 *Big endian is x[1]=00000011 B*
*Big endian x[2]= x[3]=00000000 B*/
11 /* Print little endian x[0]*/
printf(%d, (int) x[0]) ;
13 return 0;
}
✌
✆](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-94-2048.jpg)
![272 Array Pointer
x[3] x[2] x[1] x[0]
i:
x
00000000 00000000 00000011 11101001
Output of above program is
✞
-23
✌
✆
✞
1 #include stdio.h
3 int main () {
/* 1000 D = 1111101001 B*/
5 int i = 1001;
/* Pointer casting from integer to character .*/
7 char *x = (char *) i;
/* Little endian is x[0]=11101001 B*
9 *Big endian is x[1]=00000011 B*
*Big endian x[2]= x[3]=00000000 B*/
11 /* Print big endian x[1]*/
printf(%d, (int) x[1]) ;
13 return 0;
}
✌
✆
x[3] x[2] x[1] x[0]
i:
x
00000000 00000000 00000011 11101001
Output of above program is
✞
3
✌
✆
Though, the pointers allow increment and decrement operations but they are not
preferred over indexed arrays when there is requirement of random access. In indexed
arrays, fifth element can be accessed by myArr[4]. But in pointer array, we have to
first reach at the address of fifth element by using pointer increments or decrements
operations and then dereference the pointer. So, pointer requires extra coding to reach
at desire destination.
Identification of Pointer Type We know that, in C, a variable is declared as
✞
1 datatype var name ;
✌
✆
There are three main form of variable object declarations. (i) normal variables, (ii) arrays
and (iii) functions. Their prototypes are respectively](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-95-2048.jpg)
![2.2. POINTER 273
✞
1 int i; // normal variable
int k[10]; // array variable
3 int f(); // function variable
✌
✆
In above three declarations, priority is observed to identify the type of variable. In first
case, variable ‘i’ is normal integer type variable which stores integer values. It means
where ever it stores a value, it will be an integer. Priority of variable literal is lower
than square brackets or parentheses. A variable is followed by square brackets, then it is
treated as an array. Similarly, if a variable is followed by parentheses, then it is treated
as function. Now, the question is, how we identify the nature of variable when asterisk is
prefixed to variable literals to make it pointer variable as shown below:
✞
1 int *i;
int *k[10];
3 int *f();
✌
✆
Its answer is again priority listing. The priority of pointer symbol (asterisk) is less than
array symbol or parentheses. Hence first declaration is pointer to integer. In second
declaration, priority of variable ‘k’ goes with array symbol and asterisk makes it pointers.
Hence, it will be pronounce as “array k of pointers-to-integers”. Note that, datatype only
told about the type of data pointed by the pointers, not about the type of pointer itself.
Similarly, third declaration is “function which returns a pointer pointing-to-an-integer
value”. Remember, array always stores values and function always returns a value. Now,
parentheses are used to change the priority of asterisk like
✞
1 int *i;
int (*k)[10];
3 int (*f)();
✌
✆
The first declaration has no change. It is pointer to an integer. In second declaration,
priority of asterisk goes with ‘k’. Hence it is pronounce as “pointer ‘k’ to an array (due
to presence of square bracket) of integers (array stores integer type values)”. Similarly
third declaration is pronounced as “pointer ‘f’ points to a function (due to presence of
parentheses) which returns an integer value”. So, be careful while using pointers with
specific priorities. There is not change in the priority if data type is changed. For example,
only stored value at pointee address is changed to real (double data type) from integer if
above declaration is modified as
✞
1 double *i;
double (*k)[10];
3 double (*f)();
✌
✆
2.2.1 Declaring pointers
When a variable name is preceded by asterisk symbol during its declaration, it is called
pointer variable. In the following variable declarations:](https://image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-96-2048.jpg)
![210 Basic C
#endif
11 #endif /* SUM_H */
✌
✆
Codes of sum function is define in the file ‘sum.c’.
✞
1 /* sum_f() function for adding two numbers */
int sum_f(int a, int b) {
3 int c;
c = a + b;
5 return c;
}
✌
✆
Main function for calling a procedure is defined in ‘main.c’ file as
✞
#include <stdio.h>
2 /* sum.h header contains sum_f() function *
* that should be indentified and called. */
4 #include "sum.h"
6 int main (void ){
int a=2,b=3;
8 /* sum_f() function is called from *
*sum.c and identified via sum.h */
10 int c=sum_f(a,b);
printf("The sum of 2 and 3 is %d.",c);
12 return 0;
}
✌
✆
When program is compiled and run the output is
✞
The sum of 2 and 3 is 5.
✌
✆
If a macro produces multiple statements, or declares variables, it can be wrapped in
a do { ... } while(0) loop, with no terminating semicolon. This allows the macro to be
used like a single statement in any location.
✞
1 #define FREE (p) free (p); p = NULL ; /* Bad practice .*/
#define FREE (p) do { free (p); p = NULL ; } while(0) /* Good
practice .*/
✌
✆
1.10.7 Type Converter
Following is an example of string to integer conversion.
✞
#include <stdio.h>
2 #include <string.h>
4 int main (int argc , char *argv [ ]) {
char st [10] = "This ";
6 printf("String ’%s’ = integer %d.n", st , (int) st);](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-11-2048.jpg)
![1.11. PARSING ARGUMENTS 211
return 0;
8 }
✌
✆
✞
String ’This ’ = integer 2280640.
✌
✆
1.11 Parsing Arguments
When a program is being executed via another program internally, arguments are required
to be passed to the executable ie the program. These arguments are considered as inputs
for the executable. To pass the values we define main() function as
✞
1 int main (int argc , char *argv [ ])
✌
✆
Here argc counts the number of arguments in an array and argv assigns the values to
each respective counter.
✞
1 #include <stdio.h>
#include <string.h>
3 #include <stdlib.h>
5 /* main function is modified according to*
*receive the arguments in command line */
7 int main (int argc , char *argv [ ]) {
int argnum = 0;
9 /* Starting from zero */
while (argc > ++ argnum)
11 printf("Argument %d of arguments %d is %c.n",
argnum ,
13 argc ,
*argv [argnum ]);
15 exit ( EXIT_SUCCESS );
}
✌
✆
After compiling and executing the executable as
✞
executable .exe a b c
✌
✆
Output is
✞
Argument 1 of supplied four arguments is a.
Argument 2 of supplied four arguments is b.
Argument 3 of supplied four arguments is c.
✌
✆
Here executable.exe in command-line is also considered as an argument. This is why
there are four arguments and first argument, ie 0th
argument, is executable.exe itself and
rest of the arguments are a, b and c respectively. An other example is given below](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-12-2048.jpg)
![212 Basic C
✞
1 #include <stdio.h>
3 int main (int argc , char ** argv ) {
size_t i;
5
for (i = 0; i < argc ; i++) {
7 /* get all the arguments as options *
*and initialize option pointer . */
9 char const *option = argv [i];
/* Get first character of an option argument */
11 if (option [0] == ’-’) {
/*If first character of an option argument *
13 *is ’-’, then following character is a flag */
printf("Flagged option.n");
15 /* get the second character of an option argument .*/
switch (option [1]) {
17 /*If second char of an option argument *
*is ’e’, then print encryption */
19 case ’e’:
printf("You have chosen %c:ENCryption . n",
option [1]) ;
21 break;
/*If second char of an option argument *
23 *is ’d’, then print decryption */
case ’d’:
25 printf("You have chosen %c:DECryption . n",
option [1]) ;
break;
27 /*If second char of an option argument *
*is ’f’, then print filename */
29 case ’f’:
printf("Your have chosen file name %c.n",
option [1]) ;
31 break;
/* other wise */
33 default :
printf("I can not understand your option %sn",
option);
35 break;
}
37 } else {
printf("No Flagged Options .n");
39 }
}
41 return 0;
}
✌
✆
When above example is compiled and executed like
✞
executable .exe -e -f
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-13-2048.jpg)
![1.11. PARSING ARGUMENTS 213
The output at console is
✞
No Flagged Option.
Flagged Option.
You have chosen e:ENCryption .
Flagged Option.
You have chosen filename f.
✌
✆
The first output “No Flagged Option” is appeared at the console at first as ‘exe-
cutable.exe’ is considered as first parsing argument and it is not prefixed with ‘–’. Using
array and pointer we do reverse to a parsed string via command line is given below.
✞
1 #include <stdio.h>
#include <stdlib.h>
3 /* String Length*/
#define SLen 4
5
int main (int argc , char *argv [ ]) {
7 /* Get the commandline string*/
char *name = argv [1];
9 char nameR [10];
int i;
11 for (i = 0; i < SLen ; i++)
/* Store each character of string in array*/
13 nameR[i] = name [i];
15 for (i = 4; i > 0; --i)
/* Print each character of stored string in array*/
17 printf("%c", nameR[i - 1]);
exit ( EXIT_SUCCESS );
19 }
✌
✆
Similarly the string length of given string can also be obtain by using following example
✞
1 #include <stdio.h>
3 int main (int argc , char *argv [ ]) {
if (argv [1] == NULL ) {
5 printf("Use <utility .exe > <string in quote or double
quote >.n");
exit (0);
7 }
/* Get the commandline string*/
9 char *name = argv [1];
int i = 0;
11 while (name [i] != NULL )
i++;
13 printf("The length of string is %d", i);
return 0;
15 }
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-14-2048.jpg)
![214 Basic C
1.11.1 Array To Integer
atoi() function is used to convert an array into integer. This function is very useful for
the conversion of number arguments passed as array or pointer into integer value. The
use of syntax is explained in the following example.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (int argc , char *argv [ ]) {
5 if (argv [1] == NULL ) {
printf("Use <utility .exe > <string >.n");
7 exit (0);
}
9 int i;
i = atoi (argv [1]) ;
11 printf("Array to integer is %d.", i);
exit ( EXIT_SUCCESS );
13 }
✌
✆
Without atoi(), we can also convert an array into integer by using simple mathematics
as explained in the following example.
✞
1 #include <stdio.h>
3 int main () {
char intg [ ] = "1234 ";
5 int i = 0, res = 0;
/* Here res must be initialized . Otherwise *
7 *product of res and 10 shall be null value*/
while (intg [i] != ’0’) {
9 /* Product of res with 10. res must not be null .*
* (intg [i] % 48) is used to convert integer *
11 * charcode into integer value. Charcode of 0 is*
* 48. Similarly , charcode of 1 is 49 and so on */
13 res = res * 10 + (intg [i] % 48);
i++;
15 }
printf("%dn", res);
17 return 0;
}
✌
✆
✞
1234
✌
✆
We can also used pointers for array to integer conversion. Above example is modified as
it is given below:
✞
1 #include <stdio.h>
3 int main () {
char *intg = "1234 ";](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-15-2048.jpg)
![1.12. MATHEMATIS 215
5 int i = 0, res = 0;
/* Here res must be initialized . Otherwise *
7 *product of res and 10 shall be null value*/
while (* intg != ’0 ’) {
9 /* Product of res with 10. res must not be null .*
* (intg [i] % 48) is used to convert integer *
11 * charcode into integer value. Charcode of 0 is*
* 48. Similarly , charcode of 1 is 49 and so on */
13 res = res * 10 + (* intg % 48);
intg ++;
15 }
printf("%dn", res);
17 return 0;
}
✌
✆
atoi() function is used to convert an integer array into integer value. Integer value “1234”
as string is stored in memory as a group of characters. Each character is one byte long.
1 2 3 4
i :
Value at byte :
00000001 00000010 00000011 00000100
Integer value “1234” in numeric form is stored in 4 bytes long memory space, allocated
for solely storing of integer.
i :
Num value :
00000000 00000000 00000100 11010010
1234
1.12 Mathematis
In C programming addition, subtraction, multiplication and division mathematical op-
erators can be directly used. Modulus is another mathematical operators that gives the
remainder value. Application of these operators are a + b, a − b, a ∗ b, a/b and a%b
respectively.
✞
#include <stdio.h>
2 #include <string.h>
int a, b;
4
int main (void ) {
6 int a = 5;
int b = 2;
8 int add = a + b;
int sub = a - b;
10 int mul = a*b;
int div = a / b;
12 int mod = a % b;](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-16-2048.jpg)
![216 Basic C
printf("Addition of %d and %d is : %d n", a, b, add);
14 printf("Subtraction of %d and %d is : %d n", a, b, sub);
printf("Multiplication of %d and %d is : %d n", a, b, mul);
16 printf("Division of %d and %d is : %d n", a, b, div);
printf("Modulus of %d and %d is : %d n", a, b, mod);
18 return 0;
}
✌
✆
Output of above program is
✞
Addition of 5 and 2 is : 7
Subtraction of 5 and 2 is : 3
Multiplication of 5 and 2 is : 10
Division of 5 and 2 is : 2
Modulus of 5 and 2 is : 1
✌
✆
A pointer can also be used in the addition, subtraction, multiplication and division of
two or more numbers.
✞
1 #include <stdio.h>
3 func (int *i, int*j) {
*i = *i * *i;
5 *j = *j* *j;
}
7
main () {
9 int i = 5, j = 2;
func (&i, &j);
11 printf("%d %d", i, j);
return 0;
13 }
✌
✆
✞
25, 4
✌
✆
1.12.1 Trigonometric Functions
“math.h” preprocessor file provides the mathematical functions that can be used directly
in the program. Some of them are defined in following sections.
cos, sin & tan
The cos, sin, and tan functions return the cosine, sine, and tangent of the argument,
expressed in radians. The domain of arguments of sin, cos and tan are [−π/2, π/2], [0, π]
and [−π/2, π/2] respectively. The numerical range of sin, cos and tan are [−1, 1], [−1, 1]
and [−∞, ∞].
✞
1 #include <math .h>
double cos(double x);](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-17-2048.jpg)
![218 Basic C
acos, asin & atan
The acos() functions return the arccosine of their arguments in radians, and the asin()
functions return the arcsine of their arguments in radians. All functions expect the
argument in the range [−1, +1]. The arccosine returns a value in the range [0, π]; the
arcsine returns a value in the range
h
−
π
2
,
π
2
i
. The atan() returns their argument value
in radian in the range
h
−
π
2
,
π
2
i
. Method of use of inverse function in following systems.
✞
1 #include <math .h>
double asin (double x);
3 double acos (double x);
double atan (double x);
✌
✆
A simple example is
✞
#include <stdio.h>
2 #include <math .h>
4 int main (void ) {
printf("Arc cosine at argument 0.5 is : %f n", acos (0.5));
6 printf("Arc sine at argument 0.5 is : %f n", asin (0.5));
printf("Arc tangent at argument 1.5 is : %f n", atan (1.5));
8 return 0;
}
✌
✆
✞
Arc cosine at argument 0.5 is : 1.047198
Arc sine at argument 0.5 is : 0.523599
Arc tangent at argument 1.5 is : 0.982794
✌
✆
cosh, sinh & tanh
The cosh(), sinh() and tanh() functions compute the hyperbolic cosine, the hyperbolic
sine and the hyperbolic tangent of the argument respectively.
✞
1 #include <math .h>
double cosh (double x);
3 double sinh (double x);
double tanh (double x);
✌
✆
A simple example is
✞
#include <stdio.h>
2 #include <math .h>
4 int main (void ) {
printf("Hyperbolic cosine of 0.5 is : %f n", cosh (0.5));
6 printf("Hyperbolic sine of 0.5 is : %f n", sinh (0.5));
printf("Hyperbolic tangent of 1.5 is : %f n", tanh (1.5));
8 return 0;](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-19-2048.jpg)
![1.12. MATHEMATIS 231
Contrast to these types of functions, fraction functions diverge to ∞ when x → 0. See
the following limit equation for function y = 1/x,
lim
x→0
y = lim
x→0
1
x
= ∞
Now, it is not possible to use this function with other functions in mathematical op-
erations. To avoid it, we take approaching limit to point ‘0’ of the function as given
below:
lim
x→0
y = lim
x→0
1
x
= ∞; when [−∞, 0) < x < (0, ∞]
x
y
b
(0, 0)
Here, ±∞ is acceptable as 1/ ± ∞ = 0, which is a finite value.
1.12.6 Random Number Generator
Following C program is used to generate random numbers. A user defined seed control
the initial random number and subsequent random numbers are used as seed for next
random number. This program given first five random number against a seed value.
✞
#include <stdio.h>
2 extern void SeedToNew (unsigned int x);
extern int MyRand(void );
4
int main (void ) {
6 int count;
unsigned seed ;
8 printf("Please enter seed .n");
while (scanf("%u", &seed ) == 1) {
10 SeedToNew (seed );
for (count = 0; count < 5; count ++)
12 printf("%hdn", MyRand());
printf("Please enter newSeed (q to quit ):n");
14 }
printf("Done n");
16 return 0;
}
18](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-46-2048.jpg)
![2.1. ARRAY 233
2Array & Pointer
2.1 Array
Arrays in C stores data in a single variable name with an index, also known as a subscript.
It is simply a list or ordered grouping for variables of the same type. Arrays often help a
programmer in organize collections of data efficiently and intuitively. A character array
takes one byte for each character while an integer array takes 4 bytes for one integer.
Other datatypes takes appropriate bytes to stores that data type value.
A B C D E F ‘0’
myStrA
Figure 2.1: Array of first six alphabetic characters stored in memory and pointed by
variable ‘myStrA’.
00000001 00000010
myNumA myNumA[0] myNumA[1]
Figure 2.2: Array of two integers pointed by variable ‘myNumA’ are stored in memory
as shown this figure. Each integer needs four bytes memory space.
2.1.1 Uni-Dimensional Array
Arrays are declared by two ways, (i) static and (ii) dynamic. Static arrays are declared
using square brackets containing size of array. Dynamic arrays are declared with pointers.
In static declaration, compiler creates space required for storing of data at declaration
and then returns the address of memory space created. In case of string, one extra
space for null terminator is also reserved. In case of dynamic declaration only address
of proposed memory space is returned where proposed data may be stored. It does not
reserve memory space. To create memory space, function malloc is used. Note that only
string arrays have terminating marker (0). Other type of arrays must be controlled by
array size. muArrays are declared and initialized like
✞
1 int numbers [6]; // array declared & space created
int point [6]={0 ,0 ,1 ,0 ,0 ,0}; // array declared , space
3 // created and initialized
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-48-2048.jpg)
![234 Array & Pointer
Remember that the initialization of static array is take place alongwith its declaration.
Otherwise initialization of an array shows compile time error.
✞
1 char myS [];
myS="My String"; /* Illegal initialization .*/
3 // Actually , above action was copying of data to
// array , not initialisation . Copying of data done
5 // by copying character one by one in memory space
char myStr []="My String"; /* Legal initialization .*/
✌
✆
Initialisation of array with pointer after declaration is compiler dependent.
✞
#include <stdio.h>
2
int main () {
4 char *c = "This ";
c = "That ";
6 printf("%s", c);
return 0;
8 }
✌
✆
✞
That
✌
✆
The brackets ([ ]) identify ‘numbers’ or ‘points’ and the number enclosed in the brackets
indicates the number of elements in the array. An element of the array can be accessed by
its index number i.e. subscripts of the array. When square bracket symbol in static array
declaration does not contain size of array then it is called dynamic declaration of array.
Dynamic array declaration is permitted if it is initialised at the time of declaration. In
following example, each element of the array is accessed by its index number.
✞
1 #include <stdio.h>
3 int main (void ) {
int ix;
5 short anArray[ ] = {3, 6, 9, 12, 15};
for (ix = 0; ix < ( sizeof (anArray ) / sizeof ( short)); ++ix) {
7 printf("The array value is %d.n", anArray [ix]);
}
9 }
✌
✆
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
Figure 2.3: Head integer value consumes 4 byte memory space. in represents to the index
of elements of array ‘days’. Total bytes of memory used to store data is 5 × 4 = 20.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-49-2048.jpg)
![2.1. ARRAY 235
In the above example, the size of the array was not explicitly specified. The compiler
knows the size of array from the initialized list. The size of ‘anArray’ is ‘5’ because
‘anArray’ has five elements. Addition of an additional element to the list will increase its
size to six. Static declaration of the size of an array, the array list will be overflow. To
overcome this problem sizeof expression is used as
✞
1 size = sizeof(anArray)/ sizeof(short)
✌
✆
As the sizeof expression in the for loop, the script is automatically adjusted to this
change. Designated initializer is allow to pick and choose the initialized elements. If the
last element of an array is initialized then in the initialization syntax of traditional C,
there is a requirement of initialization of every element preceding to the last one. An
array, if initialized, then each element value is index from 0 to n − 1, where n is size of
the array. For example,
✞
1 int count[] = {31, 28, 30, 29, 32, 27}; // array size is 6
✌
✆
has six elements. The element value at index 0 is 31, element value at index 1 is 28 and
so on. The index of array element may be redefined inside the array as the method given
in following syntax
✞
1 /* int count[] = {[<new index >]=< array element value >};*/
int count[] = {31, [2] = 28, 30, 29, 32, 27};
✌
✆
Here, the index of second element is 2, i.e. element shall be stored at third place of
memory of integer data type. Elements of an array are overridable, i.e. new element
value at index 4 can be override the old value of the element at the index 4 if any other
element is assigned the index value 4.
✞
#include <stdio.h>
2 #define MONTHS 12
4 int main (void ) {
int days [MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29};
6 int i;
for (i = 0; i < MONTHS; i++)
8 printf("%2d %dn", i + 1, days [i]);
return 0;
10 }
✌
✆
In above program example, array ‘days’ has first element (at index position 0) 31, second
element (at index position 1) is 28. Next element, 30, of the array ‘days’ is declared for
index 4, i.e. for 5th
position. Next element is 30 in the array ‘days’. Its position shall
be next to the previous element, i.e. after 5th
position, therefore this element will be at
6th
position or at index position 5. Element for index position 6 is 31. Last element is
defined for index position 1. Hence previous element, 28, which was at the index position
1 shall be replaced by value 29. The final arrangement of the array data in the memory
shall be as shown in the below figure.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-50-2048.jpg)
![236 Array & Pointer
i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 i10 i11
31 29 0 0 31 30 31 0 0 0 0 0
days
Figure 2.4: Arrangement of elements of array ‘days’ in memory. Here, each block rep-
resents to an integer data byte (i.e. group of four memory bytes). in represents to the
index of elements of array ‘days’.
✞
1 31
2 29
3 0
4 0
5 31
6 30
7 31
8 0
9 0
10 0
11 0
12 0
✌
✆
An array initialised with ‘[ ]’ is called expandable array. When an array is declared
without its size, compiler first count the array elements and then it grows the array upto
a size so that all the elements can stored in the array.
✞
/* Array with growing size . */
2 int days [ ] = {31, 28, [4] = 31, 30, 31, [1] = 29};
✌
✆
✞
#include <stdio.h>
2
int main (void ) {
4 int days [] = {31, 28, [4] = 31, 30, 31, [1] = 29};
int i;
6 printf("Size of array is %dn", sizeof (days ) / sizeof (int));
/* Here sizeof (days ) / sizeof (int) is not*
8 *grouped as ‘/’ higher precedence to ‘<’ */
for (i = 0; i < sizeof (days ) / sizeof (int); i++)
10 printf("%2d %dn", i , days [i]);
return 0;
12 }
✌
✆
✞
Size of array is 7
0 31
1 29
2 0
3 0
4 31
5 30](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-51-2048.jpg)
![2.1. ARRAY 237
6 31
✌
✆
2.1.2 Multi-Dimensional Array
An array declaration in C is given by
✞
int myA[m][n];/*m rows and n cols .*/
✌
✆
If the size of integer type array is fixed as shown above, compiler reserves m× n× k bytes
memory. Here, k is size of variable data type. For integer it is 4 as integer is 4 bytes long
data type. Hence, memory size allocated for integer array of type m × n is 4mn. Assume
a 2 × 2 integer array as shown below
✞
1 int myA [2][2] = {
{10, 20},
3 {15, 2}
};
✌
✆
The memory allocated for this array is 2 × 2 × 4 = 16 bytes. As column size of this array
is 2, hence 8 bytes are taken in a group for two columns, in which each column uses 4
bytes for storing integer data. Remember that, in following figures, each cell represents
to one byte. This is why, an integer is represented here as a group of four bytes. It is
done, for convenient to calculate the number of bytes required to store an array data.
And in computer, the index counting is started from ‘0’ instead of ‘1’.
10 0 0 0 20 0 0 0
15 0 0 0 2 0 0 0
myA c0 c1
r0
r1
In above figure, the byte position of array data is shown into two rows and two column.
Practically above data is stored in memory as continuous data bytes.
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0
myA
1st
row 2nd
row
1st
col 2nd
col 1st
col 2nd
col
From the above arrangement of data, in a multi-dimensional array, number of rows
may be constant or variable but number of columns must be constant. The reason is
that, elements of an array are arranged one by one sequentially, so if column size is not
fixed then pointer-to-array variable will not be able to identify the starting of next row
of the array. See the example below:](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-52-2048.jpg)
![238 Array & Pointer
✞
#include <stdio.h>
2
int main () {
4 int i;
int myA [2][2] = {/* 2X2X4 =16 bytes */
6 {10, 20},
{15, 2}
8 };
printf("Size of array is %dn", sizeof (myA));
10 char *p = (char *) &myA; // Cast int into char ptr
for (i = 0; i < sizeof (myA); i++) {
12 printf("%d ", p[i]);// print all 16 bytes
}
14 return 0;
}
✌
✆
✞
Size of array is 16
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0
✌
✆
Now, an array having two columns but dynamic rows is declared and assigned as the
syntax is given below:
✞
int myB[ ][2] = {
2 {10, 20},
{15, 2},
4 {1, 4}
};
✌
✆
The memory allocated for this array is dynamic. This array has two columns hence
memory is allocated in the multiple of 2 × 4 = 8 bytes. If there are two rows then
memory allocation will be expanded to 8 × 2 = 16 bytes. Similarly if there are three
rows then memory allocation will be expanded to 8 × 3 = 24 bytes and so on, subject to
memory sharing is not violated.
myA
10 0 0 0 20 0 0 0
15 0 0 0 2 0 0 0
1 0 0 0 4 0 0 0
c0 c1
r0
r1
r2
See the example below:
✞
1 #include <stdio.h>](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-53-2048.jpg)
![2.1. ARRAY 239
3 int main () {
int i;
5 /* Array has fixed cols & dynamic rows */
int myB[ ][2] = {
7 {10, 20},
{15, 2},
9 {1, 4}
};
11 printf("Size of array is %dn", sizeof (myB));
char *p = (char *) &myB;
13 for (i = 0; i < sizeof (myB); i++) {
printf("%d ", p[i]);
15 }
return 0;
17 }
✌
✆
✞
Size of array is 24
10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 1 0 0 0 4 0 0 0
✌
✆
An array having two rows and three columns is declared and initialized as shown in the
syntax given below:
✞
int two_d [2][3] = {{ 5, 2, 1 },
2 { 6, 7, 8 }};
✌
✆
Where [2] represents to the number of rows and [3] represents to the number of columns of
the two dimensional array. A three dimensional array is declared as given in the following
syntax:
✞
int myA[ ][3][2];
2 /* | | | *
* l r c */
✌
✆
This array has two columns (y-axis represented as ‘c’ here), three rows (x-axis represented
as ‘r’ here) and variable number of layers (z-axis represented as ‘l’ here). In C programs,
which contains three dimensional array, the z-axis (i.e. third dimension) is always outer-
most loop. Practically, three dimensional array is layers of two dimensional arrays. As
shown in the following figure, a 3 × 2 array is placed in four layers and collectively, they
form a 3 × 2 × 4 three dimensional array.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-54-2048.jpg)
![240 Array & Pointer
l0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l2
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l3
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
A three dimensional array is arranged in patterns as shown in below figure.
myA
l0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
l1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
c0 c1
r0
r1
r2
The memory arrangement of three dimensional array is given in the following figure.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
myA
r0 of l0 r1 of l0
c0 of r0 c1 of r0 c0 of r1 c1 of r1
Multi-dimensional array can be used to add, subtract and product (either dot or cross)
of two vectors or matrices. Following is an example using an array of 5 × 5 dimension.
This example requires 5 × 5 × 4 = 100 bytes.
✞
1 #include <stdio.h>
#define X 5
3 #define Y 5
5 int main (void ) {
int ix , iy;
7
short anArray[X][Y]; /* 100 bytes memory requirement .*/
9 for (ix = 0; ix < X; ++ix) {
for (iy = 0; iy < Y; ++iy) {](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-55-2048.jpg)
![2.1. ARRAY 241
11 anArray[ix][ iy] = ix * iy;
};
13 }
for (ix = 0; ix < X; ++ix) {
15 for (iy = 0; iy < Y; ++iy) {
printf("%2dt", anArray[ix][iy]);
17 };
printf("n");
19 }
}
✌
✆
✞
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 4 8 12 16
✌
✆
Multidimentional array can be extended in matrix manipulations, additions, subtractions,
multiplications and divisions. In the following example, two matrices are added and
subtracted element-wise. The element-wise addition and subtraction is given by
Cij = Aij ± Bij
✞
1 #include <stdio.h>
3 /* Random number generator between 0 to 10.*/
int rand_num (int a, int b) {
5 return ((a * 97 + b*21) & 10);
}
7
int main () {
9 int i/* row*/,
j/* col*/;
11 int A [3][3]/* First Matrix*/,
B [3][3]/* Second Matrix*/,
13 C [3][3]/* Third Matrix*/;
printf("First Random Matrix is :n");
15 /* For each of three rows */
for (i = 0; i < 3; i++) {
17 /* There are three columns.*/
for (j = 0; j < 3; j++) {
19 /* Assign a random matrix elements .*/
A[i][j] = rand_num (i*j, j);
21 printf("%3dt", A[i][j]);
}
23 /* Print new line after completion of each row*/
printf("nn");
25 }
printf("nSecond Random Matrix is :n");
27 /* For each of three rows */](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-56-2048.jpg)
![242 Array & Pointer
for (i = 0; i < 3; i++) {
29 /* There are three columns.*/
for (j = 0; j < 3; j++) {
31 /* Assign a random matrix elements .*/
B[i][j] = rand_num (i, i*j);
33 printf("%3dt", B[i][j]);
}
35 /* Print new line after completion of each row*/
printf("nn");
37 }
printf("nElementwise Addition of Matrix is :n");
39 /* For each of three rows */
for (i = 0; i < 3; i++) {
41 /* There are three columns.*/
for (j = 0; j < 3; j++) {
43 /* Add matrices elementwise .*/
C[i][j] = A[i][j] + B[i][j];
45 printf("%3dt", C[i][j]);
}
47 /* Print new line after completion of each row*/
printf("nn");
49 }
printf("nElementwise Subtraction of Matrix is :n");
51 /* For each of three rows */
for (i = 0; i < 3; i++) {
53 /* There are three columns.*/
for (j = 0; j < 3; j++) {
55 /* Subtract matrices elementwise .*/
C[i][j] = A[i][j] - B[i][j];
57 printf("%3dt", C[i][j]);
}
59 /* Print new line after completion of each row*/
printf("nn");
61 }
return 0;
63 }
✌
✆
✞
First Random Matrix is :
0 0 10
0 2 8
0 2 10
Second Random Matrix is :
0 0 0
0 2 10
2 8 2
Elementwise Addition of Matrix is :
0 0 10
0 4 18
2 10 12
Elementwise Subtraction of Matrix is :
0 0 10](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-57-2048.jpg)
![2.1. ARRAY 243
0 0 -2
-2 -6 8
✌
✆
The vector and scalar products between two matrices can also be done. The dot product
of two matrices is given by
Cij = ~
Aij · ~
Bij
In the following example, dot products between to matrices is performed.
✞
#include <stdio.h>
2
/* Random number generator between 0 to 10.*/
4 int rand_num (int a) {
return ((a * 1011457789 + 12345) & 10);
6 }
8 int main () {
int i/* row*/,
10 j/* col*/;
int A [3][3]/* First Matrix*/,
12 B [3][3]/* Second Matrix*/,
C [3][3]/* Dot Matrix */;
14 printf("First Random Matrix is :n");
/* For each of three rows */
16 for (i = 0; i < 3; i++) {
/* There are three columns.*/
18 for (j = 0; j < 3; j++) {
/* Assign a random matrix elements .*/
20 A[i][j] = rand_num (i + j);
printf("%dt", A[i][j]);
22 }
/* Print new line after completion of each row*/
24 printf("nn");
}
26 printf("nSecond Random Matrix is :n");
/* For each of three rows */
28 for (i = 0; i < 3; i++) {
/* There are three columns.*/
30 for (j = 0; j < 3; j++) {
/* Assign a random matrix elements .*/
32 B[i][j] = rand_num (i * j);
printf("%dt", B[i][j]);
34 }
/* Print new line after completion of each row*/
36 printf("nn");
}
38 printf("nDot Product Matrix is :n");
/* For each of three rows */
40 for (i = 0; i < 3; i++) {
/* There are three columns.*/
42 for (j = 0; j < 3; j++) {
/* Elementwise dot product of matrices .*/](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-58-2048.jpg)
![244 Array & Pointer
44 C[i][j] = A[i][j] * B[i][j];
printf("%dt", C[i][j]);
46 }
/* Print new line after completion of each row*/
48 printf("nn");
}
50 return 0;
}
✌
✆
✞
First Random Matrix is :
8 2 2
2 2 0
2 0 8
Second Random Matrix is :
8 8 8
8 2 2
8 2 8
Dot Product Matrix is :
64 16 16
16 4 0
16 0 64
✌
✆
The cross product (vector product) of two matrices is given by
~
C = ~
A × ~
B
✞
#include <stdio.h>
2
/* Random number generator between 0 to 10.*/
4 int newseed =10;
int seed (int a){
6 newseed =newseed+a;
return newseed;
8 }
int rand_num (int a) {
10 seed (a);
return (( newseed * 99991 + 12345) & 10);
12 }
14 int main () {
int i/* row*/;
16 int A[3]/* First Vector */,
B[3]/* Second Vector */,
18 C[3]/* Dot Vector */;
printf("First Random Vector is :n");
20 /* For each of three rows */
for (i = 0; i < 3; i++) {
22 /* Assign a random vector elements .*/
A[i] = rand_num (i);
24 printf("%dt", A[i]);](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-59-2048.jpg)
![2.1. ARRAY 245
}
26 /* Print new line after completion of each row*/
printf("n");
28
printf("nSecond Random Vector is :n");
30 /* For each of three rows */
for (i = 0; i < 3; i++) {
32 /* Assign a random vector elements .*/
B[i] = rand_num (i);
34 printf("%dt", B[i]);
/* Print new line after completion of each row*/
36 }
printf("n");
38
printf("nCross Product Vector is :n");
40 /* For each of three rows */
for (i = 0; i < 3; i++) {
42 /* Elementwise cross product of matrices .*/
C[i] = pow(-1,2* i)* (A[(i+1) %3] * B[(i+2) %3]
44 - B[(i+1) %3] * A[(i+2) %3]) ;
printf("%dt", C[i]);
46 }
/* Print new line after completion of each row*/
48 printf("nn");
50 return 0;
}
✌
✆
✞
First Random Vector is :
10 2 0
Second Random Vector is :
0 10 8
Cross Product Vector is :
16 -80 100
✌
✆
Arrays can be passed to a function as its parameter (argument) as shown in the example
given below:
✞
#include <stdio.h>
2 /*+- Array pointer with **
**| expandable size */
4 void init_array (int a[ ], int count) {
int i;
6 for (i = 0; i < count; i++)
a[i] = i * 10;
8 for (i = 0; i < count; i++)
printf("The a value is %d.n", a[i]);
10 }
12 int main (void ) {
int mydata [10];](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-60-2048.jpg)
![246 Array & Pointer
14 init_array (mydata , 5);
return 0;
16 }
✌
✆
✞
The a value is 0.
The a value is 10.
The a value is 20.
The a value is 30.
The a value is 40.
✌
✆
For multidimensional array, there is no limit of dimension in C. Here, a four dimensional
matrix is represented by
✞
1 int myData [2][3][2][4]
✌
✆
A new dimension in array declaration is always grouped by curly braces. One dimensional
array has one curly braces, i.e. one row. In two dimensional array, there are two one
dimensional rows both separated by comma (,) operator. These two rows are enclosed by
another curly braces. In three dimensional systems of arrays, two 2-dimensional arrays
are placed one over another. In the following example, two, three and four dimensional
arrays are declared.
✞
1 #include <stdio.h>
3 int main () {
char a[2][2] = {
5 // cols
{1, 2}, // row
7 {5, 6} // row
};
9 char b[2][2][2] = {
{
11 // cols
{1, 2}, // row
13 {5, 6} // row
},
15 {// height
{4, 3},
17 {8, 9}
}
19 };
char c[2][2][2][2] = {
21 {
{
23 // cols
{1, 2}, // row
25 {5, 6} // row
},
27 {// height
{1, 2},](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-61-2048.jpg)
![2.1. ARRAY 247
29 {5, 6}
}
31 },
{// time
33 {
{4, 1},
35 {7, 6}
},
37 {
{4, 4},
39 {9, 1}
}
41 }
};
43 int i, j, k, l;
printf("Elements of matrix a are n");
45 for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
47 printf("Element a[%d][%d] is : %dn",
i+1, j+1, a[i][j]);
49 }
}
51 printf("Elements of matrix b are n");
for (i = 0; i < 2; i++) {
53 for (j = 0; j < 2; j++) {
for (k = 0; k < 2; k++) {
55 printf("Element b[%d][%d][%d] is : %dn",
i+1, j+1, k+1, b[i][j][k]);
57 }
}
59 }
printf("Elements of matrix c are n");
61 for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
63 for (k = 0; k < 2; k++) {
for (l = 0; l < 2; l++) {
65 printf("Element c[%d][%d][%d][%d] is : %dn",
i+1, j+1, k+1, l+1, c[i][j][k][l]);
67 }
}
69 }
}
71 return 0;
}
✌
✆
It is an example of the two dimensional matrix in which total and average marks of each
student is calculated.
✞
#include <stdio.h>
2 #define STUDENT 3 // number of STUDENTS
#define SUBJECT 5 // number of SUBJECT](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-62-2048.jpg)
![248 Array & Pointer
4
int main (void ) {
6 // marks of five stus
const float marks[STUDENT ][ SUBJECT ] = {
8 // subs ->
{9.9, 8.0, 8.3, 4.2, 6.0}, // stu row
10 {9.0, 7.0, 7.3, 2.0, 5.0}, // stu row
{9.6, 8.0, 8.8, 2.1, 5.5}, // stu row
12 };
int stu , sub;
14 float subtot , total;
printf("Student Marks (Max 50)n");
16
/* for each stu , sum marks for each sub */
18 total = 0;
for (stu = 0; stu < STUDENT; stu ++) {
20 for (sub = 0, subtot = 0; sub < SUBJECT; sub ++) {
subtot += *(*( marks + stu) + sub);
22 }
printf("%s %d %20.1fn", "Stu", stu + 1, subtot);
24 total += subtot; /* total for all stus */
}
26 printf("nThe student average is %.1f.nn",
total / STUDENT );
28
printf("Subject Average :n");
30 printf("Sub_1 Sub_2 Sub_3 Sub_4 Sub_5n");
32 /* for each sub , sum marks over stus */
for (sub = 0; sub < SUBJECT; sub ++) {
34 subtot = 0;
for (stu = 0; stu < STUDENT; stu ++) {
36 subtot += *(*( marks + stu) + sub);
}
38 printf("%5.1 f ", subtot / STUDENT );
}
40 printf("n");
return 0;
42 }
✌
✆
✞
Student Marks (Max 50)
Stu 1 36.4
Stu 2 30.3
Stu 3 34.0
The student average is 33.6.
Subject Average :
Sub_1 Sub _2 Sub_3 Sub_4 Sub_5
9.5 7.7 8.1 2.8 5.5
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-63-2048.jpg)
![2.1. ARRAY 249
A multidimensional array may also be returned by a function, if function is used as a
pointer. An example for two dimensional array as a returned value of a function is given
below:
✞
#include <stdio.h>
2
int (* myF(int arr [3][3] , int n))[3] {
4 int i, j;
for (i = 0; i < 3; i++) {
6 for (j = 0; j < 3; j++) {
arr[i][j] = i + j;
8 }
}
10 return arr;
}
12
int main () {
14 int arr [3][3];
int (*q)[3] = myF(arr , 3);
16 int i, j;
for (i = 0; i < 3; i++) {
18 for (j = 0; j < 3; j++) {
printf(" %d", q[i][j]);
20 }
printf("n");
22 }
}
✌
✆
✞
0 1 2
1 2 3
2 3 4
✌
✆
2.1.3 Array of Strings
It is very simple to declara an array for integers, float, characters datatypes as they has
fixed size. But, in case of string, declaration of array is complex as size of string, being
stored in array like matrix form, is variable. For example, at a particular cell, we can store
string “me” or string “our”. Here, both words have different size. So, declaration of an
array for string needs special caution and care. Here, we shall discuss about the storing of
string data in an array, starting from one dimensional array to multi-dimensional array.
Suppose we have to store string “This”. We declare array like
✞
1 char myArr [];
✌
✆
Here, ‘[]’ controls the size of declared variable ‘myArr’ as dynamic and memory is allocated
and reallocated by compiler at run time according to the size of input string being stored.
Now, we store string “This” in this array, and appended by null terminator. The memory
data shall be looked like-](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-64-2048.jpg)
![250 Array & Pointer
0×0012 0×0013 0×0014 0×0015 0×0016 0×0017 0×0018 0×0019
myArr
T h i s 0
Figure 2.5:
But what happens if we declare an fixed size one dimensional array as shown below:
✞
1 char myArr [10];
✌
✆
It means, above array may store only 10 characters including null terminator.
✞
1 #include <stdio.h>
#include <string.h>
3
int main () {
5 char myArr[]="This ";
printf("String is ’%s ’n",myArr);
7 return 0;
}
✌
✆
✞
String is ’This ’
✌
✆
If we try to store string of size more than 10 characters, data shall be overflow. From
figure 2.5, it is seen that each character of string ‘This’ is column of one row vector.
Therefore, when we declare a two dimensional array, one new parameter is required for
rows of the array alongwith other size of string parameter.
✞
1 char myArr[<rows >][< string size in each row >]
✌
✆
For example, an array
✞
1 char myArr [3][5]
✌
✆
tells us that, there are three rows and each row may store strings of five characters
including null terminator. Note that, the declaration parameter ‘[<string size in each
row >]’ is required only at the time of array declaration. When storing and retrieving of
strings, we just ignore it or just replace it by ‘[0]’ only.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-65-2048.jpg)
![2.1. ARRAY 251
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
i s 0
m y 0
0×0312 0×0313 0×0314 0×0315 0×0316
p e t 0
myArr[0]
myArr[1]
myArr[3]
Figure 2.6:
✞
1 #include <stdio.h>
#include <string.h>
3
int main () {
5 char myArr [4][5]={ "This ","is","my","pet"};
printf("String is ’%s ’n",myArr[0]) ;
7 printf("String is ’%s ’n",myArr[1]) ;
printf("String is ’%s ’n",myArr[2]) ;
9 printf("String is ’%s ’n",myArr[3]) ;
return 0;
11 }
✌
✆
✞
String is ’This ’
String is ’is ’
String is ’my ’
String is ’pet ’
✌
✆
Note that, a string variable is pointer of itself and points to address where data is stored.
So, use of ‘&’ symbol is optional. It also points to the address of first character of string,
so use of ‘[0]’ is also optional. So that, ‘myArr’ and ‘myArr[0]’ both return the string
‘This’.
✞
#include <stdio.h>
2 #include <string.h>
4 int main () {
char myArr [4][5]={ "This ","is","my","pet"};
6 printf("String is ’%s ’n",myArr);
printf("String is ’%s ’n",myArr[1]) ;
8 printf("String is ’%s ’n",myArr[2]) ;
printf("String is ’%s ’n",myArr[3]) ;
10 return 0;
}
✌
✆
✞
String is ’This ’](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-66-2048.jpg)
![252 Array & Pointer
String is ’is ’
String is ’my ’
String is ’pet ’
✌
✆
We can also declare an array that is arranged in rows and columns and each column is of
fixed size for storing of strings.
✞
char myArr[<rows >][< cols >][< string size >]
✌
✆
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0017 0×0018 0×0019 0×0020 0×0021
T h a t 0
i s 0 w a s 0
m y 0 m y 0
0×0312 0×0313 0×0314 0×0315 0×0316
p e t 0
0×0317 0×0318 0×0319 0×0320 0×0321
p e n 0
myArr[0][0]
myArr[1][0]
myArr[3][0]
myArr[0][1]
Figure 2.7:
See the example below:
✞
1 #include <stdio.h>
#include <string.h>
3
#define ROWS 4
5 #define COLS 2
#define STRING_SIZE 5
7
int main () {
9 char myArr[ROWS ][ COLS ][ STRING_SIZE ] = {
{"This ", "That "},
11 {"is", "was"},
{"my", "my"},
13 {"pet", "pen"}
};
15 int i;
printf("Data matrix is : n");
17 for (i = 0; i < ROWS ; i++) {
printf("%5s t %5sn", myArr[i][0], myArr[i][1]);
19 }
return 0;
21 }
✌
✆
✞
Data matrix is :
This That
is was](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-67-2048.jpg)
![2.1. ARRAY 253
my my
pet pen
✌
✆
We can add new strings in this array by using strcpy function by indicating the address
of matrix cell.
✞
1 /*At fifth row , first column */
strcpy(arr [4][0] , "Hi");
3 /*At fifth row , second column*/
strcpy(arr [4][1] , "His");
✌
✆
While we use scanf function to add user’s input from input stream, we should exactly
known to the address of memory byte where data is to be stored.
✞
#include <stdio.h>
2 #include <string.h>
4 #define ROWS 5
#define COLS 2
6 #define STRING_SIZE 5
8 int main () {
char myArr[ROWS ][ COLS ][ STRING_SIZE ] = {
10 {"This ", "That "},
{"is", "was"},
12 {"my", "my"},
{"pet", "pen"}
14 };
int i;
16 printf("Enter data for 5th row 1st column :");
scanf("%s", myArr [4][0]) ;
18 printf("Enter data for 5th row 2nd column :");
scanf("%s", &myArr [4][1][0]) ;/* last [0] is optional */
20 printf("Data matrix is : n");
for (i = 0; i < ROWS ; i++) {
22 printf("%5s t %5sn", myArr[i][0], myArr[i][1]);
}
24 return 0;
}
✌
✆
✞
Enter data for 5th row 1st column :hi
Enter data for 5th row 2nd column :his
Data matrix is :
This That
is was
my my
pet pen
hi his
✌
✆
We can also declare a static multidimensional array by using pointers. It is declared as](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-68-2048.jpg)
![254 Array & Pointer
✞
char * myArr[<rows >]
✌
✆
Data should be assigned at the time of declaration. Pointer character ‘*’ is responsible
for dynamic allocation of memory of suitable size so that assigned data is stored in the
array. See the example below:
✞
1 #include <stdio.h>
3 int main () {
/* Static array declaration */
5 char * myArr[2] = {"This ", "is"};
printf("First row string is : %sn", myArr[0]) ;
7 printf("Second row string is : %s", myArr[1]) ;
return 0;
9 }
✌
✆
✞
First row string is : This
Second row string is : is
✌
✆
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0112 0×0113 0×0114 0×0115 0×0116
i s 0
myArr[0]
myArr[1]
Here, two strings have static storage prior to the program startup. In the initializer, the
arrays are converted to pointers to char and the words array is initialized with the pointer
values. It can not be modified during the program run. It has its own advantages as we
can access to character of string by using pointers.
✞
#include <stdio.h>
2
int main () {
4 char * myArr[3] = {"This ", "is"};
printf("First row string is : %sn", myArr[0]) ;
6 printf("Same from index 1 is : %s n", (myArr [0]+1));
return 0;
8 }
✌
✆
✞
First row string is : This
First row string from index 1 is : his
✌
✆
Here, ‘myArr[0]+1’ means pointer points to the first row string at index ‘0’ and pointer
position is changed by one character position rather than next row.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-69-2048.jpg)
![2.1. ARRAY 255
0×0012 0×0013 0×0014 0×0015 0×0016
T h i s 0
0×0112 0×0113 0×0114 0×0115 0×0116
i s 0
myArr[0]+1
myArr[1]
Using pointer, we can access whole string or its part of string. For example, ‘*myArry’
is the same as myArry[0]. ‘(*myArry)[0]’ is the same as **myArry, which is the first
character of the string and not the address of the string.
✞
#include <stdio.h>
2
int main () {
4 char * myArr[2] = {"This ", "Home "};
printf("For ’This ’ : %sn", myArr [0]) ;
6 printf("For ’Home ’ : %sn", myArr [1]) ;
/* Address of ’This ’ pointed by * myArr and*
8 *it points to address of character ’T’ */
printf("For ’This ’ : %sn", *myArr);
10 /* Dereference to pointer that is pointing *
*to address where string ’This ’ is stored. *
12 *Pointer points to location of character ’T ’.*/
printf("For ’T’ : %c n", ** myArr);
14 /* same as above*/
printf("For ’T’ : %c n", (* myArr)[0]) ;
16 /* Dereference to pointer that is pointing *
*to address where string ’This ’ is stored.*
18 *Pointer in incremented by one , and now , *
*it points to location of character ’h ’. */
20 printf("For ’h’ : %c n", (* myArr)[1]) ;
/* same as above*/
22 printf("For ’h’ : %c n", *(* myArr +1));
return 0;
24 }
✌
✆
✞
For ’This ’ : This
For ’Home ’ : Home
For ’This ’ : This
For ’T’ : T
For ’T’ : T
For ’h’ : h
For ’h’ : h
✌
✆
2.1.4 Array in Function
In functions arguments are passed to it as value unless the function needs alter the
argument. If function needs update the argument, argument should be passed to function
as its argument. Arrays can also passed to functions as pointers. If an array is passed to](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-70-2048.jpg)
![256 Array & Pointer
the function, function would have to allocate enough space to hold a copy of the original
array and then copy all the data from the original array to the new array. It is much
quicker to pass the address of the array rather than array itself and have the function
work with the original data. Prototype for the passing of an array to the function is
✞
1 int sum(int arr[ ])
/*Or*/
3 int sum(int *arr)
✌
✆
sum()
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
S
Figure 2.8: Passing of address of array to sum() function. Array is pointed by the
pointer/variable ‘anArray’.
In C, array parameters are always treated as pointers. C compilers do not check the
size of the array passed to the function hence for good programming, the function should
know the limits of actions on the array. This is why a new parameter of array size as ‘n’
is passed to the function as
✞
1 int sum(int arr[ ], int n)
✌
✆
sum()
for(i=0; i<n; i++){
S += anArray[i];
}
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
n
S
Figure 2.9: Passing of address of array as well as element size of the array to sum()
function. Array is pointed by the pointer/variable ‘anArray’.
Because the name of an array is the address of the first element, an actual argument of
an array name requires that the matching formal argument be a pointer. In this context
int arr[ ] to mean the same as the int * arr. First bracket in the multidimensional array
may be empty or not but other brackets should contains the valid integers for the size of
the array dimension. For example](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-71-2048.jpg)
![2.1. ARRAY 257
✞
1 int sum(int arr[ ][ ], int rows ); // faulty declaration
✌
✆
is a faulty declaration. Recall that the compiler converts array notation to pointer no-
tation. It means, that arr[1] will become arr+1. For the compiler to evaluate this, it
needs to know the size of object to which ‘arr’ points. The declaration
✞
1 int sum2 (int arr[ ][4], int rows ); // valid declaration
✌
✆
says that ‘arr’ points to an array of four integers, so ‘arr+1’ means “add 16 bytes to the
address”. If first bracket contains a number then it will be ignored.
✞
1 int sum2 (int ar [3][4] , int rows ); // valid declaration , 3 ignored
✌
✆
✞
1 #include <stdio.h>
#define ROWS 3
3 #define COLS 4
int sum(int rows , int cols , int ar[rows ][ cols ]);
5
int main (void ) {
7 int i,j;
int varr [ROWS ][ COLS ];
9 for (i = 0; i < ROWS ; i++)
for (j = 0; j < COLS ; j++)
11 varr [i][j] = i * j + j;
printf("3x4 Array n");
13 printf("Sum of all elements = %dn",
sum(ROWS , COLS , varr ));
15 return 0;
}
17 int sum(int rows , int cols , int ar[rows ][ cols ]) {
int r;
19 int c;
int tot = 0;
21 for (r = 0; r < rows ; r++)
for (c = 0; c < cols ; c++)
23 tot += ar[r][c];
return tot;
25 }
✌
✆
✞
3x4 Array
Sum of all elements = 36
✌
✆
An array can passed to a function by using function prototype as shown in syntax given
below:
✞
#include <stdio.h>
2
void PrintIt (char Str[ ]) {
4 printf("%sn", Str);](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-72-2048.jpg)
![258 Array & Pointer
}
6
int main () {
8 char label[ ] = "Allora Caves.";
PrintIt (label);
10 return 0;
}
✌
✆
The output is
✞
Allora Caves.
✌
✆
Function PrintIt() expects a character array. When an array is declared as the
parameter to a function, it really gets a pointer. Arrays are always automatically passed
by reference. Similarly a pointer can also pass to a function as an array or as a pointer.
✞
1 #include <stdio.h>
3 void PrintIt (char Str[ ]) {
printf("%sn", Str);
5 }
7 int main () {
char * label = "Allora Caves.";
9 PrintIt (label);
return 0;
11 }
✌
✆
The output is
✞
Allora Caves.
✌
✆
✞
1 #include <stdio.h>
3 void PrintIt (char *Str) {
printf("%sn", Str);
5 }
7 int main () {
char * label = "Allora Caves.";
9 PrintIt (label);
return 0;
11 }
✌
✆
The output is
✞
Allora Caves.
✌
✆
Unfortunately, (in C and C++) the length of the array cannot be obtained from an
array passed to a function at run time, because the size of an array is not stored anywhere.
The compiler always replaces sizeof () with a constant. See the following example](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-73-2048.jpg)
![2.1. ARRAY 259
✞
1 #include <stdio.h>
#include <string.h>
3
#define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
5
int sum(int input_array [ ]) {
7 int sum_so_far = 0;
int i;
9 /* Would NOT Work ; input_array was*
*not defined in this function . */
11 for (i = 0; i < NUM_ELEM (input_array ); i++){
sum_so_far += input_array [i];
13 };
return ( sum_so_far );
15 }
17 int main (int argc , char *argv [ ]) {
int left_array [ ] = {1, 2, 3};
19 int right_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
int the_sum = sum(left_array );
21 printf("the sum of left_array is: %d n", the_sum );
the_sum = sum(right_array );
23 printf("the sum of right_array is: %d n", the_sum );
25 return 0;
}
✌
✆
When this example is run, it gives output as shown below
✞
the sum of left _array is 1
the sum of right_array is 10
✌
✆
whatever the values are passed as argument in the sum function. This ‘sum()’ routine
needs to handle more than just one constant length of an array. There are some common
ways to work around this fact:
1. Write the function as required, for each array parameter and parameter “length”
which has type “size t”. We can use sizeof () at the point where this function is
called.
2. Use of a null-terminated string to mark the end of the array if array is string. Arrays
representing to numbers does not need the null-terminating string to mark of the
end of array. Instead it, number arrays are passed to the function along with its
element size.
3. Pass the arrays as well as array length parameter to the function. We can pass
the pointer-to-array if required. Evaluate the data as per rules set by function
statements or expressions.
Using these facts, above example is now modified as given below.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-74-2048.jpg)
![260 Array & Pointer
✞
#include <stdio.h>
2
#define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
4
int mySum(int array[ ], size_t length) {
6 int sum = 0;
int i;
8 for (i = 0; i < length; i++) {
sum += array[i];
10 };
return ( sum);
12 }
14 int main (int argc , char *argv [ ]) {
int sum;
16 int i_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
/* Works here , because the size of right_array *
18 *is passed to the sum function as argument */
sum = mySum(i_array , NUM_ELEM (i_array ));
20 printf("The sum is : %d.n", sum);
22 return 0;
}
✌
✆
Output of above example is
✞
the sum is : 55
✌
✆
The same method of passing an array to a function and getting sum of all array element
is also possible with other number datatypes. Above example is suitable modified for array
contains floating type numbers.
✞
1 #include <stdio.h>
3 #define NUM_ELEM (x) (sizeof (x) / sizeof (*(x)))
5 /* Function returns floating data . So mySum()*
*should be declared as floating data type . */
7 float mySum(float in_array [ ], size_t length) {
float sum = 0;
9 int i;
for (i = 0; i < length; i++) {
11 sum += in_array [i];
};
13 return ( sum);
}
15
int main (int argc , char *argv [ ]) {
17 float sum;
float array[ ] = {10.10 , 50.50 , 4.57, 1.21};
19 sum = mySum(array , NUM_ELEM (array));](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-75-2048.jpg)
![2.1. ARRAY 261
printf("The sum is : %fn", sum);
21 return 0;
}
✌
✆
✞
The sum is : 66.379997
✌
✆
It’s worth mentioning that sizeof () operator has two variations: sizeof (type) and sizeof (<expression>).
An example using sizeof () function to a pointer is shown below.
✞
1 #include <stdio.h>
#include <string.h>
3
int main (int argc , char *argv [ ]) {
5 char buffer [10];
if (argc < 2) {
7 fprintf (stderr , "USAGE: %s stringn", argv [0]) ;
return 1;
9 }
strncpy (buffer , argv [1], sizeof ( buffer));
11 buffer[sizeof (buffer) - 1] = ’0 ’;
return 0;
13 }
✌
✆
Output of the script is
✞
USAGE: executable .exe string
✌
✆
2.1.5 String As Array
C has no built in string handling facilities. Consequently, string is defined as array of
characters. C allows a character array to be represented by a character string rather than
a list of characters, with the null terminating character, automatically added to the end.
Example of string array is shown below.
✞
1 char s[ ] = {’A’, ’p’, ’p’, ’l’, ’e’, ’s’, ’0’};
✌
✆
A p p l e s 0
s
Figure 2.10: Array of characters constructing word ‘Apples’ is stored in memory and
pointed by variable ‘s’.
Normally size of string array is controlled at initialisation. An string array can store only
the number of characters upto its length. Rest of the characters are ignored. In following
example only ten characters will be stored in the string array ‘mystr’.](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-76-2048.jpg)
![262 Array & Pointer
✞
1 char mystr [10] = "Apple is red.";
✌
✆
It is convenient to let the compiler determine the array size. If one omits the size in an
initializing declaration, the compiler determines the size for supplied string. In following
example, compiler set the string length of thirteen characters.
✞
1 char mystr[ ] = "Apple is red.";
✌
✆
A pointer notation may aslo be set up to represent a string. In pointer notation, above
example will be look like
✞
1 const char *ptrstr = "Delhi";
✌
✆
D e l h i 0
ptrstr
Figure 2.11: Character array ‘Delhi’ stored in memory. ‘ptrstr’ points to the character
array ‘Delhi’.
Both declarations amount to saying that ‘ptrstr’ is a pointer to the indicated string.
Strings as array or pointer, are same but only the pointer version can use the increment
operator while array version does not support increment operator. To create an extra long
string, string is splitted into multiple sections, by closing the first section with a quote,
and recommencing the string on the next line (also starting and ending in a quote):
✞
1 char string[ ] = "This is a very , very long "
"string that requires two lines.";
✌
✆
See the example below
✞
#include <stdio.h>
2
int main () {
4 char ch;
char string[ ] = "Two lines "
6 "string.";
int i = 0;
8 while (string[i] != ’0’) {
ch = string[i];
10 printf("%c.", ch);
i++;
12 }
return (0);
14 }
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-77-2048.jpg)
![2.1. ARRAY 263
✞
T.w.o. .l.i.n.e.s. .s.t.r.i.n.g...
✌
✆
When an array is assigned the characters to get the string, there must be a terminating
null character. Otherwise there shall be garbage output. For example following syntax
has no terminating null character. It is not in standard format.
✞
1 char a[10];
a[0]= ’a’;
3 a[1]= ’r’;
a[2]= ’u’;
✌
✆
This format should be like
✞
char a[10];
2 a[0]= ’a’;
a[1]= ’r’;
4 a[2]= ’u’;
a[3]= ’0’;
✌
✆
See following two examples, in which string is terminating without and with null character.
First example gives garbage output (see below).
✞
1 #include <stdio.h>
3 int main () {
char a[10];
5 a[0]= ’a’;
a[1]= ’r’;
7 a[2]= ’u’;
printf("%s",a);
9 return 0;
}
✌
✆
✞
<garbage output >
✌
✆
In this second example, string is terminated with null character. This example gives
output what we required.
✞
1 #include <stdio.h>
3 int main () {
char a[10];
5 a[0]= ’a’;
a[1]= ’r’;
7 a[2]= ’u’;
a[3]= ’0’;
9 printf("%s",a);
return 0;
11 }
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-78-2048.jpg)
![264 Array & Pointer
✞
aru
✌
✆
Size of static array should be larger by one to the original data size being stored in the
array. This extra byte is for NULL terminator, i.e. 0. To store one byte data, array size
should be larger than one. For storing n byte data, array size should be > n. Here two
examples are given. In first example, array size is equal to the data size and in second
example, array size is larger than data size by one. This extra one byte is used to store
null terminating character.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (void ) {
5 /* Deficient static array *
* size declared as char c.*/
7 char c[1];
printf("Enter char ’e’ : ");
9 gets (c);
if (( strcmp(c, "e") == 0))
11 printf("%sn", c);
return 0;
13 }
✌
✆
On compilation, it gives error while following example gives desired output.
✞
1 #include <stdio.h>
#include <stdlib.h>
3
int main (void ) {
5 /* Suficient static array *
* size declared as char c.*/
7 char c[2];
printf("Enter char ’e’ : ");
9 gets (c);
if (( strcmp(c, "e") == 0))
11 printf("%sn", c);
return 0;
13 }
✌
✆
✞
e
✌
✆
In first example, array ‘c’ can store only character ‘c’. There is no extra space to store
null terminating character. It makes that array ‘c’ does not hold string in proper format.
In second example, array ‘c’ can store one character as well as null terminating character.
By this way it holds string in proper format.
2.1.6 Size of Array
C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated
at run-time). The length of a dynamic array cannot be acquired from the array itself -](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-79-2048.jpg)
![2.1. ARRAY 265
its length must be stored elsewhere. The size of static array is computed as
✞
1 int length = sizeof(<array name >) / sizeof(<array element >);
✌
✆
Preprocessor ways for array length is defined as
✞
1 #define ARRAY_LENGTH (A) (sizeof(A) / sizeof(A[0]) )
✌
✆
i0 i1 i2 i3 i4
3 6 9 12 15
anArray
n
Figure 2.12: Size of ‘anArray’ is the number of elements pointed by ‘anArray’. Here
remember that array is of integer type, hence each element shown in this figure needed
4 bytes long memory space. There are 5 elements in this array, so size of ‘anArray’ is 5
(n = 5) and these elements needed 5 × 4 = 20 bytes long memory space.
Array becomes pointer when it is passed as a parameter to a function. Thus, the length of
an array parameter may not require directly but a dedicated length parameter is required
and should be passed to the function. See the following example is given string array
‘fruit’ is declared with static size of 2 elements in each row while each row is pointed by
‘fruit’ pointer itself. Hence the element size is fixed so, there is no need to calculate the
length size of array. But in this example, length is computed by using above syntax.
✞
1 #include <stdio.h>
3 int main (){
const char *fruit[2] = { "apples", "oranges" };
5
/* Length of the array by dividing *
7 *the size of all elements by the*
*size of the first element. */
9
int length = sizeof(fruit) / sizeof(fruit[0]) ;
11
printf("%dn", length);
13
return 0;
15 }
✌
✆
✞
2
✌
✆
In above example, length of the array is obtained by dividing the size of all elements
(found with sizeof (fruit)) by the size of the first element. Note that since the array
elements are pointers to null-terminated character arrays, the size of the first element is
actually the size of the pointer type - not the length of the string. This size, regardless
of the type being pointed to, is 8 bytes, 4 bytes, or 2 bytes on 64-bit, 32-bit, or 16-bit](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-80-2048.jpg)
![266 Array & Pointer
platforms respectively. Pointer can be used for variable size array as shown in example
below.
✞
1 #include <stdio.h>
/* Variable size array.*/
3 char *name ;
int main () {
5 name ="My School!!";
int i=0;
7 while(name [i] !=’0 ’){
printf("%cn",name [i]);
9 i++;
}
11 return 0;
}
✌
✆
✞
M
y
S
c
h
o
o
l
!
!
✌
✆
2.1.7 Vector & Matrix
Vector is a one dimensional array or a matrix having one rows and multiple columns. A
vector is represented by A = [1, 2, 3, 5]. A matrix is vertical arrangement of vectors. Vec-
tors are one dimensional arrangement of coefficients of variables of an algebraic equation.
Let an algebraicequation ax + by = k, that is written as
ax + by − k = 0
Now, vector u for this algebraic equation is given by
u = [a, b, −k]
If there is a set of two algebraic equations,
ax + by − k = 0
cx + dy − l = 0
Then two vectors of these two algebraic equations are u and v respectively as
u = [a, b, −k]; v = [c, d, −l]](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-81-2048.jpg)
![2.1. ARRAY 267
The matrix arrangement like AX = B is
a b −k
c d −l
x
y
1
=
0
0
Here, matrix A is row arrangement of two vectors u and v. Similarly, for example, vectors
A = [1, 2, 3, 5] and B = [5, 4, 3, 2] form a matrix when these vectors are arranged vertically.
C =](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-82-2048.jpg)
![Here, C is a 2 × 4 matrix. A one dimensional vector is defined in C like
✞
#include stdio.h
2
int main (void ) {
4 int A[5];
int i;
6 for (i = 1; i 5; i++) {
A[i] = i;
8 }
for (i = 1; i 5; i++) {
10 printf(%dt, A[i]);
}
12 return 0;
}
✌
✆
✞
1 2 3 4
✌
✆
A matrix is defined in C like
✞
1 #include stdio.h
3 int main (void ) {
int A [2][5];
5 int i, j;
for (i = 0; i 2; i++) {
7 for (j = 0; j 4; j++) {
A[i][j] = i + j;
9 }
}
11 for (i = 0; i 2; i++) {
for (j = 0; j 4; j++) {
13 printf(%dt, A[i][j]);
}
15 printf(nn, A[i][j]);
}
17 return 0;
}
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-90-2048.jpg)
![268 Array Pointer
✞
0 1 2 3
1 2 3 4
✌
✆
In C, arrays, vectors and matrices are defined in same ways.
2.1.8 Sparse Matrix
A sparse matrix is one which have majority number of zeros along rows and columns. For
example a sparce matrix is
S =
0 0 0 0 0
0 1 2 0 1
0 2 1 0 2
0 0 0 0 0
0 1 2 0 1
C program for sparse matrix is given below:
✞
1 #include stdio.h
#include time .h
3
int main () {
5 time_t t1 , t2;
t1 = time (NULL );
7 static int array [10][10];
int i, j, m = 5, n = 5;
9 int counter = 0;
for (i = 0; i m; ++i) {
11 for (j = n; j 0; --j) {
t2 = time (NULL );
13 array[i][j] = (i * j + t2) % (t1 % 5 + 1);
if (array[i][j] == 0) {
15 ++ counter ;
}
17 }
}
19 printf(Matrix is : n);
for (i = 0; i m; ++i) {
21 for (j = 0; j n; ++j) {
printf(%dt, array[i][j]);
23 }
printf(n);
25 }
if (counter ((m * n) / 2)) {
27 printf(Matrix is sparse matrix n);
} else {
29 printf(Matrix is not a sparse matrix n);
}
31 printf(There are %d number of zeros.n, counter );](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-91-2048.jpg)
![270 Array Pointer
In which, each memory cell or memory location is identified by its address and it
contains a value. See an example given below. Read program line-by-line alongwith
comments carefully.
✞
#include stdio.h
2 int main (){
/*i points to memory location where 10 is stored. */
4 int i=10;
6 /* Pointer j points to a random address */
int *j;
8
/* Now j points to same address as i is pointing . */
10 j=i; // i and j points to same address.
12 /*j stored value at its address.*/
*j=20;
14
/*As i and j points to same memory location *
16 *( addresses ) therefore , values of i and j *
*are equal. So , i = 20. */
18 printf(%d,i); //i has same value as j;
return 0;
20 }
✌
✆
✞
20
✌
✆
An array name is also the address of the first element of the array. That is, if ‘arr’ is an
array, then
✞
1 arr == arr [0]; // name of array is the
// address of the first element
✌
✆
Both ‘arr’ and ‘arr[0]’ represent the memory address of first element of the array. It is
also called the reference of the array ‘arr’. A pointer can points to any element of the
array, if the pointer is assigned address of that element. In the following example, pointer
‘x’ points to the address of first element of the array ‘i’.
✞
#include stdio.h
2
int main () {
4 int i[5] = {10, 20, 30, 40, 50};
int *x = i[0]; /* Points to first element.*/
6 printf(%d, *x);
return 0;
8 }
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-93-2048.jpg)
![2.2. POINTER 271
0×10
10
0×11
20
0×12
30
0×13
40
0×14
50
i[ ]
x
The output of above program shall be
✞
10
✌
✆
If above example is modified as given below, then the pointer ‘x’ points to the 3rd
element of the array ‘i’.
✞
1 #include stdio.h
3 int main () {
int i[5] = {10, 20, 30, 40, 50};
5 int *x = i[2]; /* Points to third element.*/
printf(%d, *x);
7 return 0;
}
✌
✆
0×0
10
0×1
20
0×2
30
0×3
40
0×4
50
i[ ]
x
The output of above program shall be
✞
30
✌
✆
If an integer is pointed by a pointer-to-char variable, then this variable can points to
the address of each byte of the integer variable (integer variable is 4 bytes long).
✞
1 #include stdio.h
3 int main () {
/* 1000 D = 1111101001 B*/
5 int i = 1001;
/* Pointer casting from integer to character .*/
7 char *x = (char *) i;
/* Little endian is x[0]=11101001 B*
9 *Big endian is x[1]=00000011 B*
*Big endian x[2]= x[3]=00000000 B*/
11 /* Print little endian x[0]*/
printf(%d, (int) x[0]) ;
13 return 0;
}
✌
✆](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-94-2048.jpg)
![272 Array Pointer
x[3] x[2] x[1] x[0]
i:
x
00000000 00000000 00000011 11101001
Output of above program is
✞
-23
✌
✆
✞
1 #include stdio.h
3 int main () {
/* 1000 D = 1111101001 B*/
5 int i = 1001;
/* Pointer casting from integer to character .*/
7 char *x = (char *) i;
/* Little endian is x[0]=11101001 B*
9 *Big endian is x[1]=00000011 B*
*Big endian x[2]= x[3]=00000000 B*/
11 /* Print big endian x[1]*/
printf(%d, (int) x[1]) ;
13 return 0;
}
✌
✆
x[3] x[2] x[1] x[0]
i:
x
00000000 00000000 00000011 11101001
Output of above program is
✞
3
✌
✆
Though, the pointers allow increment and decrement operations but they are not
preferred over indexed arrays when there is requirement of random access. In indexed
arrays, fifth element can be accessed by myArr[4]. But in pointer array, we have to
first reach at the address of fifth element by using pointer increments or decrements
operations and then dereference the pointer. So, pointer requires extra coding to reach
at desire destination.
Identification of Pointer Type We know that, in C, a variable is declared as
✞
1 datatype var name ;
✌
✆
There are three main form of variable object declarations. (i) normal variables, (ii) arrays
and (iii) functions. Their prototypes are respectively](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-95-2048.jpg)
![2.2. POINTER 273
✞
1 int i; // normal variable
int k[10]; // array variable
3 int f(); // function variable
✌
✆
In above three declarations, priority is observed to identify the type of variable. In first
case, variable ‘i’ is normal integer type variable which stores integer values. It means
where ever it stores a value, it will be an integer. Priority of variable literal is lower
than square brackets or parentheses. A variable is followed by square brackets, then it is
treated as an array. Similarly, if a variable is followed by parentheses, then it is treated
as function. Now, the question is, how we identify the nature of variable when asterisk is
prefixed to variable literals to make it pointer variable as shown below:
✞
1 int *i;
int *k[10];
3 int *f();
✌
✆
Its answer is again priority listing. The priority of pointer symbol (asterisk) is less than
array symbol or parentheses. Hence first declaration is pointer to integer. In second
declaration, priority of variable ‘k’ goes with array symbol and asterisk makes it pointers.
Hence, it will be pronounce as “array k of pointers-to-integers”. Note that, datatype only
told about the type of data pointed by the pointers, not about the type of pointer itself.
Similarly, third declaration is “function which returns a pointer pointing-to-an-integer
value”. Remember, array always stores values and function always returns a value. Now,
parentheses are used to change the priority of asterisk like
✞
1 int *i;
int (*k)[10];
3 int (*f)();
✌
✆
The first declaration has no change. It is pointer to an integer. In second declaration,
priority of asterisk goes with ‘k’. Hence it is pronounce as “pointer ‘k’ to an array (due
to presence of square bracket) of integers (array stores integer type values)”. Similarly
third declaration is pronounced as “pointer ‘f’ points to a function (due to presence of
parentheses) which returns an integer value”. So, be careful while using pointers with
specific priorities. There is not change in the priority if data type is changed. For example,
only stored value at pointee address is changed to real (double data type) from integer if
above declaration is modified as
✞
1 double *i;
double (*k)[10];
3 double (*f)();
✌
✆
2.2.1 Declaring pointers
When a variable name is preceded by asterisk symbol during its declaration, it is called
pointer variable. In the following variable declarations:](https://crownmelresort.com/image.slidesharecdn.com/booksoncprogramminglanguage-anintroductiontobeginnersbyarunumrao3-211010165849/75/Notes-for-C-Programming-for-MCA-BCA-B-Tech-CSE-ECE-and-MSC-CS-3-of-5-by-Arun-Umrao-96-2048.jpg)
More Related Content
Similar to Notes for C Programming for MCA, BCA, B. Tech CSE, ECE and MSC (CS) 3 of 5 by Arun Umrao
Notes for C Programming for MCA, BCA, B. Tech CSE, ECE and MSC (CS) 3 of 5 by Arun Umrao
- 1. 200 Basic C 5myMacro (10 / 5); myMacro (15 / 5); 7 return 0; } ✌ ✆ ✞ 10 / 5 : 2 15 / 5 : 3 ✌ ✆ Tokens Body of a macro is considered as a string of tokens rather than a string of characters. C preprocessor tokens are the separate “words” in the body of a macro definition. They are separated from one another by white spaces. For example, the definition ✞ #define FOUR 2*2 ✌ ✆ has one token-the sequence 2*2, but the definition ✞ 1 #define SIX 2 * 3 ✌ ✆ has three tokens 2, *, and 3. Character, strings and token strings differ from each other. It depends on how how multiple spaces are treated in a macro body. The preprocessor doesn’t make calculations; it just substitutes strings. For example ✞ 1 #include <stdio.h> 3 #define SQUARE(X) X*X 5 int main (void ) { int x = 4; 7 printf("x = %dn", x); printf("SQUARE(x): %d", SQUARE(x)); 9 /* Above statement is equivalent to * 11 * printf (" SQUARE(x): %d", x*x); */ return 0; 13 } ✌ ✆ ✞ x = 4 SQUARE(x): 16 ✌ ✆ In above example value of ‘x’ is passed to predefined function ‘SQUARE(X)’ and the function replaces ‘X’ by ‘x’ as ‘x*x’ and ultimately ‘4*4’. Now the result is ‘16’. If the ‘x’ passed to the function as shown in the given example then ✞ #include <stdio.h> 2 #define SQUARE(X) X*X
- 2. 1.10. PROCEDURES &FUNCTIONS 201 4 int main (void ) { 6 int x = 2; printf("x = %dn", x); 8 printf("SQUARE(x): %d", SQUARE(x+2)); 10 /* above statement is equivalent to * * printf (" SQUARE(x): %d", x+2*x+2); */ 12 return 0; } ✌ ✆ ✞ x = 2 SQUARE(x): 8 ✌ ✆ Result is ‘8’ rather than predicted as ‘16’. The reason behind it is that when ‘x+2’ is passed to the function ‘SQUARE’, it replaces ‘X*X’ by ‘x+2’ as ‘x+2*x+2’ and it gives the ultimately result ‘2+2*2+2’ that is ‘8’. Again ✞ #include <stdio.h> 2 #define SQUARE(X) X*X 4 int main (void ) { 6 /* Initial declaration of x=2. */ int x = 2; 8 /* x=2 */ 10 printf("x = %dn", x); 12 /* In below line , x in incremented * * by 1and it becomes x=2+1=3 before* 14 * it passes to macro SQUARE(). */ printf("SQUARE(x): %d", SQUARE (++x)); 16 /* Above statement is equivalent to * 18 * printf (" SQUARE(x): %d", ++x*++x);* * Here again x is incremented by 1 * 20 * from its previous declaration * * and it becomes x =3+1=4. */ 22 return 0; } ✌ ✆ ✞ x = 2 SQUARE(x): 16 ✌ ✆ #if, #else, #elif, #endif These are also known as conditionals. The #if checks whether a controlling condition expression evaluates to zero or nonzero, and excludes or includes a block of code respec-
- 3. 202 Basic C tively. ✞ #if1 2 /* This block will be included */ #endif 4 #if 0 /* This block will not be included */ 6 #endif ✌ ✆ A simple example is ✞ #include <stdio.h> 2 /* Define row size 80*/ #define RSIZE 80 4 /*If row size is >200 set row size 200 */ #if RSIZE > 200 6 #undef RSIZE #define RSIZE 200 8 /* else if row size is <50 set row size 50*/ #elif RSIZE <50 10 #undef RSIZE #define RSIZE 50 12 /* Else set row size 100 :: it is true */ #else 14 #undef RSIZE #define RSIZE 100 16 #endif int main () { 18 printf("The row size is %d.n", RSIZE); do_A (); 20 return 0; } 22 /* Define row size 201*/ #define RSIZE_B 201 24 /*If row size is >200 set row size 200 :: It is true */ #if RSIZE_B > 200 26 #undef RSIZE_B #define RSIZE_B 200 28 /* else if row size is <50 set row size 50*/ #elif RSIZE_B <50 30 #undef RSIZE_B #define RSIZE_B 50 32 /* Else set row size 1001 */ #else 34 #undef RSIZE_B #define RSIZE_B 100 36 #endif 38 do_A () { 40 printf("The row size is %d.n", RSIZE_B); }
- 4. 1.10. PROCEDURES &FUNCTIONS 203 ✌ ✆ ✞ The row size is 100. The row size is 200. ✌ ✆ #ifdef & #ifndef The #ifdef is similar to #if, except that the code block following it is selected if a macro name is defined. In this respect, ✞ #ifdef NAME ✌ ✆ is equivalent to ✞ 1 #if defined NAME ✌ ✆ A simple example is ✞ 1 #include <stdio.h> #ifndef __cplusplus 3 #error A C++ compiler is required ! #endif 5 int main () { 7 printf("C++ compiler needed !!!"); return 0; 9 } ✌ ✆ The #ifndef is similar to #ifdef, except that the test is reversed: ✞ 1 #ifndef NAME ✌ ✆ is equivalent to ✞ 1 #if !defined NAME ✌ ✆ A simple example is ✞ 1 #include <stdio.h> #ifndef A 3 #define A 10 #endif 5 int main () { 7 printf(":-> %d.n", A); // printed "10" return 0; 9 } ✌ ✆ ✞ :-> 10. ✌ ✆
- 5. 204 Basic C #define #defineis used to define a preprocessor with known value. The syntax for this prepro- cessor is ✞ 1 #define <identifier > <token -string > ✌ ✆ A program written in C is known as macro. When the computer reads the code, it replaces all instances of a word with the specified expression. #define macro is used for this purpose. ✞ 1 #define PRICE_OF_PEN 5 ✌ ✆ When ever we want to print the price of pen, we use the word PRICE OF PEN instead of the number 5, preprocessor will replace all instances of PRICE OF PEN with 5, which the compiler will interpret as the literal integer 5. The preprocessor performs substitution, that is, PRICE OF PEN is replaced by 5. Increments or decrements operation are not allowed with preprocessor identifier. For example ✞ 1 PRICE_OF_PEN ++ /* equals to 5++*/ /*OR*/ 3 ++ PRICE_OF_PEN /* equals to ++5*/ ✌ ✆ are illegal and not allowed. Because above operation becomes ✞ 1 5++ /*OR*/ 3 ++5 ✌ ✆ and these are illegal in C. It means there is no need for a semicolon. The # and ## operators are used with the #define macro. Using # causes the first argument after the # to be returned as a string in quotes. For example, the function ✞ 1 #define as_string ( s ) # s ✌ ✆ will make the compiler turn this function ✞ 1 puts ( as_string ( Hello World! ) ) ; ✌ ✆ into ✞ 1 puts ( "Hello World!" ); ✌ ✆ ✞ 1 #include <stdio.h> #include <string.h> 3 #define as_string ( s ) # s 5 int main () { puts ( as_string (Hello World !!!!)); 7 return 0; } ✌ ✆
- 6. 1.10. PROCEDURES &FUNCTIONS 205 ✞ Hello World !!!! ✌ ✆ Symbol ## concatenates what is before the ## with what is after it. After concate- nation, strings becomes tokens. For example, in the following code snippets, function ‘concatenate’ converts two strings passed without double quotes, say x and y into token xy. ✞ 1 #define concatenate ( a, b ) a ## b ... 3 int xy = 10; ... ✌ ✆ When this preprocessor is called from anywhere as shown in the below code line, ✞ printf( "%d", concatenate ( x, y )); ✌ ✆ compiler turns this code line as ✞ 1 printf( "%d", xy); ✌ ✆ which will, of course, display 10 in the standard output. ✞ 1 #include <stdio.h> #include <string.h> 3 #define concatenate ( a, b ) a ## b 5 int main () { int xy = 10; 7 printf("%d", concatenate (x, y)); return 0; 9 } ✌ ✆ ✞ 10 ✌ ✆ It is possible to concatenate a macro argument with a constant prefix or suffix to obtain a valid identifier as in ✞ 1 #define make_function ( name ) int my_ ## name (int foo) {} make_function ( bar ) ✌ ✆ which will define a function called my bar(). But it isn’t possible to integrate a macro argument into a constant string using the concatenation macro. In order to obtain such an effect, one can use the ANSI C property that two or more consecutive string constants are considered equivalent to a single string constant when encountered. Using this property, one can write ✞ #define eat( what ) puts ( "I’m eating " #what " today." ) 2 eat( fruit ) ✌ ✆
- 7. 206 Basic C whichthe macro-processor will turn into ✞ puts ( "I’m eating " "fruit" " today." ) ✌ ✆ which in turn will be interpreted by the C parser as a single string constant. The following trick can be used to turn a numeric constants into string literals ✞ 1 #define num2str (x) str(x) #define str(x) #x 3 #define CONST 23 puts (num2str (CONST)); ✌ ✆ This is a bit tricky, since it is expanded in 2 steps. First ‘num2str(CONST)’ is replaced with str(23), which in turn is replaced with “23”. ✞ #include <stdio.h> 2 #include <string.h> #define num2str (x) str(x) 4 #define str(x) #x #define CONST 23 6 int main () { 8 puts ( num2str(CONST)); return 0; 10 } ✌ ✆ ✞ 23 ✌ ✆ Using of catecanation symbol ‘##’ is useful when we have to create different user defined functions with same signature of function which are being called through their pointer addresses. See the example below, in which we have create a function by using ‘##’ symbol. ✞ 1 #include <stdio.h> 3 #define init_fcn (name , type ) /* Create structure for object ‘age’*/ 5 typedef struct { 7 type value; } F## name ; 9 /* Create mf_age function */ inline F## name mf_## name (type v) 11 { F## name t; 13 t.value = v; return t; 15 } 17 int main () { init_fcn (age , int);
- 8. 1.10. PROCEDURES &FUNCTIONS 207 19 init_fcn (Roll , int); printf("%dn",mf_age (20) ); 21 printf("%dn",mf_Roll (1020)); return 0; 23 } ✌ ✆ ✞ 20 1020 ✌ ✆ A macro assigned with a numerical value using #define preprocessor can be assessed from anywhere in the program. But it can not be assigned new value within the pro- gram. To change the assigned value to a macro, it should be redefined by using #define preprocessor. ✞ #include <stdarg.h> 2 #define MAX_NO 100 4 int main () { printf("Maximum Nos is %d.n", MAX_NO); 6 #define MAX_NO 10 printf("Maximum Nos is %d.n", MAX_NO); 8 MAX_NO =50; // Illegal assignment . Shows error printf("Maximum Nos is %d.n", MAX_NO); 10 return 0; } ✌ ✆ Example for preprocessor #define is given below ✞ 1 #include <stdio.h> #define getmax(a,b) ((a) >(b)?(a):(b)) 3 int main () { 5 int y; y = getmax (5, 2); 7 printf("The max value is %d.", y); return 0; 9 } ✌ ✆ ✞ The max value is 5. ✌ ✆ Use of #define function must be used carefully when the defined value is to be used in mathematical expression. See the example below: ✞ 1 #include <stdio.h> #define PI 3.142857143 /* First form of defining macro.*/ 3 int main () { 5 double i = 2 * PI / 3; printf("i is %lf", i); 7 return 0;
- 9. 208 Basic C } ✌ ✆ Theexpression line of above example ✞ double i = 2 * PI / 3; ✌ ✆ The ‘PI’ is replaced by the macro value ‘3.14’ as ✞ 1 double i = 2 * 3.142857143 / 3; ✌ ✆ And the program gives result ✞ i is 2.095238 ✌ ✆ Now, see the example shown below, in which the ‘PI’ macro value is changed in rational form even though its numerical value is same. ✞ 1 #include <stdio.h> 3 #define PI 22 / 7 /* Rational form . */ /*Here , 22/7 is equal to 3 numerically */ 5 int main () { 7 double i = 2 * PI / 3; printf("i is %lf", i); 9 return 0; } ✌ ✆ This form of defining a value is wrong. See the reason in following lines. Assume that, ‘PI’ is defined as shown below ✞ #define PI 22 / 7 ✌ ✆ When preprocessor is replaced by its expression, the expression i becomes as ✞ 1 double i = 2 * PI / 3; ✌ ✆ At the time of compilation, preprocessor value of PI is used as 3 rather than 3.142857143. Now, the value of i becomes ✞ 1 double i = 2 * 3 / 3; ✌ ✆ On solving this expression, the final result thus obtained is 2, which is not what we expected. ✞ i is 2.000000 ✌ ✆ For desired output, proprocessor PI should be defined as (float)22/7 instead of 22/7. See the modified form of above example.
- 10. 1.10. PROCEDURES &FUNCTIONS 209 ✞ 1 #include <stdio.h> 3 #define PI (float) 22 / 7 5 int main () { double i = 2 * PI / 3; 7 printf("i is %lf", i); return 0; 9 } ✌ ✆ ✞ i is 2.095238 ✌ ✆ The preprocessors may be defined either before or after the header inclusion. In both cases, output is same. ✞ 1 #define NOS 10 3 #include <stdio.h> 5 int main () { printf("%d",NOS); 7 } ✌ ✆ ✞ 10 ✌ ✆ ANSI C defines some useful preprocessor macros and variables, also called “magic con- stants”. ✞ 1 __ FILE __ => The name of the current file , as a string literal. __ LINE __ => Current line of the source file , as a numeric literal . 3 __ DATE __ => Current system date , as a string. __ TIME __ => Current system time , as a string. 5 __ TIMESTAMP __ => Date and time (non - standard ). __ cplusplus => undefined when your C code is being compiled by a C compiler . 7 __ func __ => Current function name of the source file , as a string. ✌ ✆ A simple example for using of preprocessors is derived in three parts. Main part, sum part and preprocessors for sum part. Following is the code of ‘sum.h’ preprocessor ✞ 1 #ifndef SUM_H #define SUM_H 3 #ifdef __cplusplus extern "C" { 5 #endif /* function identifier for sum_f() defined in sum.c*/ 7 int sum_f(int a, int b); #ifdef __cplusplus 9 }
- 11. 210 Basic C #endif 11#endif /* SUM_H */ ✌ ✆ Codes of sum function is define in the file ‘sum.c’. ✞ 1 /* sum_f() function for adding two numbers */ int sum_f(int a, int b) { 3 int c; c = a + b; 5 return c; } ✌ ✆ Main function for calling a procedure is defined in ‘main.c’ file as ✞ #include <stdio.h> 2 /* sum.h header contains sum_f() function * * that should be indentified and called. */ 4 #include "sum.h" 6 int main (void ){ int a=2,b=3; 8 /* sum_f() function is called from * *sum.c and identified via sum.h */ 10 int c=sum_f(a,b); printf("The sum of 2 and 3 is %d.",c); 12 return 0; } ✌ ✆ When program is compiled and run the output is ✞ The sum of 2 and 3 is 5. ✌ ✆ If a macro produces multiple statements, or declares variables, it can be wrapped in a do { ... } while(0) loop, with no terminating semicolon. This allows the macro to be used like a single statement in any location. ✞ 1 #define FREE (p) free (p); p = NULL ; /* Bad practice .*/ #define FREE (p) do { free (p); p = NULL ; } while(0) /* Good practice .*/ ✌ ✆ 1.10.7 Type Converter Following is an example of string to integer conversion. ✞ #include <stdio.h> 2 #include <string.h> 4 int main (int argc , char *argv [ ]) { char st [10] = "This "; 6 printf("String ’%s’ = integer %d.n", st , (int) st);
- 12. 1.11. PARSING ARGUMENTS211 return 0; 8 } ✌ ✆ ✞ String ’This ’ = integer 2280640. ✌ ✆ 1.11 Parsing Arguments When a program is being executed via another program internally, arguments are required to be passed to the executable ie the program. These arguments are considered as inputs for the executable. To pass the values we define main() function as ✞ 1 int main (int argc , char *argv [ ]) ✌ ✆ Here argc counts the number of arguments in an array and argv assigns the values to each respective counter. ✞ 1 #include <stdio.h> #include <string.h> 3 #include <stdlib.h> 5 /* main function is modified according to* *receive the arguments in command line */ 7 int main (int argc , char *argv [ ]) { int argnum = 0; 9 /* Starting from zero */ while (argc > ++ argnum) 11 printf("Argument %d of arguments %d is %c.n", argnum , 13 argc , *argv [argnum ]); 15 exit ( EXIT_SUCCESS ); } ✌ ✆ After compiling and executing the executable as ✞ executable .exe a b c ✌ ✆ Output is ✞ Argument 1 of supplied four arguments is a. Argument 2 of supplied four arguments is b. Argument 3 of supplied four arguments is c. ✌ ✆ Here executable.exe in command-line is also considered as an argument. This is why there are four arguments and first argument, ie 0th argument, is executable.exe itself and rest of the arguments are a, b and c respectively. An other example is given below
- 13. 212 Basic C ✞ 1#include <stdio.h> 3 int main (int argc , char ** argv ) { size_t i; 5 for (i = 0; i < argc ; i++) { 7 /* get all the arguments as options * *and initialize option pointer . */ 9 char const *option = argv [i]; /* Get first character of an option argument */ 11 if (option [0] == ’-’) { /*If first character of an option argument * 13 *is ’-’, then following character is a flag */ printf("Flagged option.n"); 15 /* get the second character of an option argument .*/ switch (option [1]) { 17 /*If second char of an option argument * *is ’e’, then print encryption */ 19 case ’e’: printf("You have chosen %c:ENCryption . n", option [1]) ; 21 break; /*If second char of an option argument * 23 *is ’d’, then print decryption */ case ’d’: 25 printf("You have chosen %c:DECryption . n", option [1]) ; break; 27 /*If second char of an option argument * *is ’f’, then print filename */ 29 case ’f’: printf("Your have chosen file name %c.n", option [1]) ; 31 break; /* other wise */ 33 default : printf("I can not understand your option %sn", option); 35 break; } 37 } else { printf("No Flagged Options .n"); 39 } } 41 return 0; } ✌ ✆ When above example is compiled and executed like ✞ executable .exe -e -f ✌ ✆
- 14. 1.11. PARSING ARGUMENTS213 The output at console is ✞ No Flagged Option. Flagged Option. You have chosen e:ENCryption . Flagged Option. You have chosen filename f. ✌ ✆ The first output “No Flagged Option” is appeared at the console at first as ‘exe- cutable.exe’ is considered as first parsing argument and it is not prefixed with ‘–’. Using array and pointer we do reverse to a parsed string via command line is given below. ✞ 1 #include <stdio.h> #include <stdlib.h> 3 /* String Length*/ #define SLen 4 5 int main (int argc , char *argv [ ]) { 7 /* Get the commandline string*/ char *name = argv [1]; 9 char nameR [10]; int i; 11 for (i = 0; i < SLen ; i++) /* Store each character of string in array*/ 13 nameR[i] = name [i]; 15 for (i = 4; i > 0; --i) /* Print each character of stored string in array*/ 17 printf("%c", nameR[i - 1]); exit ( EXIT_SUCCESS ); 19 } ✌ ✆ Similarly the string length of given string can also be obtain by using following example ✞ 1 #include <stdio.h> 3 int main (int argc , char *argv [ ]) { if (argv [1] == NULL ) { 5 printf("Use <utility .exe > <string in quote or double quote >.n"); exit (0); 7 } /* Get the commandline string*/ 9 char *name = argv [1]; int i = 0; 11 while (name [i] != NULL ) i++; 13 printf("The length of string is %d", i); return 0; 15 } ✌ ✆
- 15. 214 Basic C 1.11.1Array To Integer atoi() function is used to convert an array into integer. This function is very useful for the conversion of number arguments passed as array or pointer into integer value. The use of syntax is explained in the following example. ✞ 1 #include <stdio.h> #include <stdlib.h> 3 int main (int argc , char *argv [ ]) { 5 if (argv [1] == NULL ) { printf("Use <utility .exe > <string >.n"); 7 exit (0); } 9 int i; i = atoi (argv [1]) ; 11 printf("Array to integer is %d.", i); exit ( EXIT_SUCCESS ); 13 } ✌ ✆ Without atoi(), we can also convert an array into integer by using simple mathematics as explained in the following example. ✞ 1 #include <stdio.h> 3 int main () { char intg [ ] = "1234 "; 5 int i = 0, res = 0; /* Here res must be initialized . Otherwise * 7 *product of res and 10 shall be null value*/ while (intg [i] != ’0’) { 9 /* Product of res with 10. res must not be null .* * (intg [i] % 48) is used to convert integer * 11 * charcode into integer value. Charcode of 0 is* * 48. Similarly , charcode of 1 is 49 and so on */ 13 res = res * 10 + (intg [i] % 48); i++; 15 } printf("%dn", res); 17 return 0; } ✌ ✆ ✞ 1234 ✌ ✆ We can also used pointers for array to integer conversion. Above example is modified as it is given below: ✞ 1 #include <stdio.h> 3 int main () { char *intg = "1234 ";
- 16. 1.12. MATHEMATIS 215 5int i = 0, res = 0; /* Here res must be initialized . Otherwise * 7 *product of res and 10 shall be null value*/ while (* intg != ’0 ’) { 9 /* Product of res with 10. res must not be null .* * (intg [i] % 48) is used to convert integer * 11 * charcode into integer value. Charcode of 0 is* * 48. Similarly , charcode of 1 is 49 and so on */ 13 res = res * 10 + (* intg % 48); intg ++; 15 } printf("%dn", res); 17 return 0; } ✌ ✆ atoi() function is used to convert an integer array into integer value. Integer value “1234” as string is stored in memory as a group of characters. Each character is one byte long. 1 2 3 4 i : Value at byte : 00000001 00000010 00000011 00000100 Integer value “1234” in numeric form is stored in 4 bytes long memory space, allocated for solely storing of integer. i : Num value : 00000000 00000000 00000100 11010010 1234 1.12 Mathematis In C programming addition, subtraction, multiplication and division mathematical op- erators can be directly used. Modulus is another mathematical operators that gives the remainder value. Application of these operators are a + b, a − b, a ∗ b, a/b and a%b respectively. ✞ #include <stdio.h> 2 #include <string.h> int a, b; 4 int main (void ) { 6 int a = 5; int b = 2; 8 int add = a + b; int sub = a - b; 10 int mul = a*b; int div = a / b; 12 int mod = a % b;
- 17. 216 Basic C printf("Additionof %d and %d is : %d n", a, b, add); 14 printf("Subtraction of %d and %d is : %d n", a, b, sub); printf("Multiplication of %d and %d is : %d n", a, b, mul); 16 printf("Division of %d and %d is : %d n", a, b, div); printf("Modulus of %d and %d is : %d n", a, b, mod); 18 return 0; } ✌ ✆ Output of above program is ✞ Addition of 5 and 2 is : 7 Subtraction of 5 and 2 is : 3 Multiplication of 5 and 2 is : 10 Division of 5 and 2 is : 2 Modulus of 5 and 2 is : 1 ✌ ✆ A pointer can also be used in the addition, subtraction, multiplication and division of two or more numbers. ✞ 1 #include <stdio.h> 3 func (int *i, int*j) { *i = *i * *i; 5 *j = *j* *j; } 7 main () { 9 int i = 5, j = 2; func (&i, &j); 11 printf("%d %d", i, j); return 0; 13 } ✌ ✆ ✞ 25, 4 ✌ ✆ 1.12.1 Trigonometric Functions “math.h” preprocessor file provides the mathematical functions that can be used directly in the program. Some of them are defined in following sections. cos, sin & tan The cos, sin, and tan functions return the cosine, sine, and tangent of the argument, expressed in radians. The domain of arguments of sin, cos and tan are [−π/2, π/2], [0, π] and [−π/2, π/2] respectively. The numerical range of sin, cos and tan are [−1, 1], [−1, 1] and [−∞, ∞]. ✞ 1 #include <math .h> double cos(double x);
- 18. 1.12. MATHEMATIS 217 3double sin(double x); double tan(double x); ✌ ✆ A simple example is ✞ #include <stdio.h> 2 #include <math .h> 4 int main (void ) { printf("Cosine at 22/7 radian is : %f n", cos (22/7)); 6 printf("Sine at 22/7 radian is : %f n", sin (22/7)); printf("Tangent at 22/7 radian is : %f n", tan (22/7)); 8 return 0; } ✌ ✆ ✞ Cosine at 22/7 radian is : -0.989992 Sine at 22/7 radian is : 0.141120 Tangent at 22/7 radian is : -0.142547 ✌ ✆ Solved Problem 1.8 A right angle triangle having base 20cm and height h. The angle of triangle facing to side h is 30◦ , then find the height of the triangle. Solution We know that in right angle triangle, one angle is 90◦ . If angle facing to the side of hcm is 30◦ then tan 30◦ = h b = h 20 It gives, the height of the triangle h = 20/ √ 3cm. ✞ 1 #include <stdio.h> #include <math .h> 3 #define PI 3.14 5 double DtoR (int x) { return x * PI / 180; 7 } 9 int main () { double h; 11 double b = 20.0; int th = 30; /*in degree */ 13 h = b * tan(DtoR (th)); printf("The height of the triangle is %lf", h); 15 return 0; } ✌ ✆ ✞ The height of the triangle is 11.539928 ✌ ✆
- 19. 218 Basic C acos,asin & atan The acos() functions return the arccosine of their arguments in radians, and the asin() functions return the arcsine of their arguments in radians. All functions expect the argument in the range [−1, +1]. The arccosine returns a value in the range [0, π]; the arcsine returns a value in the range h − π 2 , π 2 i . The atan() returns their argument value in radian in the range h − π 2 , π 2 i . Method of use of inverse function in following systems. ✞ 1 #include <math .h> double asin (double x); 3 double acos (double x); double atan (double x); ✌ ✆ A simple example is ✞ #include <stdio.h> 2 #include <math .h> 4 int main (void ) { printf("Arc cosine at argument 0.5 is : %f n", acos (0.5)); 6 printf("Arc sine at argument 0.5 is : %f n", asin (0.5)); printf("Arc tangent at argument 1.5 is : %f n", atan (1.5)); 8 return 0; } ✌ ✆ ✞ Arc cosine at argument 0.5 is : 1.047198 Arc sine at argument 0.5 is : 0.523599 Arc tangent at argument 1.5 is : 0.982794 ✌ ✆ cosh, sinh & tanh The cosh(), sinh() and tanh() functions compute the hyperbolic cosine, the hyperbolic sine and the hyperbolic tangent of the argument respectively. ✞ 1 #include <math .h> double cosh (double x); 3 double sinh (double x); double tanh (double x); ✌ ✆ A simple example is ✞ #include <stdio.h> 2 #include <math .h> 4 int main (void ) { printf("Hyperbolic cosine of 0.5 is : %f n", cosh (0.5)); 6 printf("Hyperbolic sine of 0.5 is : %f n", sinh (0.5)); printf("Hyperbolic tangent of 1.5 is : %f n", tanh (1.5)); 8 return 0;
- 20. 1.12. MATHEMATIS 219 } ✌ ✆ ✞ Hyperboliccosine at argument 0.5 is : 1.127626 Hyperbolic sine at argument 0.5 is : 0.521095 Hyperbolic tangent at argument 1.5 is : 0.905148 ✌ ✆ acosh, asinh & atanh The acosh() functions compute the inverse hyperbolic cosine of the argument. A domain error occurs for arguments less than 1. The asinh() and atanh() functions compute the inverse hyperbolic sine and inverse hyperbolic tangent of the argument respectively. ✞ 1 #include <math .h> double acosh(double x); 3 double asinh(double x); double atanh(double x); ✌ ✆ A simple example is ✞ #include <stdio.h> 2 #include <math .h> 4 int main (void ) { printf("Hyp inverse cosine of 0.5 is : %f n", acosh (0.5)); 6 printf("Hyp inverse sine of 0.5 is : %f n", asinh (0.5)); printf("Hyp inverse tangent of 1.5 is : %f n", atanh (1.5)); 8 return 0; } ✌ ✆ ✞ Hyperbolic inverse cosine at argument 0.5 is : nan Hyperbolic inverse sine at argument 0.5 is : 0.481212 Hyperbolic inverse tangent at argument 1.5 is : nan ✌ ✆ 1.12.2 Logarithm Function Exponential & Logarithm exp() represents the exponential of a value x with base ‘e’. log() represents the logarithm of a value in natural base ‘e’. ✞ 1 #include <math .h> double exp(double x); 3 double log(double x); ✌ ✆ A simple example is
- 21. 220 Basic C ✞ 1#include <stdio.h> #include <math .h> 3 int main (void ) { 5 printf("Exponential of 0.5 is : %f n", exp (0.5)); printf("logarithm of 0.5 at base 10 is : %f n", log (0.5)); 7 return 0; } ✌ ✆ ✞ Exponential of 0.5 is : 1.648721 logarithm of 0.5 at base 10 is : -0.693147 ✌ ✆ 1.12.3 Arithmetic Function In C, symbol ˆ does not represent to power but presents to XOR bitwise operation. In ‘math.h’ preprocessor provides the power operation via pow() function. Power pow() accepts two values. First is base, (b) and second is exponent, (e). Mathematically this function is equivalent to Y = be This function is used as ✞ double pow(double x, double y); ✌ ✆ A table consisting cube of first 10 integers ranging from 1 to 10 is shown below. The formula used is y = i3 Here, 3 is exponent or power and i is base. Base Exp Result, y 1 3 1 2 3 8 3 3 27 4 3 64 5 3 125 6 3 216 7 3 343 8 3 512 9 3 729
- 22. 1.12. MATHEMATIS 221 Asimple example is ✞ 1 #include <stdio.h> #include <math .h> 3 int main (void ) { 5 printf("Power of 2 on base 3 is : %f n", pow(3, 2)); return 0; 7 } ✌ ✆ ✞ Power of 2 on base 3 is : 9.000000 ✌ ✆ Square Root sqrt() returns the square root of a given value. Mathematically it is represented as y = √ i Where, i is any number. The syntax of this function is given below: ✞ 1 double sqrt (double x); ✌ ✆ A table consisting square root of few specific numbers is given below. The formula used is y = √ i Integer Squre Root, y 1 1.00 2 1.41 3 1.73 4 2.00 5 2.24 6 2.45 7 2.65 8 2.83 9 3.00 A simple example is ✞ 1 #include <stdio.h> #include <math .h> 3
- 23. 222 Basic C intmain (void ) { 5 printf("Square root of 1.45 is : %f n", sqrt (1.45)); return 0; 7 } ✌ ✆ ✞ Square root of 1.45 is : 1.204159 ✌ ✆ Floor floor() function accepts a real number. Result of floor value of a real number is, either perfect integer positive or negative as the case may be which is either equal to or less than the given number. Its syntax is given by ✞ 1 double floor(double x); ✌ ✆ -3 -2 -1 0 1 2 3 b −1.5 bc floor(−1.5) b 1.5 bc floor(1.5) A table consisting few positive and negative numbers with their corresponding floor value, is given below. Real Number floor(r) -2.25 -3.00 -2.75 -3.00 -3.00 -3.00 2.25 2.00 2.75 2.00 3.00 3.00 A simple example is ✞ 1 #include <stdio.h> #include <math .h> 3 int main (void ) { 5 printf("Floor of 1.45 is : %f n", floor (1.45)); printf("Floor of -1.45 is : %f n", floor( -1.45) ); 7 return 0; } ✌ ✆
- 24. 1.12. MATHEMATIS 223 ✞ Floorof 1.45 is : 1.000000 Floor of -1.45 is : -2.000000 ✌ ✆ Ceiling ceil() function accepts a real number. Result of ceiling value of a real number is the perfect integer, either positive or negative as the case may be, which is either equal to or greater than the given number. ✞ double ceil (double x); ✌ ✆ -3 -2 -1 0 1 2 3 b −1.5 bc floor(−1.5) bc ceil(−1.5) -3 -2 -1 0 1 2 3 b 1.5 bc floor(1.5) bc ceil(1.5) A table consisting few positive and negative numbers with their corresponding ceiling value, is given below. Real Number ceil(r) -2.25 -2.00 -2.75 -2.00 -3.00 -3.00 2.25 3.00 2.75 3.00 3.00 3.00 A simple example is ✞ 1 #include <stdio.h> #include <math .h> 3 int main (void ) { 5 printf("Ceil of 1.4855 is : %f n", ceil (1.4855) ); printf("Ceil of -1.4855 is : %f n", ceil ( -1.4855) ); 7 return 0; } ✌ ✆
- 25. 224 Basic C ✞ Ceilof 1.4855 is : 2.000000 Ceil of -1.4855 is : -1.000000 ✌ ✆ Rounds Off round() function rounds off a fraction number to its nearest perfect integer. The fractional part about which number is rounded-off is 0.5. This definition is advanced with following rules. 1. If non-significant digit is less than 5 and is to be rounded off, the previous digit does not change and non-significant digit is simply dropped. For example 2.301 is significant upto the second place of the decimal then digit 1 is simply dropped and number is rounded off to 2.30. Similarly 2.304 is rounded off upto two place of decimal as 2.30. 2. If non-significant digit is greater than 5 and is to be rounded off, the previous digit (left side digit) is raised by 1 and non-significant digit is dropped. For example 2.306 is significant upto the second place of the decimal then digit 6 is simply dropped and previous digit (left side digit) 0 is raised by 1 and number is rounded off to 2.31. 3. If the rounding off digit is greater than 5, rounding off digit is simply dropped when the previous digit (left side digit) is even. For example, when 2.3546 is rounded off, result is 2.354. 4. If the rounding off digit is greater than 5, rounding off digit is dropped and previous digit (left side digit) is raised by 1 when the previous digit (left side digit) is odd. For example, when 2.3576 is rounded off, result is 2.358. 5. In mathematics and specially in pure science, the large numbers are mostly written in scientific notation form. Hence these numbers are rounded-off upto significant digits. To round-off a large number upto n digits, the rounding-off process is always started from leftmost non-zero digit. For example start process from 2 in 2500 and from 3 in 0.0325. 6. Keep n significant digits and replace rest of digits with zeros. 7. Write number in scientific notation, i.e. a × 10±b form, where a and b are real and significant numbers. 8. Round off mantissa upto the last significant digit. For example 0.2336 can be written as 2.336 × 10−1 in scientific notation and if there are only three significant digits then third significant digit becomes 4 and number becomes 2.34 × 10−1 . Rest of digits are dropped. The syntax of this function is given below: ✞ double round(double x); ✌ ✆
- 26. 1.12. MATHEMATIS 225 round()function in math library of C is loosely based on the basic rule of round-off. Hence in each case, if rounding-off digit is equal to or larger than 5, then previous digit is raised by 1. A simple example is ✞ 1 #include <stdio.h> #include <math .h> 3 int main (void ) { 5 printf("Rounding of 1.4 is : %f n", round (1.4)); printf("Rounding of 1.6 is : %f n", round (1.6)); 7 return 0; } ✌ ✆ ✞ Rounding of 1.4 is : 1.000000 Rounding of 1.6 is : 2.000000 ✌ ✆ 0 1 2 3 b 1.6 bc round(1.6) b 1.4 bc round(1.4) Round off negative numbers in C program is given below: ✞ #include <stdio.h> 2 #include <math .h> 4 int main (void ) { printf("Rounding of -1.4 is : %f n", round( -1.4)); 6 printf("Rounding of -1.6 is : %f n", round( -1.6)); return 0; 8 } ✌ ✆ ✞ Rounding of -1.4 is : -1.000000 Rounding of -1.6 is : -2.000000 ✌ ✆ -3 -2 -1 0 b −1.6 bc round(−1.6) b −1.4 bc round(−1.4) Rounding off a number cause rounding off errors. For example a real number 2.56889 is actual real number is which is rounded off upto 4th decimal place. It becomes 2.5689. Now the difference of the two values is 2.56889 − 2.5689 = −0.00001. It is error arises due to rounding off a real number.
- 27. 226 Basic C 1.12.4Float Point Arithmetic A float or a double has three components, (i) a sign bit, (ii) exponent and (iii) mantissa. A floating point number is written as f = ±m × b±e Here, m is mantissa of the number, b is base, i.e. 2 in IEEE-754 standards. e is exponent of the floating point number. In this section we shall use single point (float) floating numbers. A float data type number is 32 bits long and has three components, (i) a sign bit (first bit from left side), (ii) an exponent (next 8 bits from left side) and (iii) a mantissa (rest of 23 bits). The exponent is an excess-127 binary notation. This binary number is also known as exponent bias. Binary Equivalent Desired Exponent · · · · · · 01111100 -3 01111101 -2 01111110 -1 01111111 0 10000000 1 10000001 2 10000010 3 · · · · · · In this notation, binary number 01111111, equivalent to decimal 127 is a binary ex- ponent equivalent to decimal 0. The next binary exponent i.e. sum of binary 01111111 and bit 1 represents to exponent equivalent to decimal 1 (equivalent to binary 10000000). Similarly, subtraction of bit 1 from 01111111 represents to exponent equivalent to deci- mal −1 (equivalent to binary 01111110). Remember that for binary equivalent form of floating point numbers, base is 2, i.e. exponent binary 01111111 is equal to in decimal form of 20 , exponent binary 10000000 means 21 , exponent binary 01111110 means 2−1 and so on. 125 126 127 128 129 01111101 01111110 01111111 10000000 10000001 −2 −1 0 1 2 2−2 2−1 20 21 22 Decimals Excess-127 e-Line 2e Value
- 28. 1.12. MATHEMATIS 227 Thedecimal exponent equivalent to binary exponent is obtained by subtracting 01111111 from the given binary exponent. The mantissa binary numbers are solved from left side to right side. Here, we are dealing with binary fractions, so the leftmost mantissa bit means 2−1 , the next right bit has meaning of 2−2 and so on. The place values of mantissa bits from left side to right side are 2−1 , 2−2 , 2−3 etc. The first bit of a non-zero binary significant is always 1. Hence mantissa in fractions is given by M = 1 + n X i=1 biti × 2−i Here, i is ith bit counted from left hand side to right hand side in mantissa part. n is total number of significant digits in mantissa. Illustrated Example Assume a floating point representation ‘0 0111 1100 0000 0000 0000 0000 0000 000’ shown in binary form. The sign bit of this binary number is ‘0’, hence it is positive value. The exponent binary number is 01111100 and mantissa number is 0000 0000 0000 0000 0000 000. Note that if left most digit of the binary exponent part of floating point number is ‘0’, then exponent is obtained by subtracting 01111111 from the given binary exponent. Here, binary subtraction of 01111100 -01111111 -00000011 which is equivalent to decimal −3. The exponent value is −3. The mantissa part is all zero, hence M = 1 + 23 X i=1 biti × 2−i gives mantissa ‘1’. Now, the number is r = 1 × 2−3 It gives 0.125. Illustrated Example Assume a floating point representation ‘0 1010 0110 1101 0001 1010 1001 0100 101’ shown in binary form. The sign bit of this binary number is ‘0’, hence it is positive value. The exponent binary number is 10100110 and mantissa number is 1101 0001 1010 1001 0100 101. Note that, if the left most digit is of binary exponent is ‘1’, then exponent is obtained by subtracting 01111111 from the given binary exponent. Here, binary subtraction of 10100110 -01111111 00100111
- 29. 228 Basic C whichis equivalent to decimal 39. The exponent value is 39. The mantissa part is M = 1 + 23 X n bitn × 2−n gives mantissa ‘1.818989396095270’. Now, the number is r = 1.818989396095270 × 239 It gives 999999995904. Numerical programming languages use double type floating point mathematics. Therefore each number is denoted as float point, i.e. 1.0 as 1.000000, 0.5 as 0.500000. Sometime, even zero is represented as 2.5×10−18 or as 13.2×10−19 etc. where these values are very very small and are close to zero. Here zero is taken as comparative value rather than absolute value. For example, sometimes, in numerical calculations, identity matrix is represented as
- 36. 1 3.5 ×10−12 35 × 10−12 1
- 43. Operators in FloatPoints Arithmetic Normally, all the arithmetic operators may be used in floating point arithmetic. In float point arithmetic, mixing of two different floating points are allowed. A float or double data type value can be used with int data type value. The result of mixed data type values is extended to match the precision of the more precise data type value. Floating point division does not discard the fractional part and produce round off errors. ✞ #include <stdio.h> 2 int main (void ) { 4 printf("2 + 2.0 is %fn", 2 + 2.0) ; printf("2 - 2.0 is %fn", 2 - 2.0) ; 6 printf("2 / 2.0 is %fn", 2 / 2.0) ; printf("2 * 2.0 is %fn", 2 * 2.0) ; 8 return 0; } ✌ ✆ ✞ 2 + 2.0 is 4.000000 2 - 2.0 is 0.000000 2 / 2.0 is 1.000000 2 * 2.0 is 4.000000 ✌ ✆ Few operators do not work with floating-point datatypes., i.e. real numbers. These are % (modulo) and all of the bitwise operators, like ∼, <<, >>, &, ˆ, and |. ✞ #include <stdio.h> 2 int main (void ) {
- 44. 1.12. MATHEMATIS 229 4/* Will show errors*/ printf("2 % 2.0 is %fn", 2 % 2.0) ; 6 /* Will show errors*/ printf("2 ^ 2.0 is %fn", 2 ^ 2.0) ; 8 return 0; } ✌ ✆ An int data type value can be converted into floating point type by casting it. ✞ 1 #include <stdio.h> 3 int main (void ) { printf("2 is %fn", (float) 2); 5 printf("2 is %lfn", (double) 2); return 0; 7 } ✌ ✆ ✞ 2 is 2.000000 2 is 2.000000 ✌ ✆ Few of the floating values are shown in the following table. Float Decimal Binary Form 0 0 0 00000000 00000000000000000000000 -0 -0 1 00000000 00000000000000000000000 0.1 0.10000000149011612 0 01111011 10011001100110011001101 0.125 0.125 0 01111100 00000000000000000000000 0.25 0.25 0 01111101 00000000000000000000000 1 1 0 01111111 00000000000000000000000 2 2 0 10000000 00000000000000000000000 1e+12 999999995904 0 10100110 11010001101010010100101 inf inf 0 11111111 00000000000000000000000 -inf -inf 1 11111111 00000000000000000000000 nan nan 0 11111111 10000000000000000000000 A value is said to be positive infinity (0×7f800000) when its sign bit is 0 and exponent is 0×ff and all mantissa bits are 0. Similarly, a value is said to be negative infinity (0×ff800000) when its sign bit is 1 and exponent is 0×ff and all mantissa bits are 0. A not-a-number (0×7fc00000) case arises when sign bit of floating point number is 0, exponent is 0×ff and mantissa is 0×400000.
- 45. 230 Basic C AstrayResult Sometimes when a float data type number is printed in output console, it gives strange result. Like 3.1 prints as 3.0999999. Its reason is that most hardware uses base 2 for floating-point numbers rather than base 10. All the fractions in base 10 (decimal form) can not be represented in base 2 (binary form). This is why, decimal fraction 3.1 sometimes printed as 3.0999999. Double Floating Point A double is 64 bits long and has three components, (i) a sign bit (first bit from left side), (ii) exponent (next 11 bits from left side) and (iii) mantissa (rest of 52 bits). A double point floating point number is written as f = ±m × b±e Here, m is mantissa of the number, b is base either ‘10’ or ‘e’ or ‘2’ and n is exponent of the floating type number. In computers, the base is ‘2’. Binary number 1111111111 equivalent to decimal 1023 is used as Exponent bias. 1.12.5 Zero Crossing A function is said to be zero-crossing function if its sign changes when its independent variable crosses to zero in a number line. For example f(x) = x; for − 1 < x < 1 changes its sign when x crosses to zero. Similarly f(x) = sin(x); for − 4 < x < 4 is also a zero crossing function which changes its sign when x crosses to zero. Zero crossing has emmence importance in electrical and computer science. Limit At Zero In mathematics, limit is a finite value of a continuous function at a given point. It is represented as lim x→a f(x) = k Where k is fininte value of the function at given point ‘a’. If ‘a’ is zero then some functions behave strangly and do not give finite value, i.e. converging value at the point of limit. Assume a function, here y = sin(x), which converges to a finite value at point ‘0’ lim x→0 y = lim x→0 sin(x) = 0 x y b (0, 0)
- 46. 1.12. MATHEMATIS 231 Contrastto these types of functions, fraction functions diverge to ∞ when x → 0. See the following limit equation for function y = 1/x, lim x→0 y = lim x→0 1 x = ∞ Now, it is not possible to use this function with other functions in mathematical op- erations. To avoid it, we take approaching limit to point ‘0’ of the function as given below: lim x→0 y = lim x→0 1 x = ∞; when [−∞, 0) < x < (0, ∞] x y b (0, 0) Here, ±∞ is acceptable as 1/ ± ∞ = 0, which is a finite value. 1.12.6 Random Number Generator Following C program is used to generate random numbers. A user defined seed control the initial random number and subsequent random numbers are used as seed for next random number. This program given first five random number against a seed value. ✞ #include <stdio.h> 2 extern void SeedToNew (unsigned int x); extern int MyRand(void ); 4 int main (void ) { 6 int count; unsigned seed ; 8 printf("Please enter seed .n"); while (scanf("%u", &seed ) == 1) { 10 SeedToNew (seed ); for (count = 0; count < 5; count ++) 12 printf("%hdn", MyRand()); printf("Please enter newSeed (q to quit ):n"); 14 } printf("Done n"); 16 return 0; } 18
- 47. 232 Array &Pointer static unsigned long int newSeed = 1; /* the seed */ 20 int MyRand(void ) { 22 newSeed = newSeed * 1103515245 + 12345; return (unsigned int) (newSeed / 65536) % 32768; 24 } 26 void SeedToNew (unsigned int seed ) { newSeed = seed ; 28 } ✌ ✆ In the codes in line ✞ return (unsigned int) ( newSeed / 65536) % 32768; ✌ ✆ The value 32768 is used to control the limits of the random number. If it is 10 then all the random number will be within 0 to 10.
- 48. 2.1. ARRAY 233 2Array& Pointer 2.1 Array Arrays in C stores data in a single variable name with an index, also known as a subscript. It is simply a list or ordered grouping for variables of the same type. Arrays often help a programmer in organize collections of data efficiently and intuitively. A character array takes one byte for each character while an integer array takes 4 bytes for one integer. Other datatypes takes appropriate bytes to stores that data type value. A B C D E F ‘0’ myStrA Figure 2.1: Array of first six alphabetic characters stored in memory and pointed by variable ‘myStrA’. 00000001 00000010 myNumA myNumA[0] myNumA[1] Figure 2.2: Array of two integers pointed by variable ‘myNumA’ are stored in memory as shown this figure. Each integer needs four bytes memory space. 2.1.1 Uni-Dimensional Array Arrays are declared by two ways, (i) static and (ii) dynamic. Static arrays are declared using square brackets containing size of array. Dynamic arrays are declared with pointers. In static declaration, compiler creates space required for storing of data at declaration and then returns the address of memory space created. In case of string, one extra space for null terminator is also reserved. In case of dynamic declaration only address of proposed memory space is returned where proposed data may be stored. It does not reserve memory space. To create memory space, function malloc is used. Note that only string arrays have terminating marker (0). Other type of arrays must be controlled by array size. muArrays are declared and initialized like ✞ 1 int numbers [6]; // array declared & space created int point [6]={0 ,0 ,1 ,0 ,0 ,0}; // array declared , space 3 // created and initialized ✌ ✆
- 49. 234 Array &Pointer Remember that the initialization of static array is take place alongwith its declaration. Otherwise initialization of an array shows compile time error. ✞ 1 char myS []; myS="My String"; /* Illegal initialization .*/ 3 // Actually , above action was copying of data to // array , not initialisation . Copying of data done 5 // by copying character one by one in memory space char myStr []="My String"; /* Legal initialization .*/ ✌ ✆ Initialisation of array with pointer after declaration is compiler dependent. ✞ #include <stdio.h> 2 int main () { 4 char *c = "This "; c = "That "; 6 printf("%s", c); return 0; 8 } ✌ ✆ ✞ That ✌ ✆ The brackets ([ ]) identify ‘numbers’ or ‘points’ and the number enclosed in the brackets indicates the number of elements in the array. An element of the array can be accessed by its index number i.e. subscripts of the array. When square bracket symbol in static array declaration does not contain size of array then it is called dynamic declaration of array. Dynamic array declaration is permitted if it is initialised at the time of declaration. In following example, each element of the array is accessed by its index number. ✞ 1 #include <stdio.h> 3 int main (void ) { int ix; 5 short anArray[ ] = {3, 6, 9, 12, 15}; for (ix = 0; ix < ( sizeof (anArray ) / sizeof ( short)); ++ix) { 7 printf("The array value is %d.n", anArray [ix]); } 9 } ✌ ✆ i0 i1 i2 i3 i4 3 6 9 12 15 anArray Figure 2.3: Head integer value consumes 4 byte memory space. in represents to the index of elements of array ‘days’. Total bytes of memory used to store data is 5 × 4 = 20.
- 50. 2.1. ARRAY 235 Inthe above example, the size of the array was not explicitly specified. The compiler knows the size of array from the initialized list. The size of ‘anArray’ is ‘5’ because ‘anArray’ has five elements. Addition of an additional element to the list will increase its size to six. Static declaration of the size of an array, the array list will be overflow. To overcome this problem sizeof expression is used as ✞ 1 size = sizeof(anArray)/ sizeof(short) ✌ ✆ As the sizeof expression in the for loop, the script is automatically adjusted to this change. Designated initializer is allow to pick and choose the initialized elements. If the last element of an array is initialized then in the initialization syntax of traditional C, there is a requirement of initialization of every element preceding to the last one. An array, if initialized, then each element value is index from 0 to n − 1, where n is size of the array. For example, ✞ 1 int count[] = {31, 28, 30, 29, 32, 27}; // array size is 6 ✌ ✆ has six elements. The element value at index 0 is 31, element value at index 1 is 28 and so on. The index of array element may be redefined inside the array as the method given in following syntax ✞ 1 /* int count[] = {[<new index >]=< array element value >};*/ int count[] = {31, [2] = 28, 30, 29, 32, 27}; ✌ ✆ Here, the index of second element is 2, i.e. element shall be stored at third place of memory of integer data type. Elements of an array are overridable, i.e. new element value at index 4 can be override the old value of the element at the index 4 if any other element is assigned the index value 4. ✞ #include <stdio.h> 2 #define MONTHS 12 4 int main (void ) { int days [MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29}; 6 int i; for (i = 0; i < MONTHS; i++) 8 printf("%2d %dn", i + 1, days [i]); return 0; 10 } ✌ ✆ In above program example, array ‘days’ has first element (at index position 0) 31, second element (at index position 1) is 28. Next element, 30, of the array ‘days’ is declared for index 4, i.e. for 5th position. Next element is 30 in the array ‘days’. Its position shall be next to the previous element, i.e. after 5th position, therefore this element will be at 6th position or at index position 5. Element for index position 6 is 31. Last element is defined for index position 1. Hence previous element, 28, which was at the index position 1 shall be replaced by value 29. The final arrangement of the array data in the memory shall be as shown in the below figure.
- 51. 236 Array &Pointer i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 i10 i11 31 29 0 0 31 30 31 0 0 0 0 0 days Figure 2.4: Arrangement of elements of array ‘days’ in memory. Here, each block rep- resents to an integer data byte (i.e. group of four memory bytes). in represents to the index of elements of array ‘days’. ✞ 1 31 2 29 3 0 4 0 5 31 6 30 7 31 8 0 9 0 10 0 11 0 12 0 ✌ ✆ An array initialised with ‘[ ]’ is called expandable array. When an array is declared without its size, compiler first count the array elements and then it grows the array upto a size so that all the elements can stored in the array. ✞ /* Array with growing size . */ 2 int days [ ] = {31, 28, [4] = 31, 30, 31, [1] = 29}; ✌ ✆ ✞ #include <stdio.h> 2 int main (void ) { 4 int days [] = {31, 28, [4] = 31, 30, 31, [1] = 29}; int i; 6 printf("Size of array is %dn", sizeof (days ) / sizeof (int)); /* Here sizeof (days ) / sizeof (int) is not* 8 *grouped as ‘/’ higher precedence to ‘<’ */ for (i = 0; i < sizeof (days ) / sizeof (int); i++) 10 printf("%2d %dn", i , days [i]); return 0; 12 } ✌ ✆ ✞ Size of array is 7 0 31 1 29 2 0 3 0 4 31 5 30
- 52. 2.1. ARRAY 237 631 ✌ ✆ 2.1.2 Multi-Dimensional Array An array declaration in C is given by ✞ int myA[m][n];/*m rows and n cols .*/ ✌ ✆ If the size of integer type array is fixed as shown above, compiler reserves m× n× k bytes memory. Here, k is size of variable data type. For integer it is 4 as integer is 4 bytes long data type. Hence, memory size allocated for integer array of type m × n is 4mn. Assume a 2 × 2 integer array as shown below ✞ 1 int myA [2][2] = { {10, 20}, 3 {15, 2} }; ✌ ✆ The memory allocated for this array is 2 × 2 × 4 = 16 bytes. As column size of this array is 2, hence 8 bytes are taken in a group for two columns, in which each column uses 4 bytes for storing integer data. Remember that, in following figures, each cell represents to one byte. This is why, an integer is represented here as a group of four bytes. It is done, for convenient to calculate the number of bytes required to store an array data. And in computer, the index counting is started from ‘0’ instead of ‘1’. 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 myA c0 c1 r0 r1 In above figure, the byte position of array data is shown into two rows and two column. Practically above data is stored in memory as continuous data bytes. 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 myA 1st row 2nd row 1st col 2nd col 1st col 2nd col From the above arrangement of data, in a multi-dimensional array, number of rows may be constant or variable but number of columns must be constant. The reason is that, elements of an array are arranged one by one sequentially, so if column size is not fixed then pointer-to-array variable will not be able to identify the starting of next row of the array. See the example below:
- 53. 238 Array &Pointer ✞ #include <stdio.h> 2 int main () { 4 int i; int myA [2][2] = {/* 2X2X4 =16 bytes */ 6 {10, 20}, {15, 2} 8 }; printf("Size of array is %dn", sizeof (myA)); 10 char *p = (char *) &myA; // Cast int into char ptr for (i = 0; i < sizeof (myA); i++) { 12 printf("%d ", p[i]);// print all 16 bytes } 14 return 0; } ✌ ✆ ✞ Size of array is 16 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 ✌ ✆ Now, an array having two columns but dynamic rows is declared and assigned as the syntax is given below: ✞ int myB[ ][2] = { 2 {10, 20}, {15, 2}, 4 {1, 4} }; ✌ ✆ The memory allocated for this array is dynamic. This array has two columns hence memory is allocated in the multiple of 2 × 4 = 8 bytes. If there are two rows then memory allocation will be expanded to 8 × 2 = 16 bytes. Similarly if there are three rows then memory allocation will be expanded to 8 × 3 = 24 bytes and so on, subject to memory sharing is not violated. myA 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 1 0 0 0 4 0 0 0 c0 c1 r0 r1 r2 See the example below: ✞ 1 #include <stdio.h>
- 54. 2.1. ARRAY 239 3int main () { int i; 5 /* Array has fixed cols & dynamic rows */ int myB[ ][2] = { 7 {10, 20}, {15, 2}, 9 {1, 4} }; 11 printf("Size of array is %dn", sizeof (myB)); char *p = (char *) &myB; 13 for (i = 0; i < sizeof (myB); i++) { printf("%d ", p[i]); 15 } return 0; 17 } ✌ ✆ ✞ Size of array is 24 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 1 0 0 0 4 0 0 0 ✌ ✆ An array having two rows and three columns is declared and initialized as shown in the syntax given below: ✞ int two_d [2][3] = {{ 5, 2, 1 }, 2 { 6, 7, 8 }}; ✌ ✆ Where [2] represents to the number of rows and [3] represents to the number of columns of the two dimensional array. A three dimensional array is declared as given in the following syntax: ✞ int myA[ ][3][2]; 2 /* | | | * * l r c */ ✌ ✆ This array has two columns (y-axis represented as ‘c’ here), three rows (x-axis represented as ‘r’ here) and variable number of layers (z-axis represented as ‘l’ here). In C programs, which contains three dimensional array, the z-axis (i.e. third dimension) is always outer- most loop. Practically, three dimensional array is layers of two dimensional arrays. As shown in the following figure, a 3 × 2 array is placed in four layers and collectively, they form a 3 × 2 × 4 three dimensional array.
- 55. 240 Array &Pointer l0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 l1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 l2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 l3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 A three dimensional array is arranged in patterns as shown in below figure. myA l0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 l1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 c0 c1 r0 r1 r2 The memory arrangement of three dimensional array is given in the following figure. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 myA r0 of l0 r1 of l0 c0 of r0 c1 of r0 c0 of r1 c1 of r1 Multi-dimensional array can be used to add, subtract and product (either dot or cross) of two vectors or matrices. Following is an example using an array of 5 × 5 dimension. This example requires 5 × 5 × 4 = 100 bytes. ✞ 1 #include <stdio.h> #define X 5 3 #define Y 5 5 int main (void ) { int ix , iy; 7 short anArray[X][Y]; /* 100 bytes memory requirement .*/ 9 for (ix = 0; ix < X; ++ix) { for (iy = 0; iy < Y; ++iy) {
- 56. 2.1. ARRAY 241 11anArray[ix][ iy] = ix * iy; }; 13 } for (ix = 0; ix < X; ++ix) { 15 for (iy = 0; iy < Y; ++iy) { printf("%2dt", anArray[ix][iy]); 17 }; printf("n"); 19 } } ✌ ✆ ✞ 0 0 0 0 0 0 1 2 3 4 0 2 4 6 8 0 3 6 9 12 0 4 8 12 16 ✌ ✆ Multidimentional array can be extended in matrix manipulations, additions, subtractions, multiplications and divisions. In the following example, two matrices are added and subtracted element-wise. The element-wise addition and subtraction is given by Cij = Aij ± Bij ✞ 1 #include <stdio.h> 3 /* Random number generator between 0 to 10.*/ int rand_num (int a, int b) { 5 return ((a * 97 + b*21) & 10); } 7 int main () { 9 int i/* row*/, j/* col*/; 11 int A [3][3]/* First Matrix*/, B [3][3]/* Second Matrix*/, 13 C [3][3]/* Third Matrix*/; printf("First Random Matrix is :n"); 15 /* For each of three rows */ for (i = 0; i < 3; i++) { 17 /* There are three columns.*/ for (j = 0; j < 3; j++) { 19 /* Assign a random matrix elements .*/ A[i][j] = rand_num (i*j, j); 21 printf("%3dt", A[i][j]); } 23 /* Print new line after completion of each row*/ printf("nn"); 25 } printf("nSecond Random Matrix is :n"); 27 /* For each of three rows */
- 57. 242 Array &Pointer for (i = 0; i < 3; i++) { 29 /* There are three columns.*/ for (j = 0; j < 3; j++) { 31 /* Assign a random matrix elements .*/ B[i][j] = rand_num (i, i*j); 33 printf("%3dt", B[i][j]); } 35 /* Print new line after completion of each row*/ printf("nn"); 37 } printf("nElementwise Addition of Matrix is :n"); 39 /* For each of three rows */ for (i = 0; i < 3; i++) { 41 /* There are three columns.*/ for (j = 0; j < 3; j++) { 43 /* Add matrices elementwise .*/ C[i][j] = A[i][j] + B[i][j]; 45 printf("%3dt", C[i][j]); } 47 /* Print new line after completion of each row*/ printf("nn"); 49 } printf("nElementwise Subtraction of Matrix is :n"); 51 /* For each of three rows */ for (i = 0; i < 3; i++) { 53 /* There are three columns.*/ for (j = 0; j < 3; j++) { 55 /* Subtract matrices elementwise .*/ C[i][j] = A[i][j] - B[i][j]; 57 printf("%3dt", C[i][j]); } 59 /* Print new line after completion of each row*/ printf("nn"); 61 } return 0; 63 } ✌ ✆ ✞ First Random Matrix is : 0 0 10 0 2 8 0 2 10 Second Random Matrix is : 0 0 0 0 2 10 2 8 2 Elementwise Addition of Matrix is : 0 0 10 0 4 18 2 10 12 Elementwise Subtraction of Matrix is : 0 0 10
- 58. 2.1. ARRAY 243 00 -2 -2 -6 8 ✌ ✆ The vector and scalar products between two matrices can also be done. The dot product of two matrices is given by Cij = ~ Aij · ~ Bij In the following example, dot products between to matrices is performed. ✞ #include <stdio.h> 2 /* Random number generator between 0 to 10.*/ 4 int rand_num (int a) { return ((a * 1011457789 + 12345) & 10); 6 } 8 int main () { int i/* row*/, 10 j/* col*/; int A [3][3]/* First Matrix*/, 12 B [3][3]/* Second Matrix*/, C [3][3]/* Dot Matrix */; 14 printf("First Random Matrix is :n"); /* For each of three rows */ 16 for (i = 0; i < 3; i++) { /* There are three columns.*/ 18 for (j = 0; j < 3; j++) { /* Assign a random matrix elements .*/ 20 A[i][j] = rand_num (i + j); printf("%dt", A[i][j]); 22 } /* Print new line after completion of each row*/ 24 printf("nn"); } 26 printf("nSecond Random Matrix is :n"); /* For each of three rows */ 28 for (i = 0; i < 3; i++) { /* There are three columns.*/ 30 for (j = 0; j < 3; j++) { /* Assign a random matrix elements .*/ 32 B[i][j] = rand_num (i * j); printf("%dt", B[i][j]); 34 } /* Print new line after completion of each row*/ 36 printf("nn"); } 38 printf("nDot Product Matrix is :n"); /* For each of three rows */ 40 for (i = 0; i < 3; i++) { /* There are three columns.*/ 42 for (j = 0; j < 3; j++) { /* Elementwise dot product of matrices .*/
- 59. 244 Array &Pointer 44 C[i][j] = A[i][j] * B[i][j]; printf("%dt", C[i][j]); 46 } /* Print new line after completion of each row*/ 48 printf("nn"); } 50 return 0; } ✌ ✆ ✞ First Random Matrix is : 8 2 2 2 2 0 2 0 8 Second Random Matrix is : 8 8 8 8 2 2 8 2 8 Dot Product Matrix is : 64 16 16 16 4 0 16 0 64 ✌ ✆ The cross product (vector product) of two matrices is given by ~ C = ~ A × ~ B ✞ #include <stdio.h> 2 /* Random number generator between 0 to 10.*/ 4 int newseed =10; int seed (int a){ 6 newseed =newseed+a; return newseed; 8 } int rand_num (int a) { 10 seed (a); return (( newseed * 99991 + 12345) & 10); 12 } 14 int main () { int i/* row*/; 16 int A[3]/* First Vector */, B[3]/* Second Vector */, 18 C[3]/* Dot Vector */; printf("First Random Vector is :n"); 20 /* For each of three rows */ for (i = 0; i < 3; i++) { 22 /* Assign a random vector elements .*/ A[i] = rand_num (i); 24 printf("%dt", A[i]);
- 60. 2.1. ARRAY 245 } 26/* Print new line after completion of each row*/ printf("n"); 28 printf("nSecond Random Vector is :n"); 30 /* For each of three rows */ for (i = 0; i < 3; i++) { 32 /* Assign a random vector elements .*/ B[i] = rand_num (i); 34 printf("%dt", B[i]); /* Print new line after completion of each row*/ 36 } printf("n"); 38 printf("nCross Product Vector is :n"); 40 /* For each of three rows */ for (i = 0; i < 3; i++) { 42 /* Elementwise cross product of matrices .*/ C[i] = pow(-1,2* i)* (A[(i+1) %3] * B[(i+2) %3] 44 - B[(i+1) %3] * A[(i+2) %3]) ; printf("%dt", C[i]); 46 } /* Print new line after completion of each row*/ 48 printf("nn"); 50 return 0; } ✌ ✆ ✞ First Random Vector is : 10 2 0 Second Random Vector is : 0 10 8 Cross Product Vector is : 16 -80 100 ✌ ✆ Arrays can be passed to a function as its parameter (argument) as shown in the example given below: ✞ #include <stdio.h> 2 /*+- Array pointer with ** **| expandable size */ 4 void init_array (int a[ ], int count) { int i; 6 for (i = 0; i < count; i++) a[i] = i * 10; 8 for (i = 0; i < count; i++) printf("The a value is %d.n", a[i]); 10 } 12 int main (void ) { int mydata [10];
- 61. 246 Array &Pointer 14 init_array (mydata , 5); return 0; 16 } ✌ ✆ ✞ The a value is 0. The a value is 10. The a value is 20. The a value is 30. The a value is 40. ✌ ✆ For multidimensional array, there is no limit of dimension in C. Here, a four dimensional matrix is represented by ✞ 1 int myData [2][3][2][4] ✌ ✆ A new dimension in array declaration is always grouped by curly braces. One dimensional array has one curly braces, i.e. one row. In two dimensional array, there are two one dimensional rows both separated by comma (,) operator. These two rows are enclosed by another curly braces. In three dimensional systems of arrays, two 2-dimensional arrays are placed one over another. In the following example, two, three and four dimensional arrays are declared. ✞ 1 #include <stdio.h> 3 int main () { char a[2][2] = { 5 // cols {1, 2}, // row 7 {5, 6} // row }; 9 char b[2][2][2] = { { 11 // cols {1, 2}, // row 13 {5, 6} // row }, 15 {// height {4, 3}, 17 {8, 9} } 19 }; char c[2][2][2][2] = { 21 { { 23 // cols {1, 2}, // row 25 {5, 6} // row }, 27 {// height {1, 2},
- 62. 2.1. ARRAY 247 29{5, 6} } 31 }, {// time 33 { {4, 1}, 35 {7, 6} }, 37 { {4, 4}, 39 {9, 1} } 41 } }; 43 int i, j, k, l; printf("Elements of matrix a are n"); 45 for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { 47 printf("Element a[%d][%d] is : %dn", i+1, j+1, a[i][j]); 49 } } 51 printf("Elements of matrix b are n"); for (i = 0; i < 2; i++) { 53 for (j = 0; j < 2; j++) { for (k = 0; k < 2; k++) { 55 printf("Element b[%d][%d][%d] is : %dn", i+1, j+1, k+1, b[i][j][k]); 57 } } 59 } printf("Elements of matrix c are n"); 61 for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { 63 for (k = 0; k < 2; k++) { for (l = 0; l < 2; l++) { 65 printf("Element c[%d][%d][%d][%d] is : %dn", i+1, j+1, k+1, l+1, c[i][j][k][l]); 67 } } 69 } } 71 return 0; } ✌ ✆ It is an example of the two dimensional matrix in which total and average marks of each student is calculated. ✞ #include <stdio.h> 2 #define STUDENT 3 // number of STUDENTS #define SUBJECT 5 // number of SUBJECT
- 63. 248 Array &Pointer 4 int main (void ) { 6 // marks of five stus const float marks[STUDENT ][ SUBJECT ] = { 8 // subs -> {9.9, 8.0, 8.3, 4.2, 6.0}, // stu row 10 {9.0, 7.0, 7.3, 2.0, 5.0}, // stu row {9.6, 8.0, 8.8, 2.1, 5.5}, // stu row 12 }; int stu , sub; 14 float subtot , total; printf("Student Marks (Max 50)n"); 16 /* for each stu , sum marks for each sub */ 18 total = 0; for (stu = 0; stu < STUDENT; stu ++) { 20 for (sub = 0, subtot = 0; sub < SUBJECT; sub ++) { subtot += *(*( marks + stu) + sub); 22 } printf("%s %d %20.1fn", "Stu", stu + 1, subtot); 24 total += subtot; /* total for all stus */ } 26 printf("nThe student average is %.1f.nn", total / STUDENT ); 28 printf("Subject Average :n"); 30 printf("Sub_1 Sub_2 Sub_3 Sub_4 Sub_5n"); 32 /* for each sub , sum marks over stus */ for (sub = 0; sub < SUBJECT; sub ++) { 34 subtot = 0; for (stu = 0; stu < STUDENT; stu ++) { 36 subtot += *(*( marks + stu) + sub); } 38 printf("%5.1 f ", subtot / STUDENT ); } 40 printf("n"); return 0; 42 } ✌ ✆ ✞ Student Marks (Max 50) Stu 1 36.4 Stu 2 30.3 Stu 3 34.0 The student average is 33.6. Subject Average : Sub_1 Sub _2 Sub_3 Sub_4 Sub_5 9.5 7.7 8.1 2.8 5.5 ✌ ✆
- 64. 2.1. ARRAY 249 Amultidimensional array may also be returned by a function, if function is used as a pointer. An example for two dimensional array as a returned value of a function is given below: ✞ #include <stdio.h> 2 int (* myF(int arr [3][3] , int n))[3] { 4 int i, j; for (i = 0; i < 3; i++) { 6 for (j = 0; j < 3; j++) { arr[i][j] = i + j; 8 } } 10 return arr; } 12 int main () { 14 int arr [3][3]; int (*q)[3] = myF(arr , 3); 16 int i, j; for (i = 0; i < 3; i++) { 18 for (j = 0; j < 3; j++) { printf(" %d", q[i][j]); 20 } printf("n"); 22 } } ✌ ✆ ✞ 0 1 2 1 2 3 2 3 4 ✌ ✆ 2.1.3 Array of Strings It is very simple to declara an array for integers, float, characters datatypes as they has fixed size. But, in case of string, declaration of array is complex as size of string, being stored in array like matrix form, is variable. For example, at a particular cell, we can store string “me” or string “our”. Here, both words have different size. So, declaration of an array for string needs special caution and care. Here, we shall discuss about the storing of string data in an array, starting from one dimensional array to multi-dimensional array. Suppose we have to store string “This”. We declare array like ✞ 1 char myArr []; ✌ ✆ Here, ‘[]’ controls the size of declared variable ‘myArr’ as dynamic and memory is allocated and reallocated by compiler at run time according to the size of input string being stored. Now, we store string “This” in this array, and appended by null terminator. The memory data shall be looked like-
- 65. 250 Array &Pointer 0×0012 0×0013 0×0014 0×0015 0×0016 0×0017 0×0018 0×0019 myArr T h i s 0 Figure 2.5: But what happens if we declare an fixed size one dimensional array as shown below: ✞ 1 char myArr [10]; ✌ ✆ It means, above array may store only 10 characters including null terminator. ✞ 1 #include <stdio.h> #include <string.h> 3 int main () { 5 char myArr[]="This "; printf("String is ’%s ’n",myArr); 7 return 0; } ✌ ✆ ✞ String is ’This ’ ✌ ✆ If we try to store string of size more than 10 characters, data shall be overflow. From figure 2.5, it is seen that each character of string ‘This’ is column of one row vector. Therefore, when we declare a two dimensional array, one new parameter is required for rows of the array alongwith other size of string parameter. ✞ 1 char myArr[<rows >][< string size in each row >] ✌ ✆ For example, an array ✞ 1 char myArr [3][5] ✌ ✆ tells us that, there are three rows and each row may store strings of five characters including null terminator. Note that, the declaration parameter ‘[<string size in each row >]’ is required only at the time of array declaration. When storing and retrieving of strings, we just ignore it or just replace it by ‘[0]’ only.
- 66. 2.1. ARRAY 251 0×00120×0013 0×0014 0×0015 0×0016 T h i s 0 i s 0 m y 0 0×0312 0×0313 0×0314 0×0315 0×0316 p e t 0 myArr[0] myArr[1] myArr[3] Figure 2.6: ✞ 1 #include <stdio.h> #include <string.h> 3 int main () { 5 char myArr [4][5]={ "This ","is","my","pet"}; printf("String is ’%s ’n",myArr[0]) ; 7 printf("String is ’%s ’n",myArr[1]) ; printf("String is ’%s ’n",myArr[2]) ; 9 printf("String is ’%s ’n",myArr[3]) ; return 0; 11 } ✌ ✆ ✞ String is ’This ’ String is ’is ’ String is ’my ’ String is ’pet ’ ✌ ✆ Note that, a string variable is pointer of itself and points to address where data is stored. So, use of ‘&’ symbol is optional. It also points to the address of first character of string, so use of ‘[0]’ is also optional. So that, ‘myArr’ and ‘myArr[0]’ both return the string ‘This’. ✞ #include <stdio.h> 2 #include <string.h> 4 int main () { char myArr [4][5]={ "This ","is","my","pet"}; 6 printf("String is ’%s ’n",myArr); printf("String is ’%s ’n",myArr[1]) ; 8 printf("String is ’%s ’n",myArr[2]) ; printf("String is ’%s ’n",myArr[3]) ; 10 return 0; } ✌ ✆ ✞ String is ’This ’
- 67. 252 Array &Pointer String is ’is ’ String is ’my ’ String is ’pet ’ ✌ ✆ We can also declare an array that is arranged in rows and columns and each column is of fixed size for storing of strings. ✞ char myArr[<rows >][< cols >][< string size >] ✌ ✆ 0×0012 0×0013 0×0014 0×0015 0×0016 T h i s 0 0×0017 0×0018 0×0019 0×0020 0×0021 T h a t 0 i s 0 w a s 0 m y 0 m y 0 0×0312 0×0313 0×0314 0×0315 0×0316 p e t 0 0×0317 0×0318 0×0319 0×0320 0×0321 p e n 0 myArr[0][0] myArr[1][0] myArr[3][0] myArr[0][1] Figure 2.7: See the example below: ✞ 1 #include <stdio.h> #include <string.h> 3 #define ROWS 4 5 #define COLS 2 #define STRING_SIZE 5 7 int main () { 9 char myArr[ROWS ][ COLS ][ STRING_SIZE ] = { {"This ", "That "}, 11 {"is", "was"}, {"my", "my"}, 13 {"pet", "pen"} }; 15 int i; printf("Data matrix is : n"); 17 for (i = 0; i < ROWS ; i++) { printf("%5s t %5sn", myArr[i][0], myArr[i][1]); 19 } return 0; 21 } ✌ ✆ ✞ Data matrix is : This That is was
- 68. 2.1. ARRAY 253 mymy pet pen ✌ ✆ We can add new strings in this array by using strcpy function by indicating the address of matrix cell. ✞ 1 /*At fifth row , first column */ strcpy(arr [4][0] , "Hi"); 3 /*At fifth row , second column*/ strcpy(arr [4][1] , "His"); ✌ ✆ While we use scanf function to add user’s input from input stream, we should exactly known to the address of memory byte where data is to be stored. ✞ #include <stdio.h> 2 #include <string.h> 4 #define ROWS 5 #define COLS 2 6 #define STRING_SIZE 5 8 int main () { char myArr[ROWS ][ COLS ][ STRING_SIZE ] = { 10 {"This ", "That "}, {"is", "was"}, 12 {"my", "my"}, {"pet", "pen"} 14 }; int i; 16 printf("Enter data for 5th row 1st column :"); scanf("%s", myArr [4][0]) ; 18 printf("Enter data for 5th row 2nd column :"); scanf("%s", &myArr [4][1][0]) ;/* last [0] is optional */ 20 printf("Data matrix is : n"); for (i = 0; i < ROWS ; i++) { 22 printf("%5s t %5sn", myArr[i][0], myArr[i][1]); } 24 return 0; } ✌ ✆ ✞ Enter data for 5th row 1st column :hi Enter data for 5th row 2nd column :his Data matrix is : This That is was my my pet pen hi his ✌ ✆ We can also declare a static multidimensional array by using pointers. It is declared as
- 69. 254 Array &Pointer ✞ char * myArr[<rows >] ✌ ✆ Data should be assigned at the time of declaration. Pointer character ‘*’ is responsible for dynamic allocation of memory of suitable size so that assigned data is stored in the array. See the example below: ✞ 1 #include <stdio.h> 3 int main () { /* Static array declaration */ 5 char * myArr[2] = {"This ", "is"}; printf("First row string is : %sn", myArr[0]) ; 7 printf("Second row string is : %s", myArr[1]) ; return 0; 9 } ✌ ✆ ✞ First row string is : This Second row string is : is ✌ ✆ 0×0012 0×0013 0×0014 0×0015 0×0016 T h i s 0 0×0112 0×0113 0×0114 0×0115 0×0116 i s 0 myArr[0] myArr[1] Here, two strings have static storage prior to the program startup. In the initializer, the arrays are converted to pointers to char and the words array is initialized with the pointer values. It can not be modified during the program run. It has its own advantages as we can access to character of string by using pointers. ✞ #include <stdio.h> 2 int main () { 4 char * myArr[3] = {"This ", "is"}; printf("First row string is : %sn", myArr[0]) ; 6 printf("Same from index 1 is : %s n", (myArr [0]+1)); return 0; 8 } ✌ ✆ ✞ First row string is : This First row string from index 1 is : his ✌ ✆ Here, ‘myArr[0]+1’ means pointer points to the first row string at index ‘0’ and pointer position is changed by one character position rather than next row.
- 70. 2.1. ARRAY 255 0×00120×0013 0×0014 0×0015 0×0016 T h i s 0 0×0112 0×0113 0×0114 0×0115 0×0116 i s 0 myArr[0]+1 myArr[1] Using pointer, we can access whole string or its part of string. For example, ‘*myArry’ is the same as myArry[0]. ‘(*myArry)[0]’ is the same as **myArry, which is the first character of the string and not the address of the string. ✞ #include <stdio.h> 2 int main () { 4 char * myArr[2] = {"This ", "Home "}; printf("For ’This ’ : %sn", myArr [0]) ; 6 printf("For ’Home ’ : %sn", myArr [1]) ; /* Address of ’This ’ pointed by * myArr and* 8 *it points to address of character ’T’ */ printf("For ’This ’ : %sn", *myArr); 10 /* Dereference to pointer that is pointing * *to address where string ’This ’ is stored. * 12 *Pointer points to location of character ’T ’.*/ printf("For ’T’ : %c n", ** myArr); 14 /* same as above*/ printf("For ’T’ : %c n", (* myArr)[0]) ; 16 /* Dereference to pointer that is pointing * *to address where string ’This ’ is stored.* 18 *Pointer in incremented by one , and now , * *it points to location of character ’h ’. */ 20 printf("For ’h’ : %c n", (* myArr)[1]) ; /* same as above*/ 22 printf("For ’h’ : %c n", *(* myArr +1)); return 0; 24 } ✌ ✆ ✞ For ’This ’ : This For ’Home ’ : Home For ’This ’ : This For ’T’ : T For ’T’ : T For ’h’ : h For ’h’ : h ✌ ✆ 2.1.4 Array in Function In functions arguments are passed to it as value unless the function needs alter the argument. If function needs update the argument, argument should be passed to function as its argument. Arrays can also passed to functions as pointers. If an array is passed to
- 71. 256 Array &Pointer the function, function would have to allocate enough space to hold a copy of the original array and then copy all the data from the original array to the new array. It is much quicker to pass the address of the array rather than array itself and have the function work with the original data. Prototype for the passing of an array to the function is ✞ 1 int sum(int arr[ ]) /*Or*/ 3 int sum(int *arr) ✌ ✆ sum() i0 i1 i2 i3 i4 3 6 9 12 15 anArray S Figure 2.8: Passing of address of array to sum() function. Array is pointed by the pointer/variable ‘anArray’. In C, array parameters are always treated as pointers. C compilers do not check the size of the array passed to the function hence for good programming, the function should know the limits of actions on the array. This is why a new parameter of array size as ‘n’ is passed to the function as ✞ 1 int sum(int arr[ ], int n) ✌ ✆ sum() for(i=0; i<n; i++){ S += anArray[i]; } i0 i1 i2 i3 i4 3 6 9 12 15 anArray n S Figure 2.9: Passing of address of array as well as element size of the array to sum() function. Array is pointed by the pointer/variable ‘anArray’. Because the name of an array is the address of the first element, an actual argument of an array name requires that the matching formal argument be a pointer. In this context int arr[ ] to mean the same as the int * arr. First bracket in the multidimensional array may be empty or not but other brackets should contains the valid integers for the size of the array dimension. For example
- 72. 2.1. ARRAY 257 ✞ 1int sum(int arr[ ][ ], int rows ); // faulty declaration ✌ ✆ is a faulty declaration. Recall that the compiler converts array notation to pointer no- tation. It means, that arr[1] will become arr+1. For the compiler to evaluate this, it needs to know the size of object to which ‘arr’ points. The declaration ✞ 1 int sum2 (int arr[ ][4], int rows ); // valid declaration ✌ ✆ says that ‘arr’ points to an array of four integers, so ‘arr+1’ means “add 16 bytes to the address”. If first bracket contains a number then it will be ignored. ✞ 1 int sum2 (int ar [3][4] , int rows ); // valid declaration , 3 ignored ✌ ✆ ✞ 1 #include <stdio.h> #define ROWS 3 3 #define COLS 4 int sum(int rows , int cols , int ar[rows ][ cols ]); 5 int main (void ) { 7 int i,j; int varr [ROWS ][ COLS ]; 9 for (i = 0; i < ROWS ; i++) for (j = 0; j < COLS ; j++) 11 varr [i][j] = i * j + j; printf("3x4 Array n"); 13 printf("Sum of all elements = %dn", sum(ROWS , COLS , varr )); 15 return 0; } 17 int sum(int rows , int cols , int ar[rows ][ cols ]) { int r; 19 int c; int tot = 0; 21 for (r = 0; r < rows ; r++) for (c = 0; c < cols ; c++) 23 tot += ar[r][c]; return tot; 25 } ✌ ✆ ✞ 3x4 Array Sum of all elements = 36 ✌ ✆ An array can passed to a function by using function prototype as shown in syntax given below: ✞ #include <stdio.h> 2 void PrintIt (char Str[ ]) { 4 printf("%sn", Str);
- 73. 258 Array &Pointer } 6 int main () { 8 char label[ ] = "Allora Caves."; PrintIt (label); 10 return 0; } ✌ ✆ The output is ✞ Allora Caves. ✌ ✆ Function PrintIt() expects a character array. When an array is declared as the parameter to a function, it really gets a pointer. Arrays are always automatically passed by reference. Similarly a pointer can also pass to a function as an array or as a pointer. ✞ 1 #include <stdio.h> 3 void PrintIt (char Str[ ]) { printf("%sn", Str); 5 } 7 int main () { char * label = "Allora Caves."; 9 PrintIt (label); return 0; 11 } ✌ ✆ The output is ✞ Allora Caves. ✌ ✆ ✞ 1 #include <stdio.h> 3 void PrintIt (char *Str) { printf("%sn", Str); 5 } 7 int main () { char * label = "Allora Caves."; 9 PrintIt (label); return 0; 11 } ✌ ✆ The output is ✞ Allora Caves. ✌ ✆ Unfortunately, (in C and C++) the length of the array cannot be obtained from an array passed to a function at run time, because the size of an array is not stored anywhere. The compiler always replaces sizeof () with a constant. See the following example
- 74. 2.1. ARRAY 259 ✞ 1#include <stdio.h> #include <string.h> 3 #define NUM_ELEM (x) (sizeof (x) / sizeof (*(x))) 5 int sum(int input_array [ ]) { 7 int sum_so_far = 0; int i; 9 /* Would NOT Work ; input_array was* *not defined in this function . */ 11 for (i = 0; i < NUM_ELEM (input_array ); i++){ sum_so_far += input_array [i]; 13 }; return ( sum_so_far ); 15 } 17 int main (int argc , char *argv [ ]) { int left_array [ ] = {1, 2, 3}; 19 int right_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; int the_sum = sum(left_array ); 21 printf("the sum of left_array is: %d n", the_sum ); the_sum = sum(right_array ); 23 printf("the sum of right_array is: %d n", the_sum ); 25 return 0; } ✌ ✆ When this example is run, it gives output as shown below ✞ the sum of left _array is 1 the sum of right_array is 10 ✌ ✆ whatever the values are passed as argument in the sum function. This ‘sum()’ routine needs to handle more than just one constant length of an array. There are some common ways to work around this fact: 1. Write the function as required, for each array parameter and parameter “length” which has type “size t”. We can use sizeof () at the point where this function is called. 2. Use of a null-terminated string to mark the end of the array if array is string. Arrays representing to numbers does not need the null-terminating string to mark of the end of array. Instead it, number arrays are passed to the function along with its element size. 3. Pass the arrays as well as array length parameter to the function. We can pass the pointer-to-array if required. Evaluate the data as per rules set by function statements or expressions. Using these facts, above example is now modified as given below.
- 75. 260 Array &Pointer ✞ #include <stdio.h> 2 #define NUM_ELEM (x) (sizeof (x) / sizeof (*(x))) 4 int mySum(int array[ ], size_t length) { 6 int sum = 0; int i; 8 for (i = 0; i < length; i++) { sum += array[i]; 10 }; return ( sum); 12 } 14 int main (int argc , char *argv [ ]) { int sum; 16 int i_array [ ] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; /* Works here , because the size of right_array * 18 *is passed to the sum function as argument */ sum = mySum(i_array , NUM_ELEM (i_array )); 20 printf("The sum is : %d.n", sum); 22 return 0; } ✌ ✆ Output of above example is ✞ the sum is : 55 ✌ ✆ The same method of passing an array to a function and getting sum of all array element is also possible with other number datatypes. Above example is suitable modified for array contains floating type numbers. ✞ 1 #include <stdio.h> 3 #define NUM_ELEM (x) (sizeof (x) / sizeof (*(x))) 5 /* Function returns floating data . So mySum()* *should be declared as floating data type . */ 7 float mySum(float in_array [ ], size_t length) { float sum = 0; 9 int i; for (i = 0; i < length; i++) { 11 sum += in_array [i]; }; 13 return ( sum); } 15 int main (int argc , char *argv [ ]) { 17 float sum; float array[ ] = {10.10 , 50.50 , 4.57, 1.21}; 19 sum = mySum(array , NUM_ELEM (array));
- 76. 2.1. ARRAY 261 printf("Thesum is : %fn", sum); 21 return 0; } ✌ ✆ ✞ The sum is : 66.379997 ✌ ✆ It’s worth mentioning that sizeof () operator has two variations: sizeof (type) and sizeof (<expression>). An example using sizeof () function to a pointer is shown below. ✞ 1 #include <stdio.h> #include <string.h> 3 int main (int argc , char *argv [ ]) { 5 char buffer [10]; if (argc < 2) { 7 fprintf (stderr , "USAGE: %s stringn", argv [0]) ; return 1; 9 } strncpy (buffer , argv [1], sizeof ( buffer)); 11 buffer[sizeof (buffer) - 1] = ’0 ’; return 0; 13 } ✌ ✆ Output of the script is ✞ USAGE: executable .exe string ✌ ✆ 2.1.5 String As Array C has no built in string handling facilities. Consequently, string is defined as array of characters. C allows a character array to be represented by a character string rather than a list of characters, with the null terminating character, automatically added to the end. Example of string array is shown below. ✞ 1 char s[ ] = {’A’, ’p’, ’p’, ’l’, ’e’, ’s’, ’0’}; ✌ ✆ A p p l e s 0 s Figure 2.10: Array of characters constructing word ‘Apples’ is stored in memory and pointed by variable ‘s’. Normally size of string array is controlled at initialisation. An string array can store only the number of characters upto its length. Rest of the characters are ignored. In following example only ten characters will be stored in the string array ‘mystr’.
- 77. 262 Array &Pointer ✞ 1 char mystr [10] = "Apple is red."; ✌ ✆ It is convenient to let the compiler determine the array size. If one omits the size in an initializing declaration, the compiler determines the size for supplied string. In following example, compiler set the string length of thirteen characters. ✞ 1 char mystr[ ] = "Apple is red."; ✌ ✆ A pointer notation may aslo be set up to represent a string. In pointer notation, above example will be look like ✞ 1 const char *ptrstr = "Delhi"; ✌ ✆ D e l h i 0 ptrstr Figure 2.11: Character array ‘Delhi’ stored in memory. ‘ptrstr’ points to the character array ‘Delhi’. Both declarations amount to saying that ‘ptrstr’ is a pointer to the indicated string. Strings as array or pointer, are same but only the pointer version can use the increment operator while array version does not support increment operator. To create an extra long string, string is splitted into multiple sections, by closing the first section with a quote, and recommencing the string on the next line (also starting and ending in a quote): ✞ 1 char string[ ] = "This is a very , very long " "string that requires two lines."; ✌ ✆ See the example below ✞ #include <stdio.h> 2 int main () { 4 char ch; char string[ ] = "Two lines " 6 "string."; int i = 0; 8 while (string[i] != ’0’) { ch = string[i]; 10 printf("%c.", ch); i++; 12 } return (0); 14 } ✌ ✆
- 78. 2.1. ARRAY 263 ✞ T.w.o..l.i.n.e.s. .s.t.r.i.n.g... ✌ ✆ When an array is assigned the characters to get the string, there must be a terminating null character. Otherwise there shall be garbage output. For example following syntax has no terminating null character. It is not in standard format. ✞ 1 char a[10]; a[0]= ’a’; 3 a[1]= ’r’; a[2]= ’u’; ✌ ✆ This format should be like ✞ char a[10]; 2 a[0]= ’a’; a[1]= ’r’; 4 a[2]= ’u’; a[3]= ’0’; ✌ ✆ See following two examples, in which string is terminating without and with null character. First example gives garbage output (see below). ✞ 1 #include <stdio.h> 3 int main () { char a[10]; 5 a[0]= ’a’; a[1]= ’r’; 7 a[2]= ’u’; printf("%s",a); 9 return 0; } ✌ ✆ ✞ <garbage output > ✌ ✆ In this second example, string is terminated with null character. This example gives output what we required. ✞ 1 #include <stdio.h> 3 int main () { char a[10]; 5 a[0]= ’a’; a[1]= ’r’; 7 a[2]= ’u’; a[3]= ’0’; 9 printf("%s",a); return 0; 11 } ✌ ✆
- 79. 264 Array &Pointer ✞ aru ✌ ✆ Size of static array should be larger by one to the original data size being stored in the array. This extra byte is for NULL terminator, i.e. 0. To store one byte data, array size should be larger than one. For storing n byte data, array size should be > n. Here two examples are given. In first example, array size is equal to the data size and in second example, array size is larger than data size by one. This extra one byte is used to store null terminating character. ✞ 1 #include <stdio.h> #include <stdlib.h> 3 int main (void ) { 5 /* Deficient static array * * size declared as char c.*/ 7 char c[1]; printf("Enter char ’e’ : "); 9 gets (c); if (( strcmp(c, "e") == 0)) 11 printf("%sn", c); return 0; 13 } ✌ ✆ On compilation, it gives error while following example gives desired output. ✞ 1 #include <stdio.h> #include <stdlib.h> 3 int main (void ) { 5 /* Suficient static array * * size declared as char c.*/ 7 char c[2]; printf("Enter char ’e’ : "); 9 gets (c); if (( strcmp(c, "e") == 0)) 11 printf("%sn", c); return 0; 13 } ✌ ✆ ✞ e ✌ ✆ In first example, array ‘c’ can store only character ‘c’. There is no extra space to store null terminating character. It makes that array ‘c’ does not hold string in proper format. In second example, array ‘c’ can store one character as well as null terminating character. By this way it holds string in proper format. 2.1.6 Size of Array C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated at run-time). The length of a dynamic array cannot be acquired from the array itself -
- 80. 2.1. ARRAY 265 itslength must be stored elsewhere. The size of static array is computed as ✞ 1 int length = sizeof(<array name >) / sizeof(<array element >); ✌ ✆ Preprocessor ways for array length is defined as ✞ 1 #define ARRAY_LENGTH (A) (sizeof(A) / sizeof(A[0]) ) ✌ ✆ i0 i1 i2 i3 i4 3 6 9 12 15 anArray n Figure 2.12: Size of ‘anArray’ is the number of elements pointed by ‘anArray’. Here remember that array is of integer type, hence each element shown in this figure needed 4 bytes long memory space. There are 5 elements in this array, so size of ‘anArray’ is 5 (n = 5) and these elements needed 5 × 4 = 20 bytes long memory space. Array becomes pointer when it is passed as a parameter to a function. Thus, the length of an array parameter may not require directly but a dedicated length parameter is required and should be passed to the function. See the following example is given string array ‘fruit’ is declared with static size of 2 elements in each row while each row is pointed by ‘fruit’ pointer itself. Hence the element size is fixed so, there is no need to calculate the length size of array. But in this example, length is computed by using above syntax. ✞ 1 #include <stdio.h> 3 int main (){ const char *fruit[2] = { "apples", "oranges" }; 5 /* Length of the array by dividing * 7 *the size of all elements by the* *size of the first element. */ 9 int length = sizeof(fruit) / sizeof(fruit[0]) ; 11 printf("%dn", length); 13 return 0; 15 } ✌ ✆ ✞ 2 ✌ ✆ In above example, length of the array is obtained by dividing the size of all elements (found with sizeof (fruit)) by the size of the first element. Note that since the array elements are pointers to null-terminated character arrays, the size of the first element is actually the size of the pointer type - not the length of the string. This size, regardless of the type being pointed to, is 8 bytes, 4 bytes, or 2 bytes on 64-bit, 32-bit, or 16-bit
- 81. 266 Array &Pointer platforms respectively. Pointer can be used for variable size array as shown in example below. ✞ 1 #include <stdio.h> /* Variable size array.*/ 3 char *name ; int main () { 5 name ="My School!!"; int i=0; 7 while(name [i] !=’0 ’){ printf("%cn",name [i]); 9 i++; } 11 return 0; } ✌ ✆ ✞ M y S c h o o l ! ! ✌ ✆ 2.1.7 Vector & Matrix Vector is a one dimensional array or a matrix having one rows and multiple columns. A vector is represented by A = [1, 2, 3, 5]. A matrix is vertical arrangement of vectors. Vec- tors are one dimensional arrangement of coefficients of variables of an algebraic equation. Let an algebraicequation ax + by = k, that is written as ax + by − k = 0 Now, vector u for this algebraic equation is given by u = [a, b, −k] If there is a set of two algebraic equations, ax + by − k = 0 cx + dy − l = 0 Then two vectors of these two algebraic equations are u and v respectively as u = [a, b, −k]; v = [c, d, −l]
- 82. 2.1. ARRAY 267 Thematrix arrangement like AX = B is a b −k c d −l x y 1 = 0 0 Here, matrix A is row arrangement of two vectors u and v. Similarly, for example, vectors A = [1, 2, 3, 5] and B = [5, 4, 3, 2] form a matrix when these vectors are arranged vertically. C =
- 86. 1 2 35 5 4 3 2
- 90. Here, C isa 2 × 4 matrix. A one dimensional vector is defined in C like ✞ #include stdio.h 2 int main (void ) { 4 int A[5]; int i; 6 for (i = 1; i 5; i++) { A[i] = i; 8 } for (i = 1; i 5; i++) { 10 printf(%dt, A[i]); } 12 return 0; } ✌ ✆ ✞ 1 2 3 4 ✌ ✆ A matrix is defined in C like ✞ 1 #include stdio.h 3 int main (void ) { int A [2][5]; 5 int i, j; for (i = 0; i 2; i++) { 7 for (j = 0; j 4; j++) { A[i][j] = i + j; 9 } } 11 for (i = 0; i 2; i++) { for (j = 0; j 4; j++) { 13 printf(%dt, A[i][j]); } 15 printf(nn, A[i][j]); } 17 return 0; } ✌ ✆
- 91. 268 Array Pointer ✞ 0 1 2 3 1 2 3 4 ✌ ✆ In C, arrays, vectors and matrices are defined in same ways. 2.1.8 Sparse Matrix A sparse matrix is one which have majority number of zeros along rows and columns. For example a sparce matrix is S = 0 0 0 0 0 0 1 2 0 1 0 2 1 0 2 0 0 0 0 0 0 1 2 0 1 C program for sparse matrix is given below: ✞ 1 #include stdio.h #include time .h 3 int main () { 5 time_t t1 , t2; t1 = time (NULL ); 7 static int array [10][10]; int i, j, m = 5, n = 5; 9 int counter = 0; for (i = 0; i m; ++i) { 11 for (j = n; j 0; --j) { t2 = time (NULL ); 13 array[i][j] = (i * j + t2) % (t1 % 5 + 1); if (array[i][j] == 0) { 15 ++ counter ; } 17 } } 19 printf(Matrix is : n); for (i = 0; i m; ++i) { 21 for (j = 0; j n; ++j) { printf(%dt, array[i][j]); 23 } printf(n); 25 } if (counter ((m * n) / 2)) { 27 printf(Matrix is sparse matrix n); } else { 29 printf(Matrix is not a sparse matrix n); } 31 printf(There are %d number of zeros.n, counter );
- 92. 2.2. POINTER 269 return0; 33 } ✌ ✆ Above proram uses the current CPU time so each time when program is run, a different matrix is generated. The matrix generated may be a sparse matrix or not. The one run state matrix generated by above program is given below, which is not a sparse matrix. ✞ Matrix is : 0 4 4 4 4 0 0 1 2 3 0 1 3 0 2 0 2 0 3 1 0 3 2 1 0 Matrix is not a sparse matrix There are 4 number of zeros. ✌ ✆ 2.2 Pointer A pointer is a simple variable that stores the address (the location in memory) of a value in memory rather than storing data itself. A variable is said to be declared as a pointer if it prefixed with an asterisk symbol. A variable name with prefixed ampersand () defines the address of itself. A pointer with prefixed asterisk, except declaration, refers to the value of the variable whose address is pointed-by the pointer. The address to which pointer points is called pointee address. 0×50 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 0×0504 int *i; pointer address pointee address There are two valid pointer operations, (i) comparison of two pointers and (ii) addi- tion or subtraction. Address of memory cell and value stored at that memory cell both constitute different meanings. Memory is array of many bits which is capable of storing values either binary 1 or binary 0. This size of memory has no meaning as it can not store large numeric value, so multiple bits are grouped to form bytes (one byte has 8 bits). Too store an integer, 4 bytes (32 bits) are grouped together. See the following constitution of memory cells. 0×1001 0×1005 0×1009 0×1013 Value at memory cell Address of memory cell 00000000 00000000 00000011 11101001
- 93. 270 Array Pointer In which, each memory cell or memory location is identified by its address and it contains a value. See an example given below. Read program line-by-line alongwith comments carefully. ✞ #include stdio.h 2 int main (){ /*i points to memory location where 10 is stored. */ 4 int i=10; 6 /* Pointer j points to a random address */ int *j; 8 /* Now j points to same address as i is pointing . */ 10 j=i; // i and j points to same address. 12 /*j stored value at its address.*/ *j=20; 14 /*As i and j points to same memory location * 16 *( addresses ) therefore , values of i and j * *are equal. So , i = 20. */ 18 printf(%d,i); //i has same value as j; return 0; 20 } ✌ ✆ ✞ 20 ✌ ✆ An array name is also the address of the first element of the array. That is, if ‘arr’ is an array, then ✞ 1 arr == arr [0]; // name of array is the // address of the first element ✌ ✆ Both ‘arr’ and ‘arr[0]’ represent the memory address of first element of the array. It is also called the reference of the array ‘arr’. A pointer can points to any element of the array, if the pointer is assigned address of that element. In the following example, pointer ‘x’ points to the address of first element of the array ‘i’. ✞ #include stdio.h 2 int main () { 4 int i[5] = {10, 20, 30, 40, 50}; int *x = i[0]; /* Points to first element.*/ 6 printf(%d, *x); return 0; 8 } ✌ ✆
- 94. 2.2. POINTER 271 0×10 10 0×11 20 0×12 30 0×13 40 0×14 50 i[] x The output of above program shall be ✞ 10 ✌ ✆ If above example is modified as given below, then the pointer ‘x’ points to the 3rd element of the array ‘i’. ✞ 1 #include stdio.h 3 int main () { int i[5] = {10, 20, 30, 40, 50}; 5 int *x = i[2]; /* Points to third element.*/ printf(%d, *x); 7 return 0; } ✌ ✆ 0×0 10 0×1 20 0×2 30 0×3 40 0×4 50 i[ ] x The output of above program shall be ✞ 30 ✌ ✆ If an integer is pointed by a pointer-to-char variable, then this variable can points to the address of each byte of the integer variable (integer variable is 4 bytes long). ✞ 1 #include stdio.h 3 int main () { /* 1000 D = 1111101001 B*/ 5 int i = 1001; /* Pointer casting from integer to character .*/ 7 char *x = (char *) i; /* Little endian is x[0]=11101001 B* 9 *Big endian is x[1]=00000011 B* *Big endian x[2]= x[3]=00000000 B*/ 11 /* Print little endian x[0]*/ printf(%d, (int) x[0]) ; 13 return 0; } ✌ ✆
- 95. 272 Array Pointer x[3] x[2] x[1] x[0] i: x 00000000 00000000 00000011 11101001 Output of above program is ✞ -23 ✌ ✆ ✞ 1 #include stdio.h 3 int main () { /* 1000 D = 1111101001 B*/ 5 int i = 1001; /* Pointer casting from integer to character .*/ 7 char *x = (char *) i; /* Little endian is x[0]=11101001 B* 9 *Big endian is x[1]=00000011 B* *Big endian x[2]= x[3]=00000000 B*/ 11 /* Print big endian x[1]*/ printf(%d, (int) x[1]) ; 13 return 0; } ✌ ✆ x[3] x[2] x[1] x[0] i: x 00000000 00000000 00000011 11101001 Output of above program is ✞ 3 ✌ ✆ Though, the pointers allow increment and decrement operations but they are not preferred over indexed arrays when there is requirement of random access. In indexed arrays, fifth element can be accessed by myArr[4]. But in pointer array, we have to first reach at the address of fifth element by using pointer increments or decrements operations and then dereference the pointer. So, pointer requires extra coding to reach at desire destination. Identification of Pointer Type We know that, in C, a variable is declared as ✞ 1 datatype var name ; ✌ ✆ There are three main form of variable object declarations. (i) normal variables, (ii) arrays and (iii) functions. Their prototypes are respectively
- 96. 2.2. POINTER 273 ✞ 1int i; // normal variable int k[10]; // array variable 3 int f(); // function variable ✌ ✆ In above three declarations, priority is observed to identify the type of variable. In first case, variable ‘i’ is normal integer type variable which stores integer values. It means where ever it stores a value, it will be an integer. Priority of variable literal is lower than square brackets or parentheses. A variable is followed by square brackets, then it is treated as an array. Similarly, if a variable is followed by parentheses, then it is treated as function. Now, the question is, how we identify the nature of variable when asterisk is prefixed to variable literals to make it pointer variable as shown below: ✞ 1 int *i; int *k[10]; 3 int *f(); ✌ ✆ Its answer is again priority listing. The priority of pointer symbol (asterisk) is less than array symbol or parentheses. Hence first declaration is pointer to integer. In second declaration, priority of variable ‘k’ goes with array symbol and asterisk makes it pointers. Hence, it will be pronounce as “array k of pointers-to-integers”. Note that, datatype only told about the type of data pointed by the pointers, not about the type of pointer itself. Similarly, third declaration is “function which returns a pointer pointing-to-an-integer value”. Remember, array always stores values and function always returns a value. Now, parentheses are used to change the priority of asterisk like ✞ 1 int *i; int (*k)[10]; 3 int (*f)(); ✌ ✆ The first declaration has no change. It is pointer to an integer. In second declaration, priority of asterisk goes with ‘k’. Hence it is pronounce as “pointer ‘k’ to an array (due to presence of square bracket) of integers (array stores integer type values)”. Similarly third declaration is pronounced as “pointer ‘f’ points to a function (due to presence of parentheses) which returns an integer value”. So, be careful while using pointers with specific priorities. There is not change in the priority if data type is changed. For example, only stored value at pointee address is changed to real (double data type) from integer if above declaration is modified as ✞ 1 double *i; double (*k)[10]; 3 double (*f)(); ✌ ✆ 2.2.1 Declaring pointers When a variable name is preceded by asterisk symbol during its declaration, it is called pointer variable. In the following variable declarations:
- 97. 274 Array Pointer ✞ 1 long *var1 , var2 ; // Declaration of pointer int **p3; // Declaration of pointer to a pointer ✌ ✆ In line 1, ‘var1’ is declared as a pointer variable to a long data type, i.e. data stored at the pointed-to address will be long data type. And ‘var2’ is declared as a long data type variable and it is not a pointer to a long data type as it is not preceded by asterisk symbol. In line 2, ‘p3’ is declared as a pointer to a pointer to an int data type. Data types which precedes to a pointer variable during pointer declaration specify about the data read or write at the address pointed-to by the pointer variable. If data type is char type, then will be read at the address location in group of one byte. If data type is int type, then data will be read at the address location in group of four bytes and so on. Remember that uninitialized pointers results in dangling or wild pointers, therefore each pointer declared must be initialized as NULL pointer. ✞ int *p = NULL ; // Declaration initialization of pointer ✌ ✆ It is also safe to initialized a pointer to NULL when its allocated memory is freed by using free() function. ✞ 1 int *p = NULL ; // Declaration initialization of pointer p=malloc (10) ; // Allocate memory space 3 free (p); // Free memory space allocated to pointer p=NULL ; // Initialize NULL to pointers ✌ ✆ Pointer types are often used as parameters to function calls. ✞ int MyFunction ( struct MyStruct *pStruct ); ✌ ✆ In the above syntax, it is explained that how to declare a function which uses a pointer as an argument. Since C passes function arguments by value, in order to allow a function to modify a value from the calling routine, a pointer to the value must be passed. Pointer- to-Structure is also used as function arguments even when nothing in the struct will be modified in the function. This is done to avoid copying the complete contents of the structure onto the stack. A simple example is ✞ 1 #include stdio.h #include time .h 3 void getSeconds (unsigned long *par); 5 int main () { unsigned long sec; 7 getSeconds ( sec); printf(No. of seconds since 01 Jan 1970: %ldn, sec); 9 return 0; } 11 void getSeconds (unsigned long *par) { 13 *par = time (NULL ); return; 15 } ✌ ✆
- 98. 2.2. POINTER 275 ✞ No.of seconds since 01 Jan 1970: 1420616845 ✌ ✆ Solved Problem 2.1 See the following memory arrangement. A pointer variable is declared and assigned address as given in below code lines. What will be the print output? Solution The memory arrangement is : 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 ✞ 1 char *ptr =0 x53; printf(%d, *ptr); ✌ ✆ Here, pointer is declared as char type, hence it shall read data stored at address 0×53 in a group of one byte (byte group size is equal to the size of char data type). 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 So, the printf function will give output in decimal form which is equal to the value stored at the address of 0×53. From the memory arrangement, value is 100101012, that is decimal equivalent to 14910. Solved Problem 2.2 See the following memory arrangement. A pointer variable is declared and assigned address as given in below code lines. What will be the print output? Solution The memory arrangement is : 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 ✞ short *ptr =0 x53; 2 printf(%d, *ptr); ✌ ✆ Here, pointer is declared as short type, hence it shall read data stored at address 0×53 in a group of two bytes (bytes group size is equal to the size of short data type). 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 So, the printf function will give output in decimal form which is equal to the value stored in two consecutive bytes whose first byte is at the address of 0×53. From the memory arrangement, value is 10010101101101012, that is decimal equivalent to 3832510.
- 99. 276 Array Pointer Solved Problem 2.3 See the following memory arrangement. A pointer variable is declared and assigned address as given in below code lines. What will be the print output? Solution The memory arrangement is : 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 ✞ short *ptr =0 x53; 2 printf(%d, *( ptr ++)); ✌ ✆ Here, pointer is declared as short type, hence it will point to address of data stored from address 0×53 onward in a group of two bytes (bytes group size is equal to the size of short data type). The increment of pointer ‘ptr++’ will increase the address pointed by the pointer variable ‘ptr’ by two bytes (equal to the size of declaration data type, here it is short). 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 00000000 00000000 10010101 10110101 10110101 11111111 10011101 10101101 10010001 Thus the address pointed by the pointer variable ‘ptr’ is 0×55. So, the printf function will give output in decimal form which is equal to the value stored in two consecutive bytes whose first byte is at the address of 0×55. From the memory arrangement, value is 10110101111111112, that is decimal equivalent to 4659110. Assigning values to pointers A pointer variable points to an address. So, its value is always an address of other variable. The address of a variable is accessed by using ‘address of’ operator, represented by symobl ‘’. The standard procedure of assigning value to a pointer variable is shown in the following code snippets. ✞ /*An interger variable that have * 2 *null value stored in memory. */ int myInt; 4 /* Pointer that addresses to a integer value.*/ int *ptr; 6 /* Address to the pointer where * *myInt value is stores in memory.*/ 8 ptr = myInt; ✌ ✆ Here, ‘ptr’ will now reference to ‘myInt’. Pointers can also be assigned to dynamically allocated memory. See the following example. ✞ #include stdio.h 2 int j, k; int *ptr; 4
- 100. 2.2. POINTER 277 intmain (void ) { 6 j = 1; k = 2; 8 ptr = k; printf(j has value %d and stored at %pn, j, (void *) j); 10 printf(k has value %d and stored at %pn, k, (void *) k); printf(‘ptr’ = %p and stored at %pn, ptr , (void *) ptr); 12 printf(Value of the integer pointed -by ‘ptr’ is %dn, *ptr); return 0; 14 } ✌ ✆ ✞ j has value 1 and stored at 0x403100 k has value 2 and stored at 0x403120 ‘ptr ’ has value 0x403120 and stored at 0x403110 Value of the integer pointed -by ‘ptr ’ is 2 ✌ ✆ 2 0×50 3 0×51 4 0×52 5 0×53 6 0×54 7 0×55 8 0×56 int *ptr = k k k A pointer is created by using asterisk (*) as shown in the first line of the below code. Method of value assignment to the variable is shown in second line of the following code. ✞ int *j; 2 j = 5;/* Valid good practice .*/ ✌ ✆ This type of assignment updated value stored at the address of pointer variable itself. In above type of pointer assignment, pointer now points to the memory whose address is 0×05. See the example ✞ #include stdio.h 2 int main () { 4 int *j; j = 5; /* Valid good practice .* 6 *It accepts address. */ printf(j is : %dn, j);// prints address pointed 8 //by the pointer variable return 0; 10 } ✌ ✆ ✞ j is : 5 ✌ ✆ As pointers holds the address of other variables or objects, hence what ever value is assigned to pointers is treated as memory address. Note that, addresses are represented
- 101. 278 Array Pointer in hexa-decimal form, hence all other values are converted into equivalent hexadecimal values. Method of assigning a value to a pointer as shown below is invalid. This is due to assigning value to an uninitialised pointer. An uninitialized pointer points to null memory address. So, when we tries to update the value at the memory address that is pointed by the pointer, it shows errors. ✞ 1 int *j;// No address with pointer to point. *j = 5;/* Invalid as it tries to alter value * 3 * stored at address pointed by j. * *It is very bad practice . */ ✌ ✆ A pointer points to the memory location (address) where value is stored. Pointer does not store value itself. So, pointer does not know where value is stored. If we try to do so, the program either may crash or it damaged to the system. A best practice of assigning a pointer is explained in the following example. ✞ #include stdio.h 2 int main () { 4 int i = 0; int *j; 6 j = malloc (2 * sizeof (int)); j = 5; /* valid good practice to assign address */ 8 printf(j is : %dn, j);// prints address j = 6; /* valid good practice to assign address */ 10 printf(j is : %dn, j);// prints address return 0; 12 } ✌ ✆ ✞ j is : 5 j is : 6 ✌ ✆ Another example ✞ #include stdio.h 2 int main (void ) { 4 int i; int *p; 6 p = i; /* valid for best practice */ i = 10; /*i is now 10 */ 8 *p = 20; /* valid*/ /* prints 20*/ 10 printf(i is %dn, i); /* Prints value stored at address pointed by the pointer.*/ 12 printf(i is %dn, *p); return 0; 14 } ✌ ✆
- 102. 2.2. POINTER 279 ✞ iis 20 i is 20 ✌ ✆ Pointer Dereferencing (Value Finding) Pointer dereferencing or value finding or indirection is a method to extract the value stored at given memory address. To access a value to which a pointer points, the ‘*’ operator is used. Another operator, the ‘–’ operator is used in conjunction with pointers to structures. To understand dereferencing, take a memory arrangement as shown below: A 0×11 B 0×12 C 0×13 D 0×14 E 0×15 F 0×16 G 0×17 H 0×18 I 0×19 Now, we declare a pointer and assign an address as ✞ char *x = 22; 2 printf(%c, *x); ✌ ✆ 0×2A 00010110 ∗x It does not gives character whose character code is equal to 22 but it gives the character that is stored at address of 0×16 (decimal 22 and binary 00010110). And from the above memory arrangement, it is character F. There can use ‘’ and ‘*’ alternatively. Here operator ‘*’ is used for dereferencing and the operator ‘’ is used to get the address. When they are used in group, they cancel the effect of each other. See the example below: ✞ #include stdio.h 2 int main () { 4 char *p = Lucknow is capital city of UP.; /* See the sequence of and *. */ 6 printf(%sn, ** p); char *q = Delhi is capital city of India.; 8 /* Sequence of and * is changes */ printf(%sn, ** q); 10 return 0; } ✌ ✆ ✞ Lucknow is capital city of UP. Delhi is capital city of India. ✌ ✆ Again see the modified form of above example.
- 103. 280 Array Pointer ✞ #include stdio.h 2 int main () { 4 char *p = Lucknow is capital city of UP.; printf(%cn, ***p); 6 return 0; } ✌ ✆ ✞ L ✌ ✆ Here, ‘p’ is a pointer to first character of string, which is L. *p gives us L, *p gives address of L, **p again L, **p address of L, and finally ***p gives ‘L’. In case of integer type variables, variables points to the address where integer value is stored. When integer type variables are passed to function as its parameter, then we can either pass the value of the integer type variable or address of the variable. Address of integer type variable is fetched by using ‘’ symbol while the value at the address is catch by using ‘*’ symbol. ✞ 1 #include stdio.h 3 /* Catch value of i as j. Catch the* *value of from address of i as k.*/ 5 void catchI(int j, int *k) { /* The value of parameter k is not * 7 * assigned to any integer variable ,* * hence when we want to print it , * 9 * it must be dereferece first as k * * is still pointing to address of i*/ 11 printf(%d %dn, j, *k); } 13 int main () { 15 int i = 3; catchI(i, i); 17 return 0; } ✌ ✆ ✞ 3 3 ✌ ✆ Now, a question rises that do we can access the value stored at memory by referencing to its address? For example, consider memory arrangement as shown below: 0×1001 0×1005 0×1009 0×1013 Value at memory cell Address of memory cell (i) 00000000 00000000 00000011 11101001
- 104. 2.2. POINTER 281 Avariable (i) points to the address of 0×1013 where data 11101001 is stored in binary format. When we reference to variable (i), we get the value 233 in decimal. Do we can find the value by dereferencing ∗0×1013? The answer is NO, because, 0×1013 is pure integer and dereferencing can only performed on expression of type pointer. So, to get the value from the address 0×1013 we should type cast it like ✞ 1 *( int *) 0 x1013 ✌ ✆ Note that, while we access memory address directly, the System OS may prevent to do so due to memory sharing violation or access violation. See the example below, in which printf tries to print the value stored at address 102010 which is primarily reserved for the application of OS. ✞ 1 #include stdio.h 3 int main (int argc , char ** argv ) { printf(%d.n ,*(int *) 1020); 5 } ✌ ✆ Addition of pointers Following is an example in which addition of a pointer and an integer is explained. ✞ 1 #include stdio.h /* Note that it accepts a pointer to an int */ 3 void increment (int *p){ *p = *p + 1; /* dereference p and add 1 */ 5 } 7 int main (void ) { int i = 20; 9 /* i value is 20 */ printf(i is %dn, i); 11 /* Pass integer to increment function as pointer */ increment (i); 13 /* Prints the value 21*/ printf(i is %dn, i); 15 return 0; } ✌ ✆ ✞ i is 20 i is 21 ✌ ✆ The value of a pointer is the address of the object to which it points. The address of a large object, such as type double variable, typically is the address of the first byte of the object. Applying the * operator to a pointer yields the value stored in the pointed-to object. Adding 1 to the pointer increases its value by the size, in bytes, of the pointed-to type. In following prototypes
- 105. 282 Array Pointer ✞ arr + 2 == arr [2] /* Same address */ 2 *( arr + 2) == arr [2] /* Same value */ ✌ ✆ Again *(arr+2) with *arr+2 are different to each other. The indirection operator (*) binds more tightly (that is, has higher precedence) than +. ✞ *( arr + 2) /* Value of the 3rd element of dates */ 2 *arr + 2 /* 2 added to the value of the 1st element */ ✌ ✆ Pointer address can be changed by using pointer increments. If ‘a’ is a pointer address then ‘a++’ shall be next pointer address. The increments or decrements is equal to the size of data type of pointer. For example, if pointer addresses to a character data type, then its jump is multiple of four bytes. If pointer addresses to an integer data type, then its jump is multiple of one byte. In the following example, the pointer address of pointer ‘name’ is increased by one byte and the value at that pointer location is retrieved and printed in console output. ✞ #include stdio.h 2 /* Pointer array.*/ char *name ; 4 int main () { name =My School!!; 6 /* While pointer value is not null .*/ while(* name !=’0’){ 8 /* Print the pointer value.*/ printf(%cn ,*name ); 10 /* Increase the pointer location .*/ name ++; 12 } return 0; 14 } ✌ ✆ ✞ M y S c h o o l ! ! ✌ ✆ Now a question rises, what happen if a pointer reaches beyond the string length. Answer is, that it starts pointing to the any string supplied as stdin by program itself or by user. Escape characters if present are skipped. See the example below: ✞ 1 #include stdio.h
- 106. 2.2. POINTER 283 /*Pointer array.*/ 3 char *name ; 5 int main () { name = My School; /* string length is 11*/ 7 int i = 0; /* Points to 20 characters started * 9 *from 0 location of name pointer .*/ while (i 20) { 11 /* *name first puts the value of* *string while i =11. When the * 13 *supplied string is ended , it * *starts pointing to the stdin * 15 *string Value at pointer ..... */ printf(Value is : %cn, *name ); 17 /* Increase the pointer location .*/ name ++; 19 i++; } 21 return 0; } ✌ ✆ ✞ Value is : M Value is : y Value is : Value is : S Value is : c Value is : h Value is : o Value is : o Value is : l Value is : Value is : V Value is : a Value is : l Value is : u Value is : e Value is : Value is : i Value is : s Value is : Value is : : ✌ ✆ See another example given below. ✞ #include stdio.h 2 /* Pointer array.*/ char *name ; 4 int main () { 6 name = My School!!;
- 107. 284 Array Pointer int i = 0; 8 /* While pointer value is not null .*/ while (* name != ’0 ’) { 10 /* If i is larger than 5.*/ if (i 5) { 12 /* Decrease the pointer location by 5.*/ name = name - 5; 14 /* Reset i.*/ i = 0; 16 /* Print new line .*/ printf(n); 18 } /* Print the pointer values.*/ 20 printf(%c, *name ); /* Increase the pointer location .*/ 22 name ++; /* Increase i by one.*/ 24 i++; } 26 return 0; } ✌ ✆ ✞ My Sch y Scho Schoo School chool! hool !! ✌ ✆ Passing of Pointers Value assigned to one pointer can be passed to other pointer. Actually, values of both pointers are not copied mutually but pointers are set to point the value of other pointer. See the example given below: ✞ #include stdio.h 2 #include stdlib.h 4 int main () { /* Pointer array.*/ 6 int *x,*y, *z,i=0; x = malloc(sizeof(int)*100); 8 y = malloc(sizeof(int)*100); while(i10) { 10 x[i] = i; y[i] = 3*i; 12 i++; } 14 i=0; printf(Original data is : nx t yn);
- 108. 2.2. POINTER 285 16while(i 5){ printf(%d t, x[i]); 18 printf(%d t, y[i]); printf(n); 20 i++; } 22 /* Mutually transfer the pointers .*/ z=x[0]; 24 x=y[0]; y=z[0]; 26 i=0; printf(nPassing the Pointer , data is : nx t yn); 28 while(i 5){ printf(%d t, *x); 30 printf(%d t, *y); printf(n); 32 x++; y++; 34 i++; } 36 return 0; } ✌ ✆ ✞ Original data is : x y 0 0 1 3 2 6 3 9 4 12 Passing the Pointer , data is : x y 0 0 3 1 6 2 9 3 12 4 ✌ ✆ 2.2.2 Pointers and Arrays String is an array of characters. In other words, an array contains arranged characters one after another. For example ✞ 1 char label[ ] = Single;/* implicitly representation */ ✌ ✆ arranges characters in memory as
- 109. 286 Array Pointer S i n g l e 0 Memory location of the array may be anywhere. The location of array is known as address of the string. Here ‘0’ is null character represents to the end of string. The available spaces (size) of a character array may be larger than the number of characters of abstract string to be held in it. See the example given below. ✞ 1 char label [10] = Single;/* explicitly representation */ ✌ ✆ Characters are arranged in memory like S i n g l e 0 0 0 0 In above type of representation of array is called static representation, because size of allocated memory or size of array is determined at the time of program compilation. When size of array is specified, the number of elements is at least one more than the length of string. Any unused elements are automatically initialized to null character ‘0’. Pointer can hold only an address and they cannot hold all the characters of the character array. It means, special symbol ‘*’ (asterisk) is used to keep track of a string rather than string itself. ✞ 1 char name [ ] = Arun ; char status [10] = Married ; 3 char *Ptr; Ptr = name ; ✌ ✆ The first memory byte of the above variables, i.e. ‘name’, ‘status’ and ‘Ptr’ assumed to be at the location 0×40, 0×50 and 0×60 respectively. The memory arrangement for the ‘name’ variable will be as 0×40 0×41 0×42 0×43 0×44 A r u n 0 The memory arrangement of the variable ‘status’ will be as 0×50 0×51 0×52 0×53 0×54 0×55 0×56 0×57 0×58 0×59 M a r r i e d 0 0 0 and memory arrangement of the pointer variable ‘Ptr’ with holding the address of the variable ‘name’ will be looked like: 0×60 0×61 0×62 0×40
- 110. 2.2. POINTER 287 Duringthe assignment of a pointer to the address of a string array, the pointer must be a character pointer (type of data it points at the address it stored). To assign the address of an array to a pointer, address-of () operator is not used since the name of an array behaves like an address of that array in this context (array name, either string or integer, acts as address itself). A pointer is a non constant pointer1 that points to a non constant string2 where as arrays is a constant pointer3 which points to a non constant string4 . The interaction of pointers and arrays have two fundamental statements about them. 1. A variable declared as an array of some type acts as a pointer to that type. When used by itself, it points to the first element of the array. 2. A pointer can be indexed like an array name. Often, the first case is seen when an array is passed to a function as an argument. The function declares the parameter as a pointer, but the actual argument may be the name of an array. The second case occurs when dynamically allocated memory is accessed. Pointer reference example is given below. ✞ #include stdio.h 2 int main (){ int a[10], *iptr ; 4 iptr = a; *iptr = 5;// update the value of a[0] 6 printf(The first element is %d,iptr [0]) ; return 0; 8 } ✌ ✆ ✞ The first element is 5 ✌ ✆ A function which can accept a pointer, can also accept an array. Pointers also follow the rules of array and array increment processing. ✞ 1 #include stdio.h int my_array [ ] = {1,23,17,4,-5,100}; 3 int *ptr; int main (void ){ 5 int i; /* Point our pointer to the * 7 *first element of the array*/ ptr = my_array [0]; 9 for (i = 0; i 6; i++){ 11 printf(my_array [%d] = %d , i, my_array [i]); printf(ptr + %d = %dn, i, *( ptr + i)); 1 The address it holds can be updated/changed. 2 String size is dynamic as pointer points to the address of first character of string. 3 Array name always points to that address at which its data is stored. This address can not be changed as if it is changed, array name starts pointing to something else. 4 String size is dynamic as pointer points to the address of first character of string.
- 111. 288 Array Pointer 13 } return 0; 15 } ✌ ✆ ✞ my_array[0] = 1 ptr + 0 = 1 my_array[1] = 23 ptr + 1 = 23 my_array[2] = 17 ptr + 2 = 17 my_array[3] = 4 ptr + 3 = 4 my_array[4] = -5 ptr + 4 = -5 my_array[5] = 100 ptr + 5 = 100 ✌ ✆ The average example is given below. ✞ #include stdio.h 2 double getAverage (int *arr , int size ); int main () { 4 int balance [5] = {200, 20, 30, 40, 50}; double avg; 6 avg = getAverage ( balance , 5 ) ; printf(Average value is: %fn, avg ); 8 return 0; } 10 double getAverage (int *arr , int size ){ 12 int i, sum = 0; double avg; 14 for (i = 0; i size ; ++i){ sum += arr[i]; 16 } avg = (double)sum / size ; 18 return avg; } ✌ ✆ ✞ Average value is: 68.000000 ✌ ✆ A function should never return a pointer to a local variable, even when the compiler not complains. When declaring an array as variable of the function without size, it is equivalent to declared pointer. Often this is done to emphasize the fact that the pointer will be used in a manner equivalent to an array. In the following example ✞ 1 #include stdio.h 3 void main (void ) { char str_arr[ ] = This is string array.; 5 char *str = This is string pointer .; int i = 0; 7 while (i 10) { printf(%stt%sn, str_arr ++, str ++); 9 i++; }
- 112. 2.2. POINTER 289 11return 0; } ✌ ✆ Increment and decrement operation is not allowed in arrays while pointers accepts incre- ment or decrement operations. It is because ‘str arr’ is a fixed address variable. A pointer can points to the address of specific index element. It can be done like ✞ char s[ ]={ ’a’, ’b’, ’c’, ’d’}; 2 /* char a is at index 0. * *char b is at index 1. * 4 *char c is at index 2. * *char d is at index 3. */ 6 p = s[3]; /* Pointer grabs the address of* *3rd index element of array s*/ ✌ ✆ Note that pointers assigns address among them. For example, if ‘p’ and ‘q’ are pointer variables, and ‘q’ points to the memory address 0×04, then ‘p=q’, pointer ‘p’ shall points to the same address, i.e. to memory address 0×04. See the complete example, that is given below: ✞ 1 #include stdio.h 3 int main (void ) { char s[ ] = {’a’, ’b’, ’c’, ’d’, ’e’, ’n’, ’c’, ’0’}; 5 char *p, *q, *r; p = s[3]; /* Pointer grabs the address of* 7 *3rd index element of array s*/ q = p; /* address assignment from p to q*/ 9 r = s; /* address assignment from s to r*/ printf(Pointer p points to %cn, *p); 11 printf(Pointer q points to %cn, *q); printf(Pointer r points to %cn, *r); 13 return 0; } ✌ ✆ ✞ Pointer p points to d Pointer q points to d Pointer r points to a ✌ ✆ Pointers to Multidimensional Arrays A two dimensional array may be declared be normal array method or by pointer method. A two dimensional array by pointer method is declared as shown in the following syntax. ✞ 1 int (* mArr )[2]; ✌ ✆ Here, ‘mArr’ is a pointer-to-array of two columns. Parentheses are used to make prece- dence of pointer symbol (*) higher than the square bracket operator ([ ]). Square bracket operator ([ ]) has a higher precedence than dereferencing operator (*). Therefore, a declaration such as
- 113. 290 Array Pointer ✞ 1 int *mArr [2]; ✌ ✆ is invalid. An example, in which two dimensional array by pointer method is initialized and its elements are printed in output console. ✞ 1 #include stdio.h 3 int main (void ) { int *mPtr [ ][3] = { 5 {-1, 2, 3}, {4, -3, 5}, 7 {5, 6, -5} }; 9 // int *mPtr [3] = {1, 2, 3}; int i, j; 11 for (i = 0; i 3; i++) { for (j = 0; j 3; j++) { 13 printf(%2dt, *(* mPtr + (3 * i) + j)); } 15 printf(n); } 17 return 0; } ✌ ✆ ✞ -1 2 3 4 -3 5 5 6 -5 ✌ ✆ Pointers as Function Argument Sometime it may be an requirement to invoke a function with an argument that is itself a pointer. A function with a pointer is assigned as ✞ 1 int sum(int * arr); // Valid prototype int sum(int *); // Valid prototype ✌ ✆ sum() gets the address of the first element of the array, and it learns that it will find an integer at that location. This prototype function does not tell the size of array. The more flexible approach of the function is ✞ int sum(int * arr , int n); ✌ ✆ Here ‘arr’ is a pointer to the first element of array and ‘n’ is size of the array. In many instances, the variable is itself a parameter for the current function and may be a pointer to some type of structure. The ampersand character () is not needed in this circumstance to obtain a pointer value, as the variable is itself a pointer. ✞ 1 #include stdio.h
- 114. 2.2. POINTER 291 doublegetAverage (int *arr , int size ); 3 int main () { int balance [5] = {200, 20, 30, 40, 50}; 5 double avg; avg = getAverage (balance , 5); 7 printf(Average value is: %fn, avg); /* Size of the balance in bytes.*/ 9 printf(The size of balance is %zd bytes.n, sizeof balance ); return 0; 11 } 13 double getAverage (int *arr , int size ) { int i, sum = 0; 15 double avg; for (i = 0; i size ; ++i) { 17 sum += arr[i]; } 19 avg = (double) sum / size ; /* array ’arr’ is not as long as balance , because * 21 * it is not array itself. It represents to the * * position of first bytes of the array ‘balance ’.*/ 23 printf(The size of arr is %zd bytes.n, sizeof arr); return avg; 25 } ✌ ✆ ✞ The size of arr is 4 bytes. Average value is: 68.000000 The size of balance is 20 bytes. ✌ ✆ Consider another piece of code as given below. In this example, enum data type is used to define index position of rainbow colors by color name. For example, ‘red’ is at index position ‘0’, ‘orange’ for index ‘1’ and so on. These index values of rainbow colors are accessed by ‘colour’ variable in for() loop as well as these index values are used to get the color name from ‘rainbow’ array. ✞ 1 #include stdio.h 3 enum spectrum { red , orange , yellow , green , blue , indigo , violet 5 } colour; 7 char *rainbow [ ] = {red, orange, yellow, green, blue , indigo, violet}; 9 int main () { 11 for ( colour = red; colour = violet; colour ++) { printf(%s , rainbow [colour ]); 13 } printf(n); 15 return 0;
- 115. 292 Array Pointer } ✌ ✆ ✞ red orange yellow green blue indigo violet ✌ ✆ In following example pointers are used simply for swapping of two integers of variables from each other. Integer type variables are pointers by default. Hence, to pass the values, assigned to integer type variable, to a function, ‘’ symbol is prefixed to the variables to pass the address of the variable value stored in the memory. ✞ 1 #include stdio.h void swap (int *x, int *y); 3 int main () { 5 int a = 2, b = 3; printf(Swapping of values of a and b.n); 7 printf(Value of a is %d and value of b is %d.n, a, b); swap (a, b); 9 printf(Value of a is %d and value of b is %d.n, a, b); return 0; 11 } 13 void swap (int *x, int *y) { int t = *x; 15 *x = *y; *y = t; 17 return; } ✌ ✆ ✞ Swapping of values of a and b. Value of a is 2 and value of b is 3. Value of a is 3 and value of b is 2. ✌ ✆ In the definition of swap() function inside the main function, variables ‘a’ and ‘b’ are used as addresses. In prototype they are declared as pointers. Because ‘a’ and ‘b’ are integers so, ‘x’ and ‘y’ are pointers to integers. Hence the prototype function is declare as ✞ 1 void swap (int *x, int *y) ✌ ✆ Above example is rewritten as shown below. This modified example does not swap the values of integer variables ‘a’ and ‘b’. On passing of values ‘a’ and ‘b’ to swap() function, local variable ‘a’ becomes 2 and ‘x’ becomes 3. Again ‘y’ becomes 2. In this swapping, there is no change in the value of ‘b’. This is why, there is no swapping of values between variables ‘a’ and ‘b’. ✞ 1 #include stdio.h 3 void swap (int x, int y); int main () { 5 int a = 2, b = 3;
- 116. 2.2. POINTER 293 printf(Swappingof values of a and bn); 7 printf(Value of a is %d and value of is %d.n, a, b); swap (a, b); 9 printf(Value of a is %d and value of is %d.n, a, b); return 0; 11 } 13 void swap (int x, int y) { int a = x; 15 x = y; y = a; 17 return; } ✌ ✆ ✞ Swapping of values of a and b Value of a is 2 and value of is 3. Value of a is 2 and value of is 3. ✌ ✆ In function call by passing the address of a variable is also possible. The function accepts a pointer and modified the value at the address of this pointer. Local variable is passed as address to the function, the value of local variable is modified accordingly. ✞ 1 #include stdio.h 3 void myFunc(int *p) { /* Parameter as pointer to integer */ *p = 30; /* Modify the value at the address of pointer */ 5 } 7 int main () { int i = 20; /* Local variable with value 20*/ 9 myFunc (i); /* Address of local var passed to function */ printf(%d, i); /* Print modified value here . It is 30 now*/ 11 return 0; } ✌ ✆ ✞ 30 ✌ ✆ A function may also be declared as pointer and it returns the address of pointer variable being returned by retunrn keyword within its code body. See the following example: ✞ 1 #include stdio.h 3 /* Function shall return address* *of data it has manipulated . * 5 *Catch the address of myStr * *where it is stored in memory.*/ 7 char *myF(char *ch) { /* return the address that was* 9 *caught by function through * *its arguments char *ch */
- 117. 294 Array Pointer 11 return ch; } 13 /* Function shall return address of that * 15 *data , which it has manipulated . Catch* *address of myStr , stored in memory. */ 17 char *myF2 (char *ch) { /* Get string through the address * 19 *caught through argument and * *manipulate string in memory. */ 21 ch [5]= ’X’;/* change alphabet F-X* *using index method. */ 23 ch ++; /* Increase address by one* 25 *Now , it points to ‘B’ */ 27 /* return the address that was* *catched by function through* 29 *its arguments char *ch */ return ch; 31 } 33 int main () { /* Declare a pointer and assign string to it.* 35 *Memory allocated internally as declaration * *and initialization takes simultaneously . * 37 *In case of later assignment , first create * *memory using malloc () then copy string. */ 39 char * myStr = ABCDEFGHIJKLMNOPQRSTUVWXYZ; //OR 41 // char myStr[27] = ABCDEFGHIJKLMNOPQRSTUVWXYZ; 43 /* string variables or string pointers * *acts as their addresses . This is why* 45 * *myStr shows error as we are trying* *to convert address (numeric value) * 47 *into pointers . */ printf(%26sn, myF(myStr)); 49 printf(%26sn, myF2 (myStr)); return 0; 51 } ✌ ✆ ✞ ABCDEFGHIJKLMNOPQRSTUVWXYZ BCDEXGHIJKLMNOPQRSTUVWXYZ ✌ ✆ Address as Function Argument We can pass an address to a function as its argument. The value of the variable at its address is extracted in the function. This value is used in the expressions or the
- 118. 2.2. POINTER 295 statementsin function body. In example given below, integer variable ‘i’ is scanned as integer and stored in the memory address. Address of this variable is passed to function ‘ZeroCumSum’. In the function, value of the address is extracted by dereference and used in the cumulative sum expressions. ✞ #include stdio.h 2 /* Catch address through function argument .*/ int ZeroCumSum (int *i) { 4 int sum =0; /*Do what algorithm said .*/ 6 while (*i 0) { sum += *i; 8 (*i) --; } 10 /* Return result.*/ return sum; 12 } 14 int main () { /* Initialize the variables .*/ 16 int i, csum ; /* Enter a number.*/ 18 printf(Enter a number: ); scanf(%d, i); 20 /* Get cumulative sum. Here , * *i is passed to function as* 22 *as an address argument . */ csum = ZeroCumSum (i); 24 /* Print output.*/ printf(Cumsum is %dn, csum ); 26 return 0; } ✌ ✆ ✞ Enter a number: 10 Cumsum is 55 ✌ ✆ The parameter data type of argument in a function must be same as the data type whose addresses is being passed to the function. ✞ #include stdio.h 2 #include string.h 4 /* Parameter is flaot type , same as * *datatype whose address is passed.*/ 6 void outv (float *f) { printf(%fn, *f); 8 return; } 10 int main () { 12 /* Float data type variable */
- 119. 296 Array Pointer float f=12.5; 14 /* Address of float type variable */ outv (f); 16 return 0; } ✌ ✆ ✞ 12.5 ✌ ✆ Another example with double data type variable. ✞ 1 #include stdio.h #include string.h 3 /* Parameter is flaot type , same as * 5 *datatype whose address is passed.*/ void outv (double *f) { 7 printf(%lfn, *f); return; 9 } 11 int main () { /* Float data type variable */ 13 double f=12.5; /* Address of double type variable */ 15 outv (f); return 0; 17 } ✌ ✆ ✞ 12.5 ✌ ✆ Passing of address of the structures as function parameter is explained in the following example. ✞ 1 #include stdio.h #include string.h 3 struct s { 5 double d; }; 7 /* Parameter is struct type , same as * 9 *datatype whose address is passed. */ void outv (struct s *f) { 11 printf(%lfn, f-d); return; 13 } 15 int main () { /* Structure variable */ 17 struct s myS;
- 120. 2.2. POINTER 297 myS.d= 11.5;// Assignment 19 /* Pass address of structure */ outv ( myS); 21 return 0; } ✌ ✆ ✞ 11.500000 ✌ ✆ Pointer Equivalent to Array A pointer type **p is also represents to an array type arr[ ][ ]. Here [ ][ ] represents to dynamic size of array in two dimensions. Here first asterisk in **p represents to number of the rows while second asterisk represents to dynamic size of each row. It should be remember that, the dynamic length should that dimension which is used to store new data. For example, in two dimensional matrix, column length is fixed and row length is dynamic. So, ✞ 1 /* Fixed col (k) length and variable row length*/ int myA[ ][k]; ✌ ✆ represents to a two dimensional matrix with fixed length of columns and variable length of rows. Arrays declared with variable size returns compile time error if they are not initialized. ✞ #include stdio.h 2 int main () { 4 int mat [][3];/* variable row declaration .*/ return 0; 6 } ✌ ✆ Above example shall return compile time error as the array is not fixed or initialized. Now above code is modified as shown in the following example. ✞ #include stdio.h 2 int main () { 4 /* Array with variable rows declared initialized .*/ int mat[ ][3]={}; 6 int myA [2][3]; /* fixed size declaration .*/ return 0; 8 } ✌ ✆ Now, above example will compile without showing any error. Again, in three dimensional array, rows and columns are fixed in length while layer length (z-axis) is dynamic. So, a three dimensional array is represented as ✞ /* Fixed row (x) col (y) and variable layers*/ 2 int myA[ ][x][y]; ✌ ✆
- 121. 298 Array Pointer A two dimensional array having ‘m’ rows and ‘n’ columns is equivalent to pointer as shown in the syntax given below: ✞ arr[m][n] = *(*( p + m) + n) ✌ ✆ Two dimensional array can be pointed by a pointer variable. Value at the address pointing to an element of the array can be obtain by de-reference. The two dimensional reference is done as shown in the table below. Pointer Equals Array *(*(p + 0) + 0) *(*(p)) p[0][0] *(*(p + 0) + 1) *(*(p) + 1) p[0][1] *(*(p + 1) + 0) *(*(p + 1)) p[1][0] *(*(p + 1) + 1) *(*(p + 1) + 1) p[1][1] *(*(*(p + 0) + 0) + 2) *( **p + 2 ) p[0][0][2] *(*(*(p + 0) + 1) + 0) **(*p + 1 ) p[0][1][0] *(*(*(p + 0) + 0) + 0) ***p p[0][0][0] Table 2.1: Pointer and its equivalent to array. The pointer of a multi-dimensional matrix has meaning like ✞ 1 ...*(*( ptr+i)+j).... ✌ ✆ Here, i is row number and j is column number, all started from zero to continue. 10 0 0 0 20 0 0 0 15 0 0 0 2 0 0 0 *(*(p)) *(*(p)+1) *(*(p+1)) *(*(p+1)+1) c1 c2 r1 r2 ✞ 1 #include stdio.h 3 int main () { int mat [3][3] = { 5 {11, 24, 53}, {45, 45, 64}, 7 {77, 87, 99}
- 122. 2.2. POINTER 299 }; 9printf(mat [0][0] element is = %dn ,*(*(mat +0) +0)); printf(mat [0][2] element is = %dn ,*(*(mat +0) +2)); 11 return 0; } ✌ ✆ ✞ mat [0][0] element is = 11 mat [0][2] element is = 53 ✌ ✆ Similarly, a three dimensional matrix has meaning like ✞ ...*(*(*( ptr+k)+i)+j).... ✌ ✆ Here, i is row number and j is column number and k is layer number, all started from zero to continue. ✞ 1 #include stdio.h 3 int main () { int mat[ ][2][3] = { 5 { {11, 24, 53}, 7 {45, 45, 64} }, 9 { {1, 2, 3}, 11 {5, 4, 6} } 13 }; /* First layer , first row first element */ 15 printf(mat [0][0][0] element is = %dn ,*(*(*( mat +0) +0) +0)); /* Second layer , second row first element */ 17 printf(mat [1][1][0] element is = %dn ,*(*(*( mat +1) +1) +0)); return 0; 19 } ✌ ✆ ✞ mat [0][0][0] element is = 11 mat [1][1][0] element is = 5 ✌ ✆ In the following example, a matrix array is passed to a array ‘ar’ of pointers to an integer and this array pointer is used to access the elements of the matrix. ✞ #include stdio.h 2 int main () { 4 int mat [3][3] = { {11, 24, 53}, 6 {45, 45, 64}, {77, 87, 99} 8 };
- 123. 300 Array Pointer int (*a)[3]; 10 ar=mat; printf(ar [2][2] element is = %dn, *(*( ar +2) +2)); 12 printf(ar [0][2] element is = %dn, *(*( ar +0) +2)); return 0; 14 } ✌ ✆ ✞ mat [2][2] element is = 99 mat [0][2] element is = 53 ✌ ✆ ✞ #include stdio.h 2 int main () { 4 int Arr [3][3] = { {1, 2, 3}, 6 {4, 5, 6}, {7, 8, 9} 8 }; int (* mat)[3]; 10 mat = Arr; printf(Element at mat [0][1] = %dn, *(*( mat +0) +1)); 12 printf(8th element from positino of mat [0][0] = %dn, (*( mat + 0))[8]) ; 14 printf(6th element from position of mat [0][2] = %dn, (*( mat + 0) + 2) [6]) ; 16 return 0; } ✌ ✆ ✞ Element at mat [0][1] = 2 8th element from the position of mat [0][0] = 9 6th element from the position of mat [0][2] = 9 ✌ ✆ Following is an example in which a 3D matrix is accessed by using a pointer. ✞ 1 #include stdio.h 3 int main () { int Arr [3][3][3] = { 5 {/*[x][y] matrix with [z=0]*/ {11, 12, 13}, 7 {14, 15, 16}, {17, 18, 19} 9 }, {/*[x][y] matrix with [z=1]*/ 11 {21, 22, 23}, {24, 25, 26}, 13 {27, 28, 29} }, 15 {/*[x][y] matrix with [z=2]*/