BCA112_BCA117_Computer Programming

194 Computer Programming Consider the following pointer declaration: int x, y; //integer variable declaration int *ptr_x = &x; //integer pointer declaration and initialization The variable ptr_x is declared as pointer variable that can point to a integer quantity. In addition, the address of x is initially assigned to ptr_x Similarly, the above declaration can be written as follows: int x, y; //integer variable declaration int *ptr_x; //pointer variable declaration ptr_x = &x; //assigning address of x to ptr_x Observe that an asterisk is not included in the assignment statement 8.3.3 Null Pointer It is always a good practice to assign a NULL value to a pointer variable in case you do not have an exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer. The NULL pointer is a constant with a value of zero defined in several standard libraries or else it can be defined as a macro in the program. Consider the following C Program: #define NULL 0 int x, y; int *ptr_x = NULL; In the above example, ptr_x is initially assigned a value of 0. In most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location. But by convention, if a pointer contains the null (zero) value, it is assumed to point to nothing. The program can check for NULL pointer using the if statement like if(ptr_x) //succeeds, if ptr_x is not null if(!ptr_x) //succeeds, if ptr_x is null CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 195 8.3.4 What Happens at Memory Level Assume the following snippet for this example: int x=50, y=45; int *ptr_x; ptr_x = &x; y = *ptr_x; x = ptr_x; *ptr_x = 30; Let’s see what happens in memory for each and every corresponding statement of the above snippet in Fig. 8.2. Assume for the sake of this discussion that variable x resides at memory location 1450, y at 1560 and ptr_x at 2581. (Note A pointer is a variable and thus its values need to be stored somewhere.) Program snippet Memory int x=50, y=45; Garbage value int *ptr_x; x 50 y 45 ptr_x 4789 ptr_x = &x; 1450 1560 ptr_x 2581 y = *ptr_x; ptr_x 1450 x = ptr_x x 50 y 45 ptr_x 2581 *ptr_x = 30 1450 1560 ptr_x 1450 2581 x 50 y 50 1450 1450 1560 2581 1450 x 1450 y 50 2581 1450 1560 x 30 y 50 1450 1560 Fig. 8.2: How Pointers Work at Machine Level (Memory) The program starts by declaring the integer variables x and y; it also initializes them with 50 and 45 respectively. It later defines a pointer variable prt_x that is assigned the address of x. so ptr_x gets loaded with the value 1450. Now y is assigned the contents of ptr_x. ptr_x currents CU IDOL SELF LEARNING MATERIAL (SLM)

196 Computer Programming points to memory location 1450, i.e., location of x. so y gets assigned to the value of x, i.e., 50. now xi assigned with ptr_x, that itself, holds the address of x. so x gets loaded with its own address, i.e., 1450. Finally, *ptr_x is assigned with 30. *ptr_x means value at the location pointed by ptr_x that is x itself. So x gets loaded with 30. 8.4 Referencing and Dereferencing Pointers are variables which points address of another variable used in C program, to access the memory and manipulate the address, address is to referred with & operator and * sign can be used as a notation to dereference the pointer. Address in C If you have a variable var in your program, &var will give you its address in the memory, where & is commonly called the reference operator. You must have seen this notation while using scanf() function. It was used in the function to store the user inputted value in the address of var. scanf(“%d”, &var); /* Example to demonstrate use of reference operator in C programming. */ #include <stdio.h> int main() { int var = 5; printf(“Value: %d\\n”, var); printf(“Address: %u”, &var); //Notice, the ampersand(&) before var. return 0; } Output: Value: 5 Address: 2686778 Note: You may obtain different value of address while using this program. CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 197 In above source code, value 5 is stored in the memory location 2686778. var is just the name given to that location. Reference Operator (&) and Dereference Operator (*) & is called reference operator. It gives you the address of a variable. Likewise, there is another operator that gets you the value from the address, it is called a dereference operator (*). Note: The * sign when declaring a pointer is not a dereference operator. It is just a similar notation that creates a pointer. Example: To Demonstrate Working of Pointers /* Source code to demonstrate, handling of pointers in C program */ #include <stdio.h> int main() { int* pc; int c; c=22; printf(“Address of c:%u\\n”,&c); printf(“Value of c:%d\\n\\n”,c); pc=&c; printf(“Address of pointer pc:%u\\n”,pc); printf(“Content of pointer pc:%d\\n\\n”,*pc); c=11; printf(“Address of pointer pc:%u\\n”,pc); printf(“Content of pointer pc:%d\\n\\n”,*pc); *pc=2; printf(“Address of c:%u\\n”,&c); printf(“Value of c:%d\\n\\n”,c); CU IDOL SELF LEARNING MATERIAL (SLM)

198 Computer Programming return 0; } Output: Address of c: 2686784 Value of c: 22 Address of pointer pc: 2686784 Content of pointer pc: 22 Address of pointer pc: 2686784 Content of pointer pc: 11 Address of c: 2686784 Value of c: 2 pc c pc c pc c pc c pc c 22 22 2 11 Line 4: int *pc, c; Line 5: c=22; Line 8: pc=&c; Line 11: c=11; Line 14: *p=2; Fig. 8.3: Diagrammatically Representation of Flow of Program 8.5 Pointer Arithmetic Pointer is a variable that holds the memory location, which is a number. This means that arithmetic operations can be performed on pointer. The arithmetic operations that can be performed on pointer is ++ (increment), – (decrement),+ (addition) and - (subtraction). Thus, an integer value can be added to or subtracted from a pointer variable, though the resulting expression must be interpreted very carefully. Suppose, for example, that ptr_x is a pointer variable that represents the address of some variable x. We can write expressions such as ++ptr_x, - - ptr_x, (ptr_x + 3 ) , (ptr_x + i),and (ptr_x - i),where i is an integer variable. Each expression will represent an address that is located some distance from the original address represented by ptr_x. CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 199 Increment/Decrement Consider an integer pointer variable ptr_x which points to the address 1450. Let’s increment the variable (integer data size is 16 bit i.e. 2 bytes). ptr_x++; Now the pointer variable ptr_x will point to the location 1452 because each time ptr_x will be incremented, it will point to the next integer location which is 2 bytes next to the current location. If ptr_x points to a character whose address is 1000, then the above operation will point to the location 1001 because the next character will be available at 1001. Example: void main() { int x = 45; intptr_x = &x; printf(“\\nOriginal values: x = %d ptr_x = %d”, x, ptr_x); ptr_x++; printf(“\\nValues after incrementing : x = %d ptr_x = %d”, x, ptr_x); } When the above code is compiled and executed, it produces the following result: Original values: x = 45 ptr_x = 8945 Values after incrementing : x = 45 ptr_x = 8947 Similarly for decrement, it decreases pointer variables value by the number of bytes of its data type. Example void main() { int x = 45; intptr_x = &x; printf(“\\nOriginal values: x = %d ptr_x = %d”, x, ptr_x); CU IDOL SELF LEARNING MATERIAL (SLM)

200 Computer Programming ptr_x—; printf(“\\nValues after decrementing : x = %d ptr_x = %d”, x, ptr_x); } When the above code is compiled and executed, it produces the following result Original values: x = 45 ptr_x = 8945 Values after incrementing : x = 45ptr_x = 8943 Addition/Subtraction Consider the following example to demonstrate the addition operation on pointer, which can be similarly considered for subtraction. void main( ) { int *ptr_i; /* pointer to an integer */ int i= 1; ptr_i = & i ; printf (“Value: i=%d \\n\\n”, i); printf (“Address: &i=%X \\n\\n”, &i) ; printf (“ Pointer value: ptr_i=%X ptr_i + l=%X ptr_i + 2=%X ptr_i + 3=%X” ptr_i, ptr_i + 1, ptr_i + 2, ptr_i + 3 ) ; } This program displays the value and address associated to i, an integer variable. The program also makes use of a pointer variable, ptr_i, which represents the address of i. The values of ptr_i, ptr_i + 1, ptr_i + 2 and ptr_i + 3 are also displayed, so that they may be compared with the addresses of the different variables. Execution of the program results in the following output: Value: i=1 Address: &i=7890 Pointer values: ptr_i=7890 ptr_i + 1=7892 ptr_i + 2=7894 ptr_i + 3=7896 CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 201 The first line simply displays the value of the variable, and the second line displays its addresses, as assigned by the compiler. Notice the number of bytes associated with data item. The integer value represented by i requires two bytes (specifically, addresses 7890 and 7891). Now consider the third line of output, it contains the addresses represented by the pointer expressions. Clearly, ptr_i represents the address of i (i.e., 7890). However, ptr_i + 1 moves over only two bytes, to 7892,and ptr_i + 2 moves over another two bytes, to 7894, and so on. The reason is pointer ptr_i points to an integer quantity that require 2bytes. Hence when integer constants are added to ptr_i, the constant is treated as two-byte multiple. If ptr_i is defined as a pointer to a different type of object (e.g., a character or a floating-point quantity), then any integer constant that is added to or subtracted from the pointer will be interpreted differently. For example, if ptr_i would be a floating point quantity then the integer constant would be treated as four-byte multiple. Pointer Comparison Pointer variables can be compared provided both variables are of the same data type. Such comparisons can be useful when both pointer variables point to elements of the same array. The comparisons can test for either equality or inequality. Moreover, a pointer variable can be compared with zero (i.e., NULL). Assume pt_x and pt_y are pointer variables that point to elements of the same array. Several logical expressions involving these two variables are shown below. All of the expressions are syntactically correct. (pt_x<pt_y) Indicates whether or not the element associated with pt_x is ranked ahead of (pt_x>= pt_y) the element associated with pt_y (pt_x == pt_y) (pt_x != pt_y) Indicates whether or not the element associated with pt_x is ranked after the (pt_x == NULL) element associated with pt_y Indicates whether or not the element associated with pt_x is equal to the element associated with pt_y Indicates whether or not the element associated with pt_x is not equal to the element associated with pt_y Indicates whether or not the element associated with pt_x is equal to NULL Fig. 8.4: Pointer Variable comparion with Comparison Operators CU IDOL SELF LEARNING MATERIAL (SLM)

202 Computer Programming 8.6 Using Pointers with Arrays Arrays and pointers are closely related in C Programming. An array name is really a pointer to the first element in the array. This means that if x is an one-dimensional array, then the address of first element of the array can be expressed as &x[0] or x. Even the address of second element of the array can be written as x + 1 and so on. So the address of the ith element can be expressed as x + i. Hence, the expression (x + i) is a symbolic representation for an address specification rather than an arithmetic expression. Since &x [i] and (x + i) both represent the address of the ith element of x, it would seem reasonable that x [ i]and * (x + i)both represent the contents of that address, i.e., the value of the ith element of x. This is indeed the case. The two terms are interchangeable. Hence, either term can be used in any particular application. The choice depends upon your individual preferences. Consider the following example: void main() { int x[5] = {51, 42, 83, 14, 65}; int i; //displaying array elements using x[i] and x + i approach for(i=0;i<5;i++) printf(“\\n\\n i = %d, x[%d] = %d and *(x + %d) = %d”, i, i, x[i], i, *(x+i)); } This program defines a one-dimensional, 5-element integer array x. The action portion of the program consists of a loop that displays the value. Note that the value of each array element is specified in two different ways, as x[i] and as *(x + i), in order to illustrate their equivalence. Therefore, the value and the address of each array element should appear twice. The above program would generate the following output: i = 0, x[0] = 51 and *(x + 0) = 51 i = 1, x[1] = 42 and *(x + 1) = 42 i = 2, x[2] = 83 and *(x + 2) = 83 CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 203 i = 3, x[3] = 14 and *(x + 3) = 14 i = 4, x[4] = 65 and *(x + 4) = 65 The above program can be written to display the address of each element. This is given as an exercise to students. Just change the expression of array elements with an expression for address of array of element as discussed above. To assign a value to an array element, use the expression x[i] or *(x + i) in the LHS of the assignment statement. On the other hand, it is sometimes necessary to assign an address to an identifier. In such situations, a pointer variable must appear on the left side of the assignment statement. It is not possible to assign an arbitrary address to an array name or to an array element. Thus, expressions such as x, (x + i) and &x [i] cannot appear on the left side of an assignment statement. Moreover, the address of an array cannot arbitrarily be altered, so expressions such as ++x are not permitted. Let’s consider the following example: void main() { floatvar[5] = { 5.5, 14.6, 5.8, 17.3, 8.9}; float *ptr_var; int i; ptr_var = var; //Displaying array using a pointer printf(“\\n Original array:”); for(i=0;i<5;i++) printf(“*(ptr_var + %d) : %f \\n”, i, *(ptr_var + %d)); } In the above example, ptr_var is a pointer to float, which means it can store the address of a variable of float type. Once the base address of the array is assigned into ptr_var, the array elements can be accessed using *ptr_var, *(ptr_var + 1), *(ptr_var + 2) and so on. When the above code is compiled and executed, it produces the following output: CU IDOL SELF LEARNING MATERIAL (SLM)

204 Computer Programming Original array: *(p + 0) : 5.5 *(p + 1) : 14.6 *(p + 2) : 5.8 *(p + 3) : 17.3 *(p + 4) : 8.9 However, the address of one array element cannot be assigned to some other array element. This means the following statements are illegal: &marks[13] = &marks[12]; But the value of one array element can be assigned to another through a pointer, if required pt = &marks[21]; or pt = marks + 21; marks[22] = *pt; *(marks + 22) = *pt If a numerical array is defined as a pointer variable, the array elements cannot be assigned initial values. Therefore, a conventional array definition is required if initial values will be assigned to the elements of a numerical array. However, a character-type pointer variable can be assigned an entire string as a part of the variable declaration. Thus, a string can conveniently be represented by either a one-dimensional character array or a character pointer. This is clearly discussed in the following example: char x[] = “First statement \\n “; void main() { static char y[] = “Second statement \\n “; printf(“%s %s”, x,y); } The first string is assigned to the external array x[ ]. The second string is assigned to the static array y[ ], which is defined within main. This second definition occurs within a function; therefore, y[ ] must be defined as a static array so that it can be initialized. The strings are now assigned to pointer variables rather than to one-dimensional arrays. Let’s see that example CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 205 char *x = “First statement \\n “; void main() { char *y = “Second statement \\n “; printf(“%s %s”, x,y); } The external pointer variable x points to the beginning of the first string, whereas the pointer variable y, declared within main, points to the beginning of the second string. Note that y can now be initialized without being declared static. Output of either of the program would be First statement Second statement 8.7 Using Pointers with Strings Pointer to Array of String: A pointer which pointing to an array which content is string, is known as pointer to array of strings. 178 arr[4] 189 C \\0 C + + \\0 J a v a \\0 V B A \\0 178 189 ptr (*ptr) [4] Fig. 8.5: Pointer Representation with Strings CU IDOL SELF LEARNING MATERIAL (SLM)

206 Computer Programming In this example 1. ptr : It is pointer to array of string of size 4. 2. array[4] : It is an array and its content are string. 1 : Printing Address of the Character Array #include<stdio.h> int main() { int i; char *arr[4] = {“C”,”C++”,”Java”,”VBA”}; char *(*ptr)[4] = &arr; for(i=0;i<4;i++) printf(“Address of String %d : %u\\n”,i+1,(*ptr)[i]); return 0; } Output: Address of String 1 = 178 Address of String 2 = 180 Address of String 3 = 184 Address of String 4 = 189 2. Printing Contents of Character Array #include<stdio.h> int main() { int i; char *arr[4] = {“Kiran”,”KS”,”SK”,”Shri”}; CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 207 char *(*ptr)[4] = &arr; for(i=0;i<4;i++) printf(“String %d : %s\\n”,i+1,(*ptr)[i]); return 0; } Output: String 1 = Kiran String 2 = KS String 3 = SK String 4 = Shri 3. Pointer to String and Pre-increment Operator #include<stdio.h> int main() { int i; char *arr[4] = {“C”,”C++”,”Java”,”VBA”}; char *(*ptr)[4] = &arr; printf(“%s”,++(*ptr)[2]); return 0; } Output: ava 8.8 Arrays of Pointers An array is a collection of variables belongings to the same data type. Similarly, an array can also be defined as a collection of pointer variables. Since a pointer variable contains an address, an CU IDOL SELF LEARNING MATERIAL (SLM)

208 Computer Programming array of pointers would be a collection of addresses. The address present in the array of pointers can be addresses of isolated variables or addresses of array elements or any other addresses. Consider the following example: void main() { int marks[] = {45, 55, 65, 35, 47}; int i, *pt[5]; // array of pointers for(i=0;i<5;i++) pt[i] = &marks[i]; // assigning the address of integers stored in integer array for(i=0;i<5;i++) printf(“Marks of student: \\n %d \\n”, *pt[i]); } For loop in the program picks up the addresses present in pt and prints the values present at these addresses. This is shown in Fig. 8.6. Array index marks[0] marks[1] marks[2] marks[3] marks[4] marks 45 55 65 35 47 Mem loc 4789 4791 4793 4795 4797 Array index marks[0] marks[1] marks[2] marks[3] marks[4] pt 4789 4791 4793 4795 4797 Mem loc 1254 1256 1258 1260 1262 Fig. 8.6: Arrangement of Array of Pointer in Memory As discussed above, the array of pointers can contain address of isolated variables. That exercise if left up to readers. 8.8.1 Multidimensional Arrays A multidimensional array can be expressed in terms of an array of pointers rather than a pointer to a group of contiguous arrays. In such situations, the newly defined array will have one less dimension than the original multidimensional array. Each pointer will indicate the beginning of a separate (n- 1)-dimensional array. CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 209 In general terms, a two-dimensional array can be defined as a one-dimensional array of pointers by writing data-type (*pt_array)[ expression2 ] ; instead of data-type array[ expression1 ] [ expression2 ]; Notice the parentheses that surround the array name and the preceding asterisk in the pointer version of each declaration. These parentheses must be present. Suppose arr is a two-dimensional array with 10 rows and 30 columns then it can be declared as follows int (*arr)[30] instead of intx[10][30] is defined to be a pointer to a group of contiguous, one-dimensional, 30-element integer arrays. arr points to the first 30 elements i.e. row 0. Similarly arr+1 point to the second 30 elements i.e. row 1 and so on. arr[10][30] and *arr[30] are both syntactically legal references to a single int. But arr is a true two-dimensional array: 300 int-sized locations have been set aside, and the conventional rectangular subscript calculation 30 * row + col is used to find the element a[row, col]. For *arr, however, the definition only allocates 10 pointers and does not initialize them; initialization must be done explicitly, either statically or with code. Assuming that each element of *arr does point to a thirty-element array, then there will be 300 ints set aside, plus ten cells for the pointers. The important advantage of the pointer array is that the rows of the array may be of different lengths. That is, each element of *arr need not point to a thirty -element vector; some may point to two elements, some to fifty, and some to none at all. Now consider a three-dimensional floating-point array t. This array can be defined as float (*t)[20][30] instead of float t[10][20][30] t is defined as a pointer to a group of contiguous two-dimensional, 20 x 30 floating-point arrays. CU IDOL SELF LEARNING MATERIAL (SLM)

210 Computer Programming 8.9 Pointers as Function Arguments Functions also take pointer as parameters. This allows the data items of the program inside the calling function to be accessed, altered and then returned to the calling function with the new changes reflected in the data item passed. This use of pointer is referred to as passing arguments by reference (address/location). [recall: passing arguments by value discussed in the earlier chapter on functions]. When an argument is passed by value, the data item is copied in function and any change done to it is not reflected in the calling function. However, when an argument is passed by reference, the address of the data item is passed into the function and any changes/alterations done will be reflected in both the function and the calling function. Thus, the use of a pointer as a function argument permits the corresponding data item to be altered globally from within the function. When pointers are used as arguments to a function, formal pointer arguments must each be preceded by an asterisk. Function prototypes are written in the same manner. In case the function declaration does not include variable names, the data type of each pointer argument must be followed by an asterisk. Example: void show_int(int x, int y);//function prototype void show_int1(int *pt_x, int *pt_y); void main() { int x = 56; int y = 75; printf(“\\n Original values: x=%d, y=%d”, x, y); show_int(x,y); printf(“\\n Values of x and y after calling show_int(): x=%d, y=%d”, x, y); show_int1(&u, &v); printf(“\\n Values of x and y after calling show_int1(): x=%d, y=%d”, x, y); } CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 211 void show_int(int x, int y) { x=y=1; printf(“\\n\\n Values of x and y inside show_int1(): x=%d, y=%d”, x, y); } show_int1(int *pt_x, int *pt_y) { *pt_x=*pt_y=1; printf(“\\n\\n Values of x and y inside show_int1(): *pt_x=%d, *pt_y=%d”, *pt_x, *pt_y); } As seen in the above program, there are two functions show_int() and show_int1() which accept two arguments. The first function show_int() accepts two integer arguments and modifies their values to 1. But these changes are not reflected in the main(); as these arguments are passed by value. The changes done to the arguments are local to the function in which the changes occur. The second function show_int1() accepts two pointer to integer variable as its arguments. The arguments are identified as pointers by the indirection operators (i.e., the asterisks) that appear in the argument declaration. Here the contents of the pointer addresses are reassigned the values to 1. Since the addresses are recognized in both show_int1() and main(), these changes are reflected in the main(). The output is generated as follows when the program executes. Original values: x=56, y=75 Values of x and y inside show_int1(): x=1, y=1 Values of x and y after calling show_int(): x=56, y=75 Values of x and y inside show_int1(): *pt_x=1, *pt_y=1 Values of x and y after calling show_int1(): x=1, y=1 Notice that the values of x and y are unchanged within main after the call to show_int(), though the values of these variables are changed within main after the call to show_int1(). Thus, CU IDOL SELF LEARNING MATERIAL (SLM)

212 Computer Programming the output illustrates the local nature of the alterations within show_int(), and the global nature of the alterations within show_int1(). 8.10 Functions Returning Pointers C also allows to return a pointer from a function. To do so, you would have to declare a function returning a pointer as in the following example “ int * myFunction() { . . } Second point to remember is that, it is not a good idea to return the address of a local variable outside the function, so you would have to define the local variable as static variable. Now, consider the following function which will generate 10 random numbers and return them using an array name which represents a pointer, i.e., address of first array element. A function can also return a pointer to the calling function. In this case you must be careful, because local variables of function doesn’t live outside the function, hence if you return a pointer connected to a local variable, that pointer be will pointing to nothing when function ends. #include <stdio.h> #include <conio.h> int* larger(int*, int*); void main() { int a=15; int b=92; int *p; p=larger(&a, &b); printf(“%d is larger”,*p); CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 213 } int* larger(int *x, int *y) { if(*x > *y) return x; else return y; } Safe Ways to Return a Valid Pointer 1. Either use argument with functions. Because argument passed to the functions are declared inside the calling function, hence, they will live outside the function called. 2. Or, use static local variables inside the function and return it. As static variables have a lifetime until main() exits, they will be available throughout the program. 8.11 Summary Pointers in C language is a variable that stores/points the address of another variable. A Pointer in C is used to allocate memory dynamically, i.e., at run time. The pointer variable might be belonging to any of the data type such as int, float, char, double, short etc. A pointer is a variable that represents the location (rather than the value) of a data item in memory, such as a variable or an array element. Pointer is a very useful tool of C programming as it can help improve the programs efficiency and allow the user to handle unlimited amount of data. Pointers are also closely associated with arrays, and therefore, provide an alternate way to access individual array elements. Pointer Variables contains the following points: 1. Defining and Declaration of a Pointer Variable 2. Pointer Initialization and Pointer Assignment 3. Null Pointer 4. What Happens at Memory Level CU IDOL SELF LEARNING MATERIAL (SLM)

214 Computer Programming & is called reference operator. It gives you the address of a variable. Likewise, there is another operator that gets you the value from the address, it is called a dereference operator (*). Pointer to Array of String: A pointer which pointing to an array which content is string, is known as pointer to array of strings. 8.12 Key Words/Abbreviations  Reference Operator: The reference  operator noted  by  ampersand  (\"&\"),  is  also  a unary operator  in  C languages  that  uses  for  assign  address  of  the  variables.  It  returns the pointer address of the variable. This is called \"referencing\" operater.  Dereference Operator: A dereference operator, also known as an indirection operator, operates on a pointer variable. It returns the location value, or l-value in memory pointed to by the variable's value. In the C programming language, the deference operator is denoted with an asterisk (*). 8.13 Learning Activity 1. Explain Pointer Arithmetic ....................................................................................................................................... ....................................................................................................................................... 2. Explain Arrays of Pointers ....................................................................................................................................... ....................................................................................................................................... 8.14 Unit End Questions (MCQ and Descriptive) A. Descriptive Type: Short Answer Type Questions 1. Explain how variables are represented in memory. How is the address of a variable determined? 2. What is a pointer? What kind of information is represented by a pointer variable? Explain with an example. CU IDOL SELF LEARNING MATERIAL (SLM)

Pointers 215 3. What is the relationship between the address of a variable and the corresponding pointer variable? Explain with the help of a diagram. 4. What is the relationship between the data item represented by a variable and the corresponding pointer variable? Explain with the help of a diagram. 5. How is a pointer variable declared? What is the purpose of the data type included in the declaration? 6. Explain the function prototype when it receives a pointer as an argument. Also explain how the pointer argument is declared within the function definition. 7. What is the relationship between an array name and a pointer? 8. How can a one-dimensional array of pointers be used to represent a collection of strings? Explain with an example. 9. Describe the two different ways to specify the address of an array element. 10. Describe the two different ways to access an array element. 11. Explain how functions returning pointer with suitable example. 12. Explain with suitable example how pointer variables can be passed as a function arguments. 13. Explain array of pointers in detail with example. B. Multiple Choice/Objective Type Questions 1. What is (void*)0? (a) Representation of NULL pointer (b) Representation of void pointer (c) Error (d) None of above 2. A pointer is (a) A variable that stores address of an instruction (b) A variable that stores address of other variable (c) A keyword used to create variables (d) None of these CU IDOL SELF LEARNING MATERIAL (SLM)

216 Computer Programming 3. The reason for using pointers in a Cprogram is (a) Pointers allow different functions to share and modify their local variables. (b) To pass large structures so that complete copy of the structure can be avoided. (c) Pointers enable complex “linked\" data structures like linked lists and binary trees. (d) All of the above 4. What do the following declaration signify? char **argv; (a) argv is a pointer to pointer. (b)  argv is a pointer to a char pointer. (c)  argv is a function pointer. (d)  argv is a member of function pointer. 5. What do the following declaration signify? char *arr[10]; (a) arr is a array of 10 character pointers. (b) arr is a array of function pointer. (c) arr is a array of characters. (d) arr is a pointer to array of characters Answers: 1. (a), 2. (b), 3. (d), 4. (b), 5. (a) 8.15 References 1. https://fresh2refresh.com/c-programming/c-pointer/ 2. https://www.studytonight.com/c/pointers-in-c.php 3. C: The complete reference by Herbert Schildt.  CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 217 UNIT 9 STRUCTURE Structure: 9.0 Learning Objectives 9.1 Introduction 9.2 Basics of Structure 9.3 Declaration of Structure 9.4 Reading and Assignment of Structure Variables 9.5 Array of Structures 9.6 Arrays within Structures 9.7 Nested Structure 9.8 Structures and Pointers 9.9 Summary 9.10 Key Words/Abbreviations 9.11 Learning Activity 9.12 Unit End Questions (MCQ and Descriptive) 9.13 References CU IDOL SELF LEARNING MATERIAL (SLM)

218 Computer Programming 9.0 Learning Objectives After studying this unit, you will be able to:  Describe the basics of structure  Explain accessing structure members  Elaborate structure with refence to array, function and pointer 9.1 Introduction Structure is a user-defined datatype in C language which allows us to combine data of different types together. Structure helps to construct a complex data type which is more meaningful. It is somewhat similar to an Array, but an array holds data of similar type only. But structure on the other hand, can store data of any type, which is practical more useful. 9.2 Basics of Structure C Structure is a collection of different data types which are grouped together and each element in a C structure is called member. In a real world scenario, data items under consideration are a collection of things. These collections of things can have its own attributes. A single structure might contain integer elements, floating-point elements and character elements. Consider a real world data “book”, which is a collection of things like title of book, author, publisher, no. of pages, etc., all these informations are dissimilar, i.e., author is a string whereas no. of pages is an integer. For dealing with such collections, C provides a data type called ‘structure’. A structure gathers together, different atoms of information that comprise a given entity. Uses of Structures in C 1. C Structures can be used to store huge data. Structures act as a database. 2. C Structures can be used to send data to the printer. 3. C Structures can interact with keyboard and mouse to store the data. 4. C Structures can be used in drawing and floppy formatting. 5. C Structures can be used to clear output screen contents. 6. C Structures can be used to check computer’s memory size, etc. CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 219 9.3 Declaration of Structure Declaration of structure starts with struct keyword followed by structure name with list of members enclosed in curly braces. A single structure might contain integer elements, floating-point elements and character elements or maybe combination of integer, float and character. Even, pointers, arrays and other structures can be included as elements within a structure. The individual structure elements are referred to as members. Structure declaration is different and more complicated than array declaration, as individual members also have to be defined. struct tag{ member 1; member 2; … member n; }; Here, struct is a keyword, tag is the name that identifies the structure of this type, and member 1, member 2, … member n are the individual member declaration. The member names within a particular structure must be distinct from one another, though a member name can be the same as the name of a variable that is defined outside of the structure. A storage class cannot be assigned to an individual member, and individual members cannot be initialized within a structure type declaration. Individual structure-type variables can be declared as follows: storage-class struct tag variable 1, variable 2, … variable n; where storage-class is an optional storage class specifier, struct and tag refer to the same as discussed above and variable1, variabel2, … variable n are the structure variables to type tag. The composition of structure is illustrated in the following diagram. CU IDOL SELF LEARNING MATERIAL (SLM)

220 Computer Programming struct struct name { type varname ; type varname ; type varname ; type varname ; }; Fig. 9.1: Composition of a Nested Structure Let’s take an example struct book { char title[20]; char author[40]; int no_of_pages; float cost; }; The above structure name is book. It contains four members: character array of 20 characters (title [20]), character array of 40 characters (author [40]), an integer quantity (no_of_pages) and a floating point quantity (cost). To define structure variable of type book as follows: struct book cprog, basicprog; here two variables of type book are defined whose composition is identified by the tag account. There is one more way in which the declaration of structure composition and structure variable can be combined. This is shown below: storage-class struct tag{ member 1; member 2; … member n; CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 221 } variable 1, variable 2, . . ., variable n; // tag is optional Let’s take an example struct book { char title[20]; char author[40]; int no_of_pages; float cost; } cprog, basicprog; Thus cprog and basicprog are structure variables of type book. Because the declaration of structure and structure variable is combined, tag can be eliminated. Note the following points while declaring a structure type:  The closing brace in the structure type declaration must be followed by a semicolon.  It is important to understand that a structure type declaration does not tell the compiler to reserve any space in memory. It only defines the ‘form’ of the structure.  Usually structure type declaration appears at the top of the source code file, before any variables or functions are defined. In very large programs they are usually put in a separate header file, and the file is included (using the preprocessor directive #include) in whichever program the structure type is required Structure Padding in C Many processors expect memory for variables to be aligned based on the size of the variable. A ‘char’ of 1 byte can be allocated anywhere in memory like 0x5000 or 0x5001. And an ‘int’ of 4 bytes, must start at a 4-byte boundary like 0x5004 or 0x5008. The structure padding is automatically done by the compiler to make sure all its members are byte aligned. The size of the below structure is 16 bytes due to structure padding: Struct dummy { Char ch; Int num; Double temp; CU IDOL SELF LEARNING MATERIAL (SLM)

222 Computer Programming } Here ‘char’ is only 1 byte but after 3 byte padding, the number starts at 4 byte boundary. For ‘int’ and ‘double’, it takes up 4 and 8 bytes respectively. The compiler used the 3 wasted bytes (marked in red) to pad the structure so that all the other members are byte aligned. Now, the size of the structure is 4 + 1 +3 = 8 bytes. The size of the entire structure is 8 bytes. On knowing the structured padding, it is easier to redesign or rewrite the structure. Let’s look at another example where the syntax is slightly different; CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 223 #include<stdio.h> Struct dummy { Int num; Double x; Float f; }; Struct dummy1 { Double x; Int num; Float f; }; Int main() { Printf(“size:%d %d ”, sizeof(struct dummy ), sizeof(struct dummy1)); System(“PAUSE”); Return 0; } The output will be as shown below; 9.4 Reading and Assignment of Structure Variables Individual members of a structure variable can be assigned initial values in the same way as the elements of an array. The initial values must appear in the order in which they will be assigned to their corresponding structure members, enclosed in braces and separated by commas. The general form is CU IDOL SELF LEARNING MATERIAL (SLM)

224 Computer Programming storage-class struct tag variable = {value 1, value 2, . . ., value tn); where value1 refer to the value of first member, value2 refer to the value of second member and so on. Taking an example for initializing the above defined structure book. struct book cprog = {“Introduction to C Programming”, “Kiran Gurbani”, 569, 499.55}; cprog is a structure instance variable of type book, whose members are assigned initial values. The first member (title) is assigned the string “Introduction to C Programming”, the second member (author) is assigned the string “Kiran Gurbani”, the third member (no_of_pages) is assigned the integer value 569 and the fourth member (cost) is assigned the floating-point value 499.55. The members of a structer can be accessed and processed separately. It can be accessed by writing the following statement: instance variable. member where instance variable refers to the structure type variable and member refers to the name of the member. Note that the period (.) that separates the variable name from the member name. Consider the following structure: struct book { char title[20]; char author[40]; int no_of_pages; float cost; } cprog; Here the structure instance variable is cprog and to access the cprog’s title and author name use the following code cprog.title cprog.author The period operator has the highest precedence. Hence the operator will take precedence over the unary operator as well as the other binary operators. Which means, the expression of the form CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 225 ++variable. member is equivalent to ++(variable. member); i.e., the ++ operator will apply to the structure member, not the entire structure variable. Similarly, the expression and instance variable.member is equivalent to & (variable. member); thus, the expression accesses the address of the structure member, not the starting address of the structure variable. Structure Assignment Normally, can structure variables be treated similar to any regular variables? Especially, when the value of one structure variable needs to be assigned to other. Well it is a complicated task. Let’s try to understand. Consider the following structure definition. struct car { char manufacturer[50]; char model[10]; int cost; }; If two variables c1and c2, structure variables of type car, are to be assigned to each other then there are three different ways in which it can be done (i) Assign the members one by one c1.manufacturer = c2.manufacturer c1.model = c2.model c1.cost = c2.cost (ii) Copy the whole memory contents of c2 to c1 memcpy(&c1,&c2,sizeof(c1)); (iii) Straight assignment using ‘=’ c1=c2; As shown above, it would be stupid programming if the programmer uses the first approach. So obviously they would prefer using the 2nd or the 3rd way of structure assignment. But what is the difference? Is there any drawback? CU IDOL SELF LEARNING MATERIAL (SLM)

226 Computer Programming Copying the structure variables using the straight assignment ‘=’ technique is probably the best as it’s shorter, easier to read and has higher level of abstraction. While the other technique is more compiler friendly, it just copies the memory of the size specified. This requires the reader to think about the size argument to copy. When doing a straight assignment, there is no hesitation about whether or not the size is correct. The dangerous part of structure assignment is when the structure element is a pointer. Copying structures that contain pointers can be a bit dangerous, since by doing so those pointers are aliased, typically making it ambiguous who owns the pointer after the copying operation. If the structure has char * pointing to a specific string, both structures will point to the same string. Changing the contents of one of those string fields will change the other as well. To overcome this, copy the entire contents of the structure and then deep copy the string by effectively giving a separate string to each structure. Thing to remember while using structure assignment  Recommend using straight assignment ‘=’ instead of memcpy.  If structure has pointer or array member, please consider the pointer alias problem, it will lead to dangling pointer once incorrect use. Better way is to implement structure assignment function in C 9.5 Array of Structures Structure is used to store the information of one particular object but if we need to store such 100 objects then Array of Structure is used. What is meant by array of structures? It is an array in which each element is a structure itself. Let’s understand thus using an example struct author { char first_name[15]; char last_name[15]; }; struct book CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 227 { char title[20]; struct author book_author; int no_of_pages; float cost; } books[50]; In this declaration books is a 50 elements array of structure. Each element of books is a separate structure to type book. Each structure of type book in turn includes an array (title) and another structure (author) as members. This shows how an array and a structure in embedded in another structure, which itself is an element of an array. An alternate way to define an array of structure book is shown below struct author { char first_name[15]; char last_name[15]; }; struct book { char title[20]; struct author book_author; int no_of_pages; float cost; }; struct book books[50]; an array of structure can be initialized just the way as any other array. Consider the following declarations CU IDOL SELF LEARNING MATERIAL (SLM)

228 Computer Programming struct author { char first_name[15]; char last_name[15]; }; struct author author_list[]={ “Kiran”, “Gurbani”} As seen in this example, the size of the array of structure is not specified. The initial values will define the size of the array and amount of memory required to store the array. The use of the period operator can be extended to arrays of structures, by writing array [expression] .member where array refers to the array name, and array [expression] is an individual array element (a structure variable). Therefore, array [expression], member will refer to a specific member within a particular structure. For the above example, author_list is an array of structures of type author. To access its second element use the expression author_list[1]. Let’s consider the following example: struct author { char first_name[15]; char last_name[15]; }; struct book { char title[20]; struct author book_author; int no_of_pages; float cost; }books[5]; CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 229 The following table gives expression showing how the various members and submembers of the structure variable can be accessed. Expression Explanation book[1].title &book[1].title Access the title member for the second book book[1].title[3] Access the address of title member within the second book structure book[1].book_author.first_name Access the 3rd character within book’s title Access the first_name member of structure of type author within ++book[1].no_of_pages the structure book Causes the value of no_of_pages to increment Fig. 9.2: Expressions of Structure The following program explains all the aspect of array of structures. struct student { int id; char name[30]; float percentage; }; void main() { int i; struct student data[2]; // 1st student’s data data [0].id=1; strcpy(data [0].name, “Prem”); data[0].percentage = 68.5; // 2nd student’s data data[1].id=2; strcpy(data[1].name, “Dheeraj”); CU IDOL SELF LEARNING MATERIAL (SLM)

230 Computer Programming data[1].percentage = 89.5; // 3rd student’s data data[2].id=3; strcpy(data[2].name, “Swapnil”); data[2].percentage = 77.5; for(i=0; i<3; i++) { printf(“ Records of STUDENT : %d \\n”, i+1); printf(“ Id is: %d \\n”, data[i].id); printf(“ Name is: %s \\n”, data[i].name); printf(“ Percentage is: %f\\n\\n”, data[i].percentage); } getch( ); } Output of the above program is Records of STUDENT : 1 Id is: 1 Name is: Prem Percentage is: 68.500000 Records of STUDENT : 2 Id is: 2 Name is: Dheeraj Percentage is: 89.500000 Records of STUDENT : 3 Id is: 3 Name is: Swapnil Percentage is: 77.500000 CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 231 9.6 Arrays within Structures Structure is a collection of different data types. As discussed earlier, Structures can contain an array as its member. Lets once again see the declaration of structure that contains an array within the structure struct tag{ data-type var1; data-type arr[size]; ... data-type varN; }; Here, struct is a keyword, tag is the name that identifies the structure of this type, and var1, arr[size], … varN are the individual member declaration. arr[size] is an array of element whose size is identified by size //structure variable declaration struct tag object; This would define a structure variable object of type tag. Example: //structure declaration struct month { int num_of_days; char name[4]; }; void main() { struct month this_month = { 31, “Jan” }; printf(“The month is %s\\n”, this_month.name ); CU IDOL SELF LEARNING MATERIAL (SLM)

232 Computer Programming } Alternate way to define the array is explained in the following array: //structure declaration struct month { int num_of_days; char name[4]; }; void main() { this_month.num_of_days = 31; strcpy( this_month.name, “Jan” ); printf(“The month is %s\\n”, this_month.name ); } Example of Structures Containing Arrays struct Student { int roll_No; char name[40]; int marks[5]; int total; float percentage; }; void main() { int i; CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 233 struct Student s; printf(“\\nEnter Student Roll No: “); scanf(“%d”, &s.roll_No); printf(“\\n Enter Student Name: “); scanf(“%s”, &s.name); s.total = 0; for(i=0; i<5; i++) { printf(“\\n Enter Marks %d:”, i+1); scanf(“%d”, &s.marks[i]); s.total = s.total + s.marks[i]; } s.percentage = (s.total/500)*100; printf(“\\n Roll No: %d”,s.roll_No); printf(“\\n Name: %d”,s.Name); printf(“\\n Marks in 5 subjects: %d %d %d %d %d”, s.marks[0], s.marks[1], s.marks[2], s.marks[3], s.marks[4]) printf(“\\n Total: %d”,s.total); printf(“\\n Percentage: %d”,s.percentage); } Output: Enter Student Roll No : 51 Enter Student Name : sravan Enter Marks 1: 55 Enter Marks 2: 56 Enter Marks 3: 74 CU IDOL SELF LEARNING MATERIAL (SLM)

234 Computer Programming Enter Marks 4: 81 Enter Marks 5: 45 Roll No: 51 Name: sravan Marks in 5 subjects: 55 56 74 81 45 Total: 311 Percentage: 62.20000 9.7 Nested Structure Nested structure in C is nothing but structure within structure. One structure can be declared inside other structure as we declare structure members inside a structure. As the complexity of real world data items increases, it may happen that a structure variable would be defined as a member of another structure. In such situations, the declaration of the embedded structure must appear before the declaration of the outer structure. This is also called nested structure. Let’s consider an example struct author{ char first_name[15]; char last_name[15]; }; struct book { char title[20]; struct author book_author; int no_of_pages; float cost; } cprog, basicprog; The second structure (book) now contains another structure (author) as one of its members. Note that the declaration of author precedes the declaration of book. The composition of nested structure can be illustrated in the following diagram: CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 235 struct struct name { struct struct name { type varname ; type varname ; }; type varname type varname }; } varname ; Fig. 9.3: Composition of Nested Structure Taking an example for initializing the above defined structure book. struct book cprog = {“Introduction to C Programming”, “Kiran”, “Gurbani”, 569, 499.55}; cprog is a structure variable of type book, whose members are assigned initial values. The first member (title) is assigned the string “C Programming”, the second member (author) is itself a structure that contain two string members (first_name and last_name). Therefore, it will be assigned the string “Kiran” and “Gurbani”. The third member (no_of_pages) is assigned the integer value 569 and the fourth member (cost) is assigned the floating-point value 499.55. It’s already seen how a structure member can be accessed using the (.) period operator. The repeated use of the period operator can also be used when a structure member itself is a structure shown below: variable.member.submember where member refers to the name of the member of the outer structure and submember refers to the name of the member of the nested structure (which will be shortly addressed). Similarly if the structure member is an array then it can be accessed as follows variable.member[expression] where expression indicates the non-negative value that identifies the array element. CU IDOL SELF LEARNING MATERIAL (SLM)

236 Computer Programming Let’s consider the same example struct author{ char first_name[15]; char last_name[15]; }; struct book { char title[20]; struct author book_author; int no_of_pages; float cost; } cprog,basicprog; book_author is the member of the structure, which in turn is a structure of type author. To access the first_name member of book_author use cprog.book_author.first_name Similarly, cprog.book_author.no_of_pages This value can be incremented by witing ++cprog.book_author.first_name The first member title is a character array. The fourth element of this array, can be access by using cprog.title[3] Structure members can be processed in the same manner as ordinary variables of the same data type. Single-valued structure members can appear in expressions, they can be passed to functions, and they can be returned from functions, as though they were ordinary single-valued variables. Complex structure members are processed in the same way as ordinary data items of that same type. CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 237 What does this imply? Structure members which are arrays can be processed in the same manner as an ordinary array. Structure member that is a structure can be processed on member at a time in the same manner as any other structure. These operations are shown below Consider the structure struct author{ char first_name[15]; char last_name[15]; }; struct book { char title[20]; struct author book_author; int no_of_pages; float cost; } cprog; Several operations to access structure members cprog.no_of_pages=455; This statement assigns the value of 455 to cprog.no_of_pages printf(“Book title is %s”, cprog.title); This statement passes the array cprog.title to the printf function, so that it could be printed on console. printf(“Author’s name %s %s”, cprog.book_author.first_name,Prog.book_author.first_name); This statement passes two arrays cprog.book_author.first_name and cprog.book_author last_name to the printf function, both of which are submembers of structure cprog, so that it could be printed on console. CU IDOL SELF LEARNING MATERIAL (SLM)

238 Computer Programming 9.8 Structures and Pointers This program explains how to use structure within structure in C using pointer variable. “student_college_detail’ structure is declared inside “student_detail” structure in this program. one normal structure variable and one pointer structure variable is used in this program. Note that combination of .(dot) and ->(arrow) operators are used to access the structure member which is declared inside the structure. #include <stdio.h> #include <string.h> struct student_college_detail { int college_id; char college_name[50]; }; struct student_detail { int id; char name[20]; float percentage; // structure within structure struct student_college_detail clg_data; } stu_data, *stu_data_ptr; void main() { struct student_detail stu_data = {1, “Raju”, 90.5, 71145, “Anna University”}; CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 239 stu_data_ptr = &stu_data; printf(“ Id is: %d \\n”, stu_data_ptr->id); printf(“ Name is: %s \\n”, stu_data_ptr->name); printf(“ Percentage is: %f \\n\\n”, stu_data_ptr->percentage); printf(“ College Id is: %d \\n”, stu_data_ptr->clg_data.college_id); printf(“ College Name is: %s \\n”, stu_data_ptr->clg_data.college_name); getch( ); } Output: Id is: 1 Name is: shruti Percentage is: 90.500000 College Id is: 71145 College Name is: Mumbai University 9.9 Summary When you design a program, it is important to choose an optimal way to represent the data that the program processes. In simple cases, scalar variables and arrays are sufficient. However, in practical programming context, you need a new form of variable that reflects the real world. For example, in your program, you may want to refer to an address that holds multiple fields including house number, street, zip code, state and country. C provides a special kind of variable called structure. C structure allows you to wrap related variables that has different data types into a single variable. A structure can contain any valid data types such as int,char,float,array,pointer or even other structures. Each variable in the structure is called structure member. CU IDOL SELF LEARNING MATERIAL (SLM)

240 Computer Programming 9.10 Key Words/Abbreviations Formatting: Prepare (a storage medium) to receive data. Structure: It is a user-defined data type of C language which allows us to combine data of different types together. 9.11 Learning Activity 1. What are the uses of structure? ....................................................................................................................................... ....................................................................................................................................... 2. Explain array of structure. ....................................................................................................................................... ....................................................................................................................................... 9.12 Unit End Questions (MCQ and Descriptive) A. Descriptive Type: Short Answer Type Questions 1. What is a structure? Give its definition and explain with an example. 2. Explain how structure can be initialized. 3. How is a structure member accessed? How can a structure member be processed? 4. What is a structure? Explain what can be a structure member and how can they be accessed. 5. Explain the (.) and (->) operators that can be applied onto a structure. 6. Can one structure be assigned to another? If yes, explain how it can be done. Also mention its advantage and disadvantage. 7. Write a note on nested structure. 8. What is main advantage of using nested structure? Give an example. 9. How is an array of structure initialized? CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 241 10. Can array be a member of structure? If yes explain. 11. How is an array of structures defined? Give its syntax and explain. B. Multiple Choice/Objective Type Questions 1. Which of the following operators can be applied on structure variables? (a) Equality comparison ( == ) (b) Assignment ( = ) (c) Both of the above (d) None of the above 2. Which of the following cannot be a structure member? (a) Another structure (b) Function (c) Array (d) None of the mentioned 3. What is the output of this C code? #include <stdio.h> struct student { int no; char name[20]; } void main() { struct student s; s.no = 8; printf(\"hello\"); } (a) Compile time error (b) Nothing (c) hello (d) Varies 4. What is the output of this C code? #include <stdio.h> void main() CU IDOL SELF LEARNING MATERIAL (SLM)

242 Computer Programming { struct student { int no; char name[20]; }; struct student s; s.no = 8; printf(\"%d\", s.no); } (a) Nothing (b) Compile time error (c) Junk (d) 8 5. #include<stdio.h> struct Point {    int x, y, z; }; int main() {    struct Point p1 = {.y = 0, .z = 1, .x = 2};    printf(\"%d %d %d\", p1.x, p1.y, p1.z);    return 0; } (a) Compiler Error (b) 2 0 1 (c) 0 1 2 (d) 2 1 0 Answers: 1. (b), 2. (b), 3. (a), 4. (d), 5. (b) CU IDOL SELF LEARNING MATERIAL (SLM)

Structure 243 9.13 References 1. https://www.studytonight.com/c/structures-in-c.php 2. https://www.geeksforgeeks.org/structures-c/ 3. https://www.zentut.com/c-tutorial/c-structure/ 4. https://www.tutorialspoint.com/cprogramming/pdf/c_structures.pdf  CU IDOL SELF LEARNING MATERIAL (SLM)