What are structures in C programming?

Structures in C programming are user-defined data types that allow the grouping of different data types under a single name. They are used to represent a record, such as a student or employee, with various attributes.

What is the syntax for declaring a structure variable in C?

The syntax for declaring a structure variable in C is: struct StructureName variableName;. For example: struct Student student1; declares a variable student1 of type struct Student.

How do you access structure members in C?

To access structure members in C, use the dot operator. For example, if student1 is a structure variable of type struct Student, then student1.id, student1.name, and student1.marks access the members of the structure.

Can structures in C contain arrays as members?

Yes, structures in C can contain arrays as members. For example: struct Student { int id; char name[50]; float marks[5]; }; includes an array marks to store marks of 5 subjects.

What are nested structures in C?

Nested structures in C are structures that contain other structures as members. This allows for more complex data representations. For example: struct Address { char city[50]; int zip; }; struct Student { int id; struct Address addr; };.

What is the use of typedef with structures in C?

The typedef keyword is used with structures in C to create an alias for the structure type. This simplifies the syntax for declaring structure variables. For example: typedef struct { int id; char name[50]; } Student; allows declaring Student student1; instead of struct Student student1;.

How do you use pointers with structures in C?

To use pointers with structures in C, declare a pointer to the structure type and use the arrow operator to access members. For example: struct Student *ptr = &student1; ptr->id = 1; accesses and modifies the id member.

Can you have an array of structures in C?

Yes, you can have an array of structures in C. For example: struct Student students[10]; declares an array of 10 Student structures, allowing you to store and manage multiple student records.

How do you copy structures in C?

You can copy structures in C by using the assignment operator. For example: struct Student student2 = student1; copies the contents of student1 into student2, including all member values.

What is the size of a structure in C?

The size of a structure in C is the sum of the sizes of its members, including any padding added by the compiler to align data. Use the sizeof operator to determine the size of a structure. For example: sizeof(struct Student) gives the size of the Student structure.

What is the purpose of the offsetof macro with structures in C?

The offsetof macro in C, defined in stddef.h, is used to determine the byte offset of a member within a structure. For example: offsetof(struct Student, name) gives the offset of the name member in the Student structure.

How do you define a structure with bit-fields in C?

To define a structure with bit-fields in C, use the colon syntax to specify the number of bits for each member. For example: struct Flags { unsigned int flag1: 1; unsigned int flag2: 1; }; defines a structure with two 1-bit fields.

Can you pass a structure to a function by reference in C?

Yes, you can pass a structure to a function by reference in C by passing a pointer to the structure. This is more efficient than passing by value, especially for large structures. For example: void display(struct Student *s) { printf("%d", s->id); }.

What are the advantages of using structures in C?

Structures in C provide a way to group related data of different types, making it easier to manage and manipulate complex data sets. They enhance code readability and maintainability by organizing data logically.

How do you use structures in linked lists in C?

To use structures in linked lists in C, define a structure with a pointer to the same structure type for linking nodes. For example: struct Node { int data; struct Node *next; }; defines a node structure for a linked list.

Can structures in C have function pointers as members?

Yes, structures in C can have function pointers as members. This allows for more flexible and modular code. For example: struct Operation { int (*func)(int, int); }; defines a structure with a function pointer member.

Structures MCQs - Part 1 » 💡 Brilliant Mind

Q: How do you define a structure in C?

To define a structure in C, use the struct keyword followed by the structure name and a block containing the members. For example: struct Student { int id; char name[50]; float marks; };.

Q: How do you initialize a structure in C?

You can initialize a structure in C by specifying the values in braces, in the order of the structure's members. For example: struct Student student1 = {1, "John", {85.0, 90.0, 88.0, 92.0, 80.0}};.

Q: How do you pass a structure to a function in C?

You can pass a structure to a function in C either by value or by reference. Passing by value involves copying the entire structure, while passing by reference involves passing a pointer to the structure.

Home » Programming Languages » C Programming » Structures MCQs » Part 1 » 100 Questions

Timer: Off

Random: Off

1. What is a structure in C programming?

ⓐ. A type of array

ⓑ. A collection of variables of different types

ⓒ. A function

ⓓ. A pointer

Correct Answer: A collection of variables of different types

Explanation: A structure in C is a user-defined data type that allows the grouping of variables of different types under a single name for easier handling.

2. How do you define a structure in C?

ⓐ. struct structure_name { … };

ⓑ. struct { … };

ⓒ. typedef structure_name { … };

ⓓ. define structure { … };

Correct Answer: struct structure_name { … };

Explanation: In C, a structure is defined using the `struct` keyword followed by the structure name and the definition of its members within curly braces.

3. Which of the following is the correct way to declare a structure variable?

ⓐ. structure_name var_name;

ⓑ. struct structure_name var_name;

ⓒ. typedef structure_name var_name;

ⓓ. define structure_name var_name;

Correct Answer: struct structure_name var_name;

Explanation: To declare a structure variable, you must use the `struct` keyword followed by the structure name and the variable name.

4. How can you access the members of a structure in C?

ⓐ. Using the -> operator

ⓑ. Using the . operator

ⓒ. Using the [] operator

ⓓ. Using the & operator

Correct Answer: Using the . operator

Explanation: The members of a structure in C are accessed using the dot (.) operator, where the variable name is followed by the dot and the member name.

5. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point p = {10, 20};
printf("%d, %d", p.x, p.y);

ⓐ. 0, 0

ⓑ. 10, 20

ⓒ. x, y

ⓓ. Compiler error

Correct Answer: 10, 20

Explanation: The structure `Point` is initialized with values 10 and 20, and the `printf` function outputs these values correctly using the dot operator to access the structure members.

6. How do you initialize a structure in C?

ⓐ. struct structure_name var_name = {value1, value2, …};

ⓑ. struct structure_name = {value1, value2, …};

ⓒ. structure_name var_name = {value1, value2, …};

ⓓ. typedef structure_name var_name = {value1, value2, …};

Correct Answer: struct structure_name var_name = {value1, value2, …};

Explanation: A structure can be initialized by specifying its values in braces at the time of declaration, with the `struct` keyword and structure name.

7. Can a structure contain a pointer to itself in C?

ⓐ. Yes

ⓑ. No

ⓒ. Only if it is typedef

ⓓ. Only in C++

Correct Answer: Yes

Explanation: A structure in C can contain a pointer to itself, which is useful for creating linked lists and other dynamic data structures.

8. Which of the following is true about structure padding?

ⓐ. It is used to reduce the size of the structure.

ⓑ. It is used to increase the size of the structure.

ⓒ. It aligns structure members for efficient memory access.

ⓓ. It removes unused members from the structure.

Correct Answer: It aligns structure members for efficient memory access.

Explanation: Structure padding is used to align the members of a structure in memory, ensuring that each member is aligned according to its data type requirements for efficient access.

9. How can you pass a structure to a function in C?

ⓐ. By value

ⓑ. By reference

ⓒ. Both by value and by reference

ⓓ. Structures cannot be passed to functions

Correct Answer: Both by value and by reference

Explanation: In C, structures can be passed to functions either by value (copying the structure) or by reference (passing a pointer to the structure).

10. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point p1 = {10, 20};
struct Point p2 = p1;
p2.x = 30;
printf("%d, %d", p1.x, p2.x);

ⓐ. 10, 30

ⓑ. 30, 30

ⓒ. 10, 10

ⓓ. Compiler error

Correct Answer: 10, 30

Explanation: The structure `p2` is a copy of `p1`, and modifying `p2.x` does not affect `p1.x`. Therefore, `p1.x` remains 10, and `p2.x` is 30.

11. How can you define a structure with a member that is an array in C?

ⓐ. struct structure_name { int member[]; };

ⓑ. struct structure_name { int member[10]; };

ⓒ. struct structure_name { array member[10]; };

ⓓ. struct structure_name { int[] member; };

Correct Answer: struct structure_name { int member[10]; };

Explanation: To define a structure with an array member, you specify the type and size of the array within the structure definition.

12. Which of the following is a correct way to define a structure with nested structures in C?

ⓐ. struct structure_name { struct nested_structure nested_member; };

ⓑ. struct structure_name { nested_structure nested_member; };

ⓒ. struct structure_name { structure nested_member; };

ⓓ. struct structure_name { struct nested_structure *nested_member; };

Correct Answer: struct structure_name { struct nested_structure nested_member; };

Explanation: To define a structure with a nested structure, you must use the `struct` keyword followed by the nested structure name and member name.

13. What keyword is used to rename a structure in C?

ⓐ. struct

ⓑ. typedef

ⓒ. define

ⓓ. alias

Correct Answer: typedef

Explanation: The `typedef` keyword is used to create an alias for a structure, making it easier to declare variables of that structure type.

14. Which of the following is an example of using typedef with a structure in C?

ⓐ. typedef struct { int x; int y; } Point;

ⓑ. define struct { int x; int y; } Point;

ⓒ. struct { int x; int y; } typedef Point;

ⓓ. struct Point { int x; int y; };

Correct Answer: typedef struct { int x; int y; } Point;

Explanation: The correct syntax for using `typedef` with a structure is to place the `typedef` keyword before the structure definition and specify the new name after the closing brace.

15. How can you define an anonymous structure in C?

ⓐ. struct { int x; int y; } var_name;

ⓑ. anonymous struct { int x; int y; };

ⓒ. struct anonymous { int x; int y; };

ⓓ. define struct { int x; int y; } var_name;

Correct Answer: struct { int x; int y; } var_name;

Explanation: An anonymous structure is defined without a name and can be directly associated with a variable at the time of declaration.

16. What is the size of the following structure in C?


struct Example {
    char a;
    int b;
    char c;
};

Assuming no padding, what would be the size of this structure?

ⓐ. 6 bytes

ⓑ. 8 bytes

ⓒ. 10 bytes

ⓓ. 12 bytes

Correct Answer: 6 bytes

Explanation: Without padding, the size would be the sum of the sizes of the individual members. `char` is 1 byte, `int` is 4 bytes, and another `char` is 1 byte, totaling 6 bytes.

17. How do you define a pointer to a structure in C?

ⓐ. struct structure_name *pointer_name;

ⓑ. pointer struct structure_name pointer_name;

ⓒ. struct pointer_name *structure_name;

ⓓ. struct *structure_name pointer_name;

Correct Answer: struct structure_name *pointer_name;

Explanation: To define a pointer to a structure, use the `struct` keyword followed by the structure name and an asterisk before the pointer name.

18. What is the correct way to access a member of a structure through a pointer in C?

ⓐ. pointer_name.member

ⓑ. *pointer_name.member

ⓒ. pointer_name->member

ⓓ. *pointer_name->member

Correct Answer: pointer_name->member

Explanation: To access a member of a structure through a pointer, use the arrow (->) operator.

19. How do you assign values to the members of a structure using a pointer in C?

ⓐ. pointer_name->member = value;

ⓑ. *pointer_name.member = value;

ⓒ. pointer_name.member = value;

ⓓ. pointer_name.member->value;

Correct Answer: pointer_name->member = value;

Explanation: To assign values to the members of a structure using a pointer, use the arrow (->) operator followed by the member name and assignment.

20. Which of the following is true about typedef and structures in C?

ⓐ. Typedef can only be used with structures.

ⓑ. Typedef cannot be used with structures.

ⓒ. Typedef can create an alias for structures to simplify code.

ⓓ. Typedef is not used in modern C programming.

Correct Answer: Typedef can create an alias for structures to simplify code.

Explanation: The `typedef` keyword is used to create an alias for structures, making the code easier to read and write by allowing the use of a simpler name for the structure type.

21. Which operator is used to access members of a structure directly?

ⓐ. ->

ⓑ. .

ⓒ. ::

ⓓ.

Correct Answer: .

Explanation: The dot (.) operator is used to access members of a structure directly.

22. Which operator is used to access members of a structure through a pointer?

ⓐ. .

ⓑ.

ⓒ. &->

ⓓ. ::

Correct Answer: ->

Explanation: The arrow (->) operator is used to access members of a structure through a pointer.

23. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point p = {5, 10};
printf("%d", p.y);

ⓐ. 5

ⓑ. 10

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: 10

Explanation: The member `y` of the structure `Point` is accessed using the dot operator, and its value (10) is printed.

24. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point p = {5, 10};
struct Point *ptr = &p;
printf("%d", ptr->x);

ⓐ. 5

ⓑ. 10

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: 5

Explanation: The member `x` of the structure `Point` is accessed through the pointer `ptr` using the arrow operator, and its value (5) is printed.

25. Which of the following is the correct way to modify the member of a structure through a pointer?

ⓐ. ptr.member = value;

ⓑ. ptr->member = value;

ⓒ. *ptr.member = value;

ⓓ. ptr->*member = value;

Correct Answer: ptr->member = value;

Explanation: To modify the member of a structure through a pointer, use the arrow (->) operator followed by the member name and the new value.

26. What is the output of the following code?


struct Rectangle {
    int length;
    int width;
};
struct Rectangle rect = {10, 5};
struct Rectangle *rptr = ▭
rptr->width = 15;
printf("%d", rect.width);

ⓐ. 5

ⓑ. 10

ⓒ. 15

ⓓ. Compiler error

Correct Answer: 15

Explanation: The member `width` of the structure `Rectangle` is modified through the pointer `rptr` using the arrow operator, and its new value (15) is printed.

27. Which of the following is a valid way to initialize a structure and access its members?

ⓐ. struct Point { int x; int y; } p = {3, 4}; printf(“%d”, p.x);

ⓑ. struct Point { int x; int y; } p; p = {3, 4}; printf(“%d”, p.x);

ⓒ. struct Point { int x; int y; } p; p->x = 3; p->y = 4; printf(“%d”, p.x);

ⓓ. struct Point { int x; int y; } p; p = {3, 4}; printf(“%d”, p->x);

Correct Answer: struct Point { int x; int y; } p = {3, 4}; printf(“%d”, p.x);

Explanation: This code correctly initializes a structure `Point` and accesses its member `x` using the dot operator.

28. Which of the following statements is true about accessing members of a structure in C?

ⓐ. Members of a structure can only be accessed using the dot operator.

ⓑ. Members of a structure can only be accessed using the arrow operator.

ⓒ. Members of a structure can be accessed using either the dot or arrow operator, depending on whether a pointer is used.

ⓓ. Members of a structure cannot be accessed directly.

Correct Answer: Members of a structure can be accessed using either the dot or arrow operator, depending on whether a pointer is used.

Explanation: The dot operator is used for direct access, while the arrow operator is used when accessing members through a pointer.

29. What is the output of the following code?


struct Book {
    char title[50];
    int pages;
};
struct Book b = {"C Programming", 300};
printf("%s", b.title);

ⓐ. C Programming

ⓑ. 300

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: C Programming

Explanation: The member `title` of the structure `Book` is accessed using the dot operator, and its value (“C Programming”) is printed.

30. What is the output of the following code?


struct Employee {
    char name[20];
    int id;
};
struct Employee e;
strcpy(e.name, "Alice");
e.id = 1001;
struct Employee *eptr = &e;
printf("%s %d", eptr->name, eptr->id);

ⓐ. Alice 1001

ⓑ. Alice

ⓒ. 1001

ⓓ. Compiler error

Correct Answer: Alice 1001

Explanation: The member `name` and `id` of the structure `Employee` are accessed through the pointer `eptr` using the arrow operator, and their values (“Alice” and 1001) are printed.

31. How do you declare an array of structures in C?

ⓐ. struct structure_name array_name[];

ⓑ. struct structure_name array_name[10];

ⓒ. structure_name array_name[10];

ⓓ. array structure_name array_name[10];

Correct Answer: struct structure_name array_name[10];

Explanation: To declare an array of structures in C, you use the `struct` keyword followed by the structure name and then specify the array name with the desired size in square brackets. This creates an array where each element is a structure of the specified type.

32. Which of the following is the correct way to initialize an array of structures in C?

ⓐ. struct structure_name array_name = { {value1, value2}, {value3, value4} };

ⓑ. struct structure_name array_name[2] = { {value1, value2}, {value3, value4} };

ⓒ. structure_name array_name[2] = { {value1, value2}, {value3, value4} };

ⓓ. struct structure_name array_name[2] = { value1, value2, value3, value4 };

Correct Answer: struct structure_name array_name[2] = { {value1, value2}, {value3, value4} };

Explanation: The correct way to initialize an array of structures is by specifying the array size and providing initialization values for each element of the array. Each element is initialized with a set of values corresponding to the structure members.

33. How do you access a member of a structure in an array of structures?

ⓐ. array_name.member

ⓑ. array_name->member

ⓒ. array_name[index].member

ⓓ. array_name[index]->member

Correct Answer: array_name[index].member

Explanation: To access a member of a structure within an array of structures, you use the array name followed by the index of the desired element in square brackets and the dot operator to access the member. This allows you to reference and manipulate the specific member of the structure at the given index.

34. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point points[2] = { {1, 2}, {3, 4} };
printf("%d, %d", points[1].x, points[1].y);

ⓐ. 1, 2

ⓑ. 3, 4

ⓒ. 1, 4

ⓓ. Compiler error

Correct Answer: 3, 4

Explanation: The array `points` is initialized with two elements. The code accesses the second element (index 1) of the array and prints its members `x` and `y`. The values of these members are 3 and 4, respectively.

35. How can you modify a member of a structure in an array of structures?

ⓐ. array_name[index].member = new_value;

ⓑ. array_name.member = new_value;

ⓒ. array_name[index]->member = new_value;

ⓓ. array_name->member = new_value;

Correct Answer: array_name[index].member = new_value;

Explanation: To modify a member of a structure in an array of structures, you specify the array name followed by the index of the desired element in square brackets and use the dot operator to access the member. You can then assign a new value to this member.

36. What is the output of the following code?


struct Student {
    char name[20];
    int grade;
};
struct Student students[2] = { {"John", 85}, {"Jane", 90} };
students[0].grade = 95;
printf("%d", students[0].grade);

ⓐ. 85

ⓑ. 90

ⓒ. 95

ⓓ. Compiler error

Correct Answer: 95

Explanation: The array `students` is initialized with two elements. The code modifies the `grade` member of the first element (index 0) and assigns it a new value of 95. The `printf` function then prints this updated value, which is 95.

37. How do you declare a pointer to an array of structures?

ⓐ. struct structure_name *array_name[];

ⓑ. struct structure_name (*array_name)[size];

ⓒ. struct structure_name *array_name[size];

ⓓ. struct structure_name *array_name;

Correct Answer: struct structure_name (*array_name)[size];

Explanation: To declare a pointer to an array of structures, you use parentheses to indicate that the pointer is to an array of the specified size. This allows you to work with the entire array of structures through the pointer.

38. What is the output of the following code?


struct Book {
    char title[50];
    int pages;
};
struct Book library[2] = { {"C Programming", 300}, {"Data Structures", 450} };
struct Book (*ptr)[2] = &library;
printf("%s", (*ptr)[1].title);

ⓐ. C Programming

ⓑ. Data Structures

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: Data Structures

Explanation: The pointer `ptr` is declared to point to an array of two `Book` structures. The code dereferences the pointer and accesses the second element (index 1) of the array, printing the `title` member, which is “Data Structures”.

39. How can you iterate over an array of structures using a pointer in C?

ⓐ. for (int i = 0; i < size; i++) { ptr[i].member = ...; }

ⓑ. for (int i = 0; i < size; i++) { ptr->member = …; ptr++; }

ⓒ. for (int i = 0; i < size; i++) { (*ptr)[i].member = ...; }

ⓓ. for (int i = 0; i < size; i++) { (*ptr)++.member = ...; }

Correct Answer: for (int i = 0; i < size; i++) { (*ptr)[i].member = ...; }

Explanation: To iterate over an array of structures using a pointer, you dereference the pointer and access the array elements by index. The loop iterates over each element, allowing you to access and modify the members as needed.

40. What is the output of the following code?


struct Employee {
    char name[20];
    int id;
};
struct Employee employees[2] = { {"Alice", 1001}, {"Bob", 1002} };
struct Employee *eptr = employees;
printf("%s %d", (eptr + 1)->name, (eptr + 1)->id);

ⓐ. Alice 1001

ⓑ. Bob 1002

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: Bob 1002

Explanation: The pointer `eptr` points to the first element of the `employees` array. By adding 1 to `eptr`, the pointer is incremented to point to the second element. The arrow operator is then used to access and print the `name` and `id` members of this element, resulting in “Bob 1002”.

41. How do you copy one array of structures to another in C?

ⓐ. Use the `memcpy` function

ⓑ. Use the `strcpy` function

ⓒ. Direct assignment

ⓓ. Use a loop to copy each element

Correct Answer: Use a loop to copy each element

Explanation: In C, you cannot directly assign one array of structures to another. Instead, you must use a loop to copy each element of the source array to the corresponding element of the destination array.

42. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point points1[2] = { {1, 2}, {3, 4} };
struct Point points2[2];
for (int i = 0; i < 2; i++) {
    points2[i] = points1[i];
}
printf("%d, %d", points2[0].x, points2[0].y);

ⓐ. 0, 0

ⓑ. 1, 2

ⓒ. 3, 4

ⓓ. Compiler error

Correct Answer: 1, 2

Explanation: The loop copies each element of `points1` to `points2`. The code then prints the members `x` and `y` of the first element of `points2`, which are 1 and 2, respectively.

43. What is the correct way to pass an array of structures to a function in C?

ⓐ. struct structure_name array_name[size];

ⓑ. struct structure_name *array_name;

ⓒ. struct structure_name (*array_name)[size];

ⓓ. struct structure_name array_name[];

Correct Answer: struct structure_name (*array_name)[size];

Explanation: To pass an array of structures to a function, you use a pointer to the array. This allows the function to access and manipulate the array elements. The size of the array can also be passed as an additional parameter to the function.

44. What is the output of the following code?


struct Student {
    char name[20];
    int grade;
};void printStudent(struct Student *s) {
    printf("%s %d\n", s->name, s->grade);
}
struct Student students[2] = { {"John", 85}, {"Jane", 90} };
for (int i = 0; i < 2; i++) {
    printStudent(&students[i]);
}

ⓐ. John 85

ⓑ. Jane 90

ⓒ. John 85 Jane 90

ⓓ. Compiler error

Correct Answer: John 85 Jane 90

Explanation: The `printStudent` function takes a pointer to a `Student` structure and prints its `name` and `grade` members. The loop iterates over the `students` array and passes the address of each element to the `printStudent` function, resulting in the output "John 85 Jane 90".

45. How can you dynamically allocate an array of structures in C?

ⓐ. Use the `malloc` function

ⓑ. Use the `calloc` function

ⓒ. Use the `realloc` function

ⓓ. All of the above

Correct Answer: All of the above

Explanation: You can use the `malloc`, `calloc`, or `realloc` functions to dynamically allocate an array of structures in C. `malloc` allocates memory without initializing it, `calloc` allocates and initializes memory to zero, and `realloc` adjusts the size of an already allocated memory block.

46. What is the output of the following code?


struct Employee {
    char name[20];
    int id;
};
struct Employee *employees = (struct Employee *)malloc(2 * sizeof(struct Employee));
strcpy(employees[0].name, "Alice");
employees[0].id = 1001;
strcpy(employees[1].name, "Bob");
employees[1].id = 1002;
printf("%s %d", employees[1].name, employees[1].id);
free(employees);

ⓐ. Alice 1001

ⓑ. Bob 1002

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: Bob 1002

Explanation: The `malloc` function dynamically allocates memory for an array of two `Employee` structures. The names and IDs of the employees are assigned, and the code prints the `name` and `id` of the second employee, which are "Bob" and 1002, respectively. Finally, the allocated memory is freed using the `free` function.

47. What is the purpose of using `calloc` instead of `malloc` when allocating an array of structures?

ⓐ. To allocate more memory

ⓑ. To allocate and initialize the memory to zero

ⓒ. To allocate less memory

ⓓ. To avoid memory allocation

Correct Answer: To allocate and initialize the memory to zero

Explanation: The `calloc` function not only allocates memory but also initializes all bytes in the allocated memory block to zero. This can be useful when you want to ensure that all members of the structures are initialized to zero or NULL.

48. How do you deallocate an array of structures that was dynamically allocated?

ⓐ. Use the `delete` function

ⓑ. Use the `remove` function

ⓒ. Use the `free` function

ⓓ. Use the `clear` function

Correct Answer: Use the `free` function

Explanation: The `free` function is used to deallocate memory that was previously allocated using `malloc`, `calloc`, or `realloc`. This is necessary to avoid memory leaks by releasing the allocated memory back to the system.

49. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point *points = (struct Point *)calloc(2, sizeof(struct Point));
points[0].x = 1;
points[0].y = 2;
points[1].x = 3;
points[1].y = 4;
printf("%d, %d", points[1].x, points[1].y);
free(points);

ⓐ. 1, 2

ⓑ. 3, 4

ⓒ. 0, 0

ⓓ. Compiler error

Correct Answer: 3, 4

Explanation: The `calloc` function allocates memory for an array of two `Point` structures and initializes all bytes to zero. The members `x` and `y` of the second element are then assigned values 3 and 4, respectively. The `printf` function prints these values, and the allocated memory is freed using the `free` function.

50. What happens if you try to access an element outside the bounds of an array of structures?

ⓐ. The program will always crash

ⓑ. The program will behave unpredictably

ⓒ. The program will output zero

ⓓ. The compiler will catch the error

Correct Answer: The program will behave unpredictably

Explanation: Accessing an element outside the bounds of an array of structures results in undefined behavior. The program may crash, produce incorrect results, or behave unpredictably, as the memory accessed may be invalid or contain unexpected data. This is a common source of bugs and security vulnerabilities.

51. How do you declare a pointer to a structure in C?

ⓐ. struct structure_name *pointer_name;

ⓑ. structure_name *pointer_name;

ⓒ. struct *structure_name pointer_name;

ⓓ. struct structure_name pointer_name;

Correct Answer: struct structure_name *pointer_name;

Explanation: To declare a pointer to a structure in C, you use the `struct` keyword followed by the structure name, an asterisk (*), and the pointer name. This creates a pointer that can hold the address of a structure of the specified type.

52. How do you access the members of a structure through a pointer?

ⓐ. Using the dot operator (.)

ⓑ. Using the arrow operator (->)

ⓒ. Using the double colon operator (::)

ⓓ. Using the address operator (&)

Correct Answer: Using the arrow operator (->)

Explanation: To access the members of a structure through a pointer, you use the arrow operator (->). This operator combines the dereferencing of the pointer and accessing the member in one step.

53. What is the output of the following code?


struct Person {
    char name[20];
    int age;
};
struct Person p = {"Alice", 30};
struct Person *ptr = &p;
printf("%s is %d years old.", ptr->name, ptr->age);

ⓐ. Alice is 30 years old.

ⓑ. Alice is 0 years old.

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: Alice is 30 years old.

Explanation: The pointer `ptr` is assigned the address of the structure `p`. The arrow operator (->) is used to access the `name` and `age` members of the structure through the pointer, printing "Alice is 30 years old."

54. How can you assign the address of a dynamically allocated structure to a pointer?

ⓐ. ptr = malloc(sizeof(struct structure_name));

ⓑ. ptr = &malloc(sizeof(struct structure_name));

ⓒ. ptr = (struct structure_name)malloc(sizeof(struct structure_name));

ⓓ. ptr = (struct structure_name *)malloc(sizeof(struct structure_name));

Correct Answer: ptr = (struct structure_name *)malloc(sizeof(struct structure_name));

Explanation: To dynamically allocate memory for a structure and assign its address to a pointer, you use the `malloc` function and cast the returned pointer to the appropriate type. This allocates memory of the size of the structure and assigns the address to the pointer.

55. What is the output of the following code?


struct Car {
    char model[20];
    int year;
};
struct Car *c = (struct Car *)malloc(sizeof(struct Car));
strcpy(c->model, "Tesla Model S");
c->year = 2022;
printf("%s %d", c->model, c->year);
free(c);

ⓐ. Tesla Model S 2022

ⓑ. Tesla Model S 0

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: Tesla Model S 2022

Explanation: The code dynamically allocates memory for a `Car` structure, assigns values to the `model` and `year` members through the pointer `c` using the arrow operator (->), and prints these values. The memory is then freed using the `free` function.

56. Which of the following is a valid way to check if memory allocation for a structure was successful?

ⓐ. if (ptr)

ⓑ. if (ptr != NULL)

ⓒ. if (ptr == NULL)

ⓓ. Both A and B

Correct Answer: Both A and B

Explanation: To check if memory allocation for a structure was successful, you can use either `if (ptr)` or `if (ptr != NULL)`. Both checks will confirm that the pointer is not NULL, indicating that the allocation was successful. If the pointer is NULL, it means the allocation failed.

57. What is the output of the following code?


struct Node {
    int data;
    struct Node *next;
};
struct Node *head = (struct Node *)malloc(sizeof(struct Node));
head->data = 10;
head->next = (struct Node *)malloc(sizeof(struct Node));
head->next->data = 20;
printf("%d %d", head->data, head->next->data);

ⓐ. 10 20

ⓑ. 10 0

ⓒ. 0 20

ⓓ. Compiler error

Correct Answer: 10 20

Explanation: The code creates a linked list with two nodes. The `head` pointer points to the first node, which contains the value 10. The `next` pointer of the first node points to the second node, which contains the value 20. The `printf` function prints the `data` members of both nodes, resulting in "10 20".

58. How do you pass a pointer to a structure to a function in C?

ⓐ. struct structure_name function_name(*ptr);

ⓑ. void function_name(struct structure_name *ptr);

ⓒ. void function_name(struct structure_name ptr);

ⓓ. struct structure_name function_name(ptr);

Correct Answer: void function_name(struct structure_name *ptr);

Explanation: To pass a pointer to a structure to a function, you define the function with a parameter of type `struct structure_name *`. This allows the function to receive the address of the structure and access or modify its members using the arrow operator (->).

59. What is the output of the following code?


struct Rectangle {
    int length;
    int width;
};void printArea(struct Rectangle *r) {
    printf("%d", r->length * r->width);
}
struct Rectangle rect = {10, 5};
printArea(&rect);

ⓐ. 50

ⓑ. 15

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: 50

Explanation: The `printArea` function takes a pointer to a `Rectangle` structure and prints the area by multiplying the `length` and `width` members. The address of the `rect` structure is passed to the function, which calculates and prints the area (10 * 5 = 50).

60. How do you free memory allocated for a structure through a pointer?

ⓐ. delete(ptr);

ⓑ. free(*ptr);

ⓒ. free(ptr);

ⓓ. dealloc(ptr);

Correct Answer: free(ptr);

Explanation: To free memory allocated for a structure through a pointer, you use the `free` function with the pointer as the argument. This releases the allocated memory back to the system, preventing memory leaks.

61. How do you allocate memory for an array of structures using pointers?

ⓐ. ptr = malloc(n * sizeof(struct structure_name));

ⓑ. ptr = (struct structure_name *)malloc(n);

ⓒ. ptr = (struct structure_name *)malloc(n * sizeof(struct structure_name));

ⓓ. Both A and C

Correct Answer: Both A and C

Explanation: To allocate memory for an array of structures using pointers, you use the `malloc` function. You need to multiply the number of elements (`n`) by the size of the structure (`sizeof(struct structure_name)`). Casting the result of `malloc` to `struct structure_name *` is also good practice in C.

62. What is the output of the following code?


struct Point {
    int x;
    int y;
};
struct Point *p = (struct Point *)malloc(2 * sizeof(struct Point));
p[0].x = 1;
p[0].y = 2;
p[1].x = 3;
p[1].y = 4;
printf("%d %d %d %d", p[0].x, p[0].y, p[1].x, p[1].y);
free(p);

ⓐ. 0 0 0 0

ⓑ. 1 2 3 4

ⓒ. 1 2 0 0

ⓓ. Compiler error

Correct Answer: 1 2 3 4

Explanation: The code dynamically allocates memory for an array of two `Point` structures. The `x` and `y` members of both structures are assigned values. The `printf` function prints these values, and the allocated memory is freed using the `free` function.

63. How do you change the value of a structure member through a pointer?

ⓐ. *ptr.member = value;

ⓑ. ptr.member = value;

ⓒ. ptr->member = value;

ⓓ. ptr*->member = value;

Correct Answer: ptr->member = value;

Explanation: To change the value of a structure member through a pointer, you use the arrow operator (->). This allows you to access and modify the member directly via the pointer.

64. What is the output of the following code?


struct Book {
    char title[30];
    float price;
};void updatePrice(struct Book *b, float newPrice) {
    b->price = newPrice;
}
struct Book myBook = {"C Programming", 29.99};
updatePrice(&myBook, 24.99);
printf("%.2f", myBook.price);

ⓐ. 24.99

ⓑ. 29.99

ⓒ. Compiler error

ⓓ. Undefined behavior

Correct Answer: 24.99

Explanation: The `updatePrice` function takes a pointer to a `Book` structure and a new price. It updates the `price` member of the `Book` structure through the pointer. The address of `myBook` is passed to the function, which changes the price to 24.99. The `printf` function then prints the updated price.

65. What is the advantage of using pointers to structures in C?

ⓐ. Allows dynamic memory allocation

ⓑ. Enables passing large structures to functions efficiently

ⓒ. Facilitates the creation of complex data structures like linked lists and trees

ⓓ. All of the above

Correct Answer: All of the above

Explanation: Using pointers to structures in C allows for dynamic memory allocation, efficient passing of large structures to functions, and the creation of complex data structures like linked lists, trees, and graphs. This provides flexibility and efficiency in managing memory and data.

66. What is the output of the following code?


struct Person {
    char name[20];
    int age;
};void birthday(struct Person *p) {
    p->age++;
}
struct Person john = {"John", 25};
birthday(&john);
printf("%d", john.age);

ⓐ. 24

ⓑ. 25

ⓒ. 26

ⓓ. Compiler error

Correct Answer: 26

Explanation: The `birthday` function takes a pointer to a `Person` structure and increments the `age` member. The address of `john` is passed to the function, which increments his age from 25 to 26. The `printf` function then prints the updated age.

67. How can you use a pointer to traverse a linked list of structures in C?

ⓐ. By incrementing the pointer itself

ⓑ. By following the `next` pointers in each node

ⓒ. By using array indexing

ⓓ. By using a counter

Correct Answer: By following the `next` pointers in each node

Explanation: To traverse a linked list of structures in C, you use a pointer to follow the `next` pointers in each node. This allows you to move from one node to the next until you reach the end of the list.

68. What is the output of the following code?


struct Node {
    int data;
    struct Node *next;
};void printList(struct Node *n) {
    while (n != NULL) {
        printf("%d ", n->data);
        n = n->next;
    }
}
struct Node n1 = {10, NULL};
struct Node n2 = {20, NULL};
struct Node n3 = {30, NULL};
n1.next = &n2;
n2.next = &n3;
printList(&n1);

ⓐ. 10 20 30

ⓑ. 30 20 10

ⓒ. 10 30 20

ⓓ. Compiler error

Correct Answer: 10 20 30

Explanation: The code creates a linked list with three nodes and connects them. The `printList` function takes a pointer to the head of the list and prints the `data` members of each node in order. The output is "10 20 30".

69. How do you initialize a pointer to a structure to NULL?

ⓐ. struct structure_name *ptr = 0;

ⓑ. struct structure_name *ptr = NULL;

ⓒ. struct structure_name *ptr = null;

ⓓ. Both A and B

Correct Answer: Both A and B

Explanation: You can initialize a pointer to a structure to NULL using either `struct structure_name *ptr = 0;` or `struct structure_name *ptr = NULL;`. This ensures that the pointer does not point to any valid memory location initially.

70. What is the output of the following code?


struct Employee {
    char name[20];
    int id;
    struct Employee *next;
};
struct Employee *head = NULL;
struct Employee *e1 = (struct Employee *)malloc(sizeof(struct Employee));
strcpy(e1->name, "Alice");
e1->id = 1001;
e1->next = NULL;
head = e1;
printf("%s %d", head->name, head->id);
free(e1);

ⓐ. Alice 1001

ⓑ. Alice 0

ⓓ. Undefined behavior

Correct Answer: Alice 1001

Explanation: The code dynamically allocates memory for an `Employee` structure, assigns values to the `name` and `id` members, and sets the `next` pointer to NULL. The `head` pointer is set to point to this structure. The `printf` function prints the `name` and `id` members of the `head` structure. Finally, the allocated memory is freed using the `free` function.

71. What is a nested structure in C?

ⓐ. A structure that contains a pointer to another structure

ⓑ. A structure that is defined within another structure

ⓓ. A structure that is defined globally

Correct Answer: A structure that is defined within another structure

Explanation: A nested structure in C is a structure that is defined within another structure. This allows the inner structure to be a member of the outer structure, enabling complex data representation.

72. How do you access a member of a nested structure in C?

ⓐ. outer_struct.inner_struct.member

ⓑ. outer_struct->inner_struct->member

ⓓ. outer_struct->inner_struct.member

Correct Answer: outer_struct.inner_struct.member

Explanation: To access a member of a nested structure in C, you use the dot operator to navigate through the outer structure to the inner structure, and then access the desired member. If using pointers, you would use the arrow operator appropriately.

73. What is the output of the following code?


struct Address {
    char city[20];
    int zip;
};
struct Person {
    char name[20];
    struct Address addr;
};
struct Person p = {"John", {"New York", 10001}};
printf("%s lives in %s, ZIP: %d", p.name, p.addr.city, p.addr.zip);

ⓐ. John lives in New York, ZIP: 10001

ⓑ. John lives in New York, ZIP: 0

ⓓ. Compiler error

Correct Answer: John lives in New York, ZIP: 10001

Explanation: The code defines a nested structure `Address` within `Person`. It initializes the `Person` structure and assigns values to the nested `Address` structure. The `printf` function prints the `name`, `city`, and `zip` members, resulting in "John lives in New York, ZIP: 10001".

74. How do you dynamically allocate memory for a structure containing a nested structure?

ⓐ. Use `malloc` for the outer structure only

ⓑ. Use `malloc` for both the outer and inner structures

ⓓ. Use `calloc` for the outer structure only

Correct Answer: Use `malloc` for the outer structure only

Explanation: When dynamically allocating memory for a structure containing a nested structure, you only need to use `malloc` for the outer structure. The nested structure is part of the outer structure and does not require separate allocation.

75. What is the output of the following code?


struct Dimensions {
    int length;
    int width;
};
struct Box {
    char label[20];
    struct Dimensions size;
};
struct Box *b = (struct Box *)malloc(sizeof(struct Box));
strcpy(b->label, "Package");
b->size.length = 10;
b->size.width = 5;
printf("%s: %d x %d", b->label, b->size.length, b->size.width);
free(b);

ⓐ. Package: 10 x 5

ⓑ. Package: 0 x 0

ⓓ. Compiler error

Correct Answer: Package: 10 x 5

Explanation: The code dynamically allocates memory for a `Box` structure, assigns values to the `label` and nested `Dimensions` structure, and prints these values. The `printf` function prints "Package: 10 x 5", and the allocated memory is freed using the `free` function.

76. How do you pass a nested structure to a function in C?

ⓐ. void function_name(struct outer_struct inner_struct);

ⓑ. void function_name(struct outer_struct *inner_struct);

ⓓ. void function_name(struct outer_struct *outer_struct);

Correct Answer: void function_name(struct outer_struct *outer_struct);

Explanation: To pass a nested structure to a function, you typically pass a pointer to the outer structure. This allows the function to access and modify the nested structure's members using the arrow operator.

77. What is the output of the following code?


struct Engine {
    int horsepower;
    int cylinders;
};
struct Car {
    char model[20];
    struct Engine eng;
};void printCar(struct Car *c) {
    printf("%s: %d HP, %d cylinders", c->model, c->eng.horsepower, c->eng.cylinders);
}
struct Car car = {"Sedan", {250, 4}};
printCar(&car);

ⓐ. Sedan: 250 HP, 4 cylinders

ⓑ. Sedan: 0 HP, 0 cylinders

ⓓ. Undefined behavior

Correct Answer: Sedan: 250 HP, 4 cylinders

Explanation: The `printCar` function takes a pointer to a `Car` structure and prints its members, including the nested `Engine` structure's members. The `Car` structure is initialized, and its address is passed to the `printCar` function, resulting in the output "Sedan: 250 HP, 4 cylinders".

78. What is a common use case for nested structures in C?

ⓐ. To simplify pointer arithmetic

ⓑ. To represent complex data relationships

ⓓ. To reduce the size of structures

Correct Answer: To represent complex data relationships

Explanation: Nested structures in C are commonly used to represent complex data relationships. By embedding one structure within another, you can model hierarchical data, such as a person having an address, an engine belonging to a car, or a company having multiple departments.

79. What is the output of the following code?


struct Date {
    int day;
    int month;
    int year;
};
struct Event {
    char title[30];
    struct Date eventDate;
};
struct Event e = {"Meeting", {15, 7, 2024}};
printf("%s on %d/%d/%d", e.title, e.eventDate.day, e.eventDate.month, e.eventDate.year);

ⓐ. Meeting on 15/7/2024

ⓑ. Meeting on 7/15/2024

ⓓ. Compiler error

Correct Answer: Meeting on 15/7/2024

Explanation: The code defines a nested structure `Date` within `Event`. It initializes the `Event` structure with a title and a date. The `printf` function prints the `title` and the `day`, `month`, and `year` members of the nested `Date` structure, resulting in "Meeting on 15/7/2024".

80. How do you initialize a nested structure in C?

ⓐ. Using individual assignments for each member

ⓑ. Using a nested initializer list

ⓓ. Using a macro

Correct Answer: Using a nested initializer list

Explanation: To initialize a nested structure in C, you use a nested initializer list. This allows you to specify the values for the inner structure's members within the outer structure's initializer list, as shown in the previous example with `struct Event e = {"Meeting", {15, 7, 2024}};`.

81. What is the output of the following code?


struct Time {
    int hour;
    int minute;
    int second;
};
struct Schedule {
    char task[20];
    struct Time startTime;
};
struct Schedule meeting = {"Team Meeting", {10, 30, 0}};
printf("%s starts at %02d:%02d:%02d", meeting.task, meeting.startTime.hour, meeting.startTime.minute, meeting.startTime.second);

ⓐ. Team Meeting starts at 10:30:00

ⓑ. Team Meeting starts at 10:30

ⓓ. Compiler error

Correct Answer: Team Meeting starts at 10:30:00

Explanation: The code defines a nested structure `Time` within `Schedule`. It initializes the `Schedule` structure with a task and a start time. The `printf` function prints the task and the start time in `hh:mm:ss` format, resulting in "Team Meeting starts at 10:30:00".

82. How do you define a nested structure within another structure using typedef in C?

ⓐ. typedef struct outer { struct inner { ... } } outer;

ⓑ. typedef struct { struct { ... } inner } outer;

ⓓ. typedef struct outer { struct inner { ... } inner; } outer;

Correct Answer: typedef struct outer { struct inner { ... } inner; } outer;

Explanation: To define a nested structure using `typedef`, you first define the outer structure and then define the inner structure within it. This approach allows you to use `outer` as an alias for the outer structure type, which includes the inner structure.

83. What is the output of the following code?


struct Date {
    int day;
    int month;
    int year;
};
struct Employee {
    char name[20];
    struct Date birthdate;
};
struct Employee emp = {"Alice", {12, 5, 1990}};
printf("%s was born on %d/%d/%d", emp.name, emp.birthdate.day, emp.birthdate.month, emp.birthdate.year);

ⓐ. Alice was born on 12/5/1990

ⓑ. Alice was born on 5/12/1990

ⓓ. Compiler error

Correct Answer: Alice was born on 12/5/1990

Explanation: The code defines a nested structure `Date` within `Employee`. It initializes the `Employee` structure with a name and a birthdate. The `printf` function prints the name and the birthdate in `dd/mm/yyyy` format, resulting in "Alice was born on 12/5/1990".

84. How do you modify the values of a nested structure's members?

ⓐ. Using the dot operator for each level of nesting

ⓑ. Using a single dot operator for the entire path

ⓓ. Using a single arrow operator for the entire path

Correct Answer: Using the dot operator for each level of nesting

Explanation: To modify the values of a nested structure's members, you use the dot operator for each level of nesting. This means you access each nested level step by step, modifying the desired member.

85. What is the output of the following code?


struct Engine {
    int horsepower;
    int cylinders;
};
struct Car {
    char model[20];
    struct Engine eng;
};
struct Car *c = (struct Car *)malloc(sizeof(struct Car));
strcpy(c->model, "Coupe");
c->eng.horsepower = 200;
c->eng.cylinders = 6;
printf("%s: %d HP, %d cylinders", c->model, c->eng.horsepower, c->eng.cylinders);
free(c);

ⓐ. Coupe: 200 HP, 6 cylinders

ⓑ. Coupe: 0 HP, 0 cylinders

ⓓ. Compiler error

Correct Answer: Coupe: 200 HP, 6 cylinders

Explanation: The code dynamically allocates memory for a `Car` structure, assigns values to the `model` and nested `Engine` structure, and prints these values. The `printf` function prints "Coupe: 200 HP, 6 cylinders", and the allocated memory is freed using the `free` function.

86. How can you copy the values of one nested structure to another in C?

ⓐ. Using the `=` operator directly

ⓑ. Using `strcpy` for string members and direct assignment for other members

ⓓ. Both B and C

Correct Answer: Both B and C

Explanation: You can copy the values of one nested structure to another in C by using `strcpy` for string members and direct assignment for other members. Alternatively, you can use `memcpy` to copy the entire structure at once. Using the `=` operator directly works if the structures are identical and do not contain pointers.

87. What is the output of the following code?


struct Date {
    int day;
    int month;
    int year;
};
struct Person {
    char name[20];
    struct Date birthdate;
};
struct Person p1 = {"John", {10, 4, 1985}};
struct Person p2;
p2 = p1;
printf("%s was born on %d/%d/%d", p2.name, p2.birthdate.day, p2.birthdate.month, p2.birthdate.year);

ⓐ. John was born on 10/4/1985

ⓑ. John was born on 4/10/1985

ⓓ. Undefined behavior

Correct Answer: John was born on 10/4/1985

Explanation: The code initializes a `Person` structure `p1` and then copies it to another `Person` structure `p2`. The `printf` function prints the copied values, resulting in "John was born on 10/4/1985". The assignment `p2 = p1;` copies all the members, including the nested structure.

88. How do you compare two nested structures for equality in C?

ⓐ. Using the `==` operator

ⓑ. Using the `memcmp` function

ⓓ. Both B and C

Correct Answer: Both B and C

Explanation: To compare two nested structures for equality in C, you can use the `memcmp` function to compare the memory blocks of the structures or compare each member individually. The `==` operator cannot be used to compare structures directly.

89. What is the output of the following code?


struct Date {
    int day;
    int month;
    int year;
};
struct Event {
    char title[30];
    struct Date eventDate;
};
struct Event e1 = {"Conference", {25, 11, 2024}};
struct Event e2 = {"Conference", {25, 11, 2024}};
int isEqual = memcmp(&e1, &e2, sizeof(struct Event)) == 0;
printf("Events are %s", isEqual ? "equal" : "not equal");

ⓐ. Events are equal

ⓑ. Events are not equal

ⓓ. Undefined behavior

Correct Answer: Events are equal

Explanation: The code defines two `Event` structures with identical values. The `memcmp` function compares the memory blocks of `e1` and `e2`. Since the structures are identical, `memcmp` returns 0, and the `printf` function prints "Events are equal".

90. How do you initialize a nested structure with an initializer list?

ⓐ. By specifying values for the outer structure only

ⓑ. By specifying values for both the outer and inner structures

ⓓ. By using macros

Correct Answer: By specifying values for both the outer and inner structures

Explanation: To initialize a nested structure with an initializer list, you specify values for both the outer and inner structures. This ensures that all members are properly initialized. For example, `struct Event e = {"Meeting", {15, 7, 2024}};` initializes both the `Event` and the nested `Date` structure.

91. How do you pass a structure to a function in C?

ⓐ. By passing the structure directly

ⓑ. By passing a pointer to the structure

ⓓ. By passing the structure as an array

Correct Answer: By passing the structure directly

Explanation: In C, you can pass a structure to a function directly as an argument. This allows the function to receive a copy of the structure, enabling operations on its members within the function.

92. What is the output of the following code?


#include <stdio.h>
struct Point {
    int x;
    int y;
};
void printPoint(struct Point p) {
    printf("(%d, %d)\n", p.x, p.y);
}
int main() {
    struct Point p1 = {3, 7};
    printPoint(p1);
    p1.x = 5;
    p1.y = 10;
    printPoint(p1);
    return 0;
}

ⓐ. (3, 7) (5, 10)

ⓑ. (5, 10) (3, 7)

ⓓ. Compiler error

Correct Answer: (3, 7) (5, 10)

Explanation: The `printPoint` function takes a structure `Point` as an argument and prints its `x` and `y` coordinates. In `main`, a `Point` structure `p1` is initialized with (3, 7) and printed first. Then, `p1` is modified to (5, 10) and printed again, resulting in "(3, 7) (5, 10)".

93. How do you pass a structure to a function by reference in C?

ⓐ. By passing the structure using the `&` operator

ⓑ. By passing the structure using a pointer

ⓓ. By passing the structure using the `->` operator

Correct Answer: By passing the structure using a pointer

Explanation: To pass a structure by reference in C, you pass a pointer to the structure as an argument to the function. This allows the function to directly modify the original structure passed from `main` or another calling function.

94. What is the output of the following code?


#include <stdio.h>
struct Rectangle {
    int length;
    int width;
};
void scaleRectangle(struct Rectangle *r, int scale) {
    r->length *= scale;
    r->width *= scale;
}
int main() {
    struct Rectangle rect = {5, 3};
    scaleRectangle(&rect, 2);
    printf("Scaled Rectangle: %d x %d\n", rect.length, rect.width);
    return 0;
}

ⓐ. Scaled Rectangle: 10 x 6

ⓑ. Scaled Rectangle: 5 x 3

ⓓ. Compiler error

Correct Answer: Scaled Rectangle: 10 x 6

Explanation: The `scaleRectangle` function takes a pointer to a `Rectangle` structure and a scale factor. It scales the length and width of the rectangle by the scale factor. In `main`, a `Rectangle` structure `rect` is initialized with dimensions (5, 3). After scaling by 2, it prints "Scaled Rectangle: 10 x 6".

95. How do you initialize a structure in a function and return it to `main` in C?

ⓐ. By using the `return` statement with the structure

ⓑ. By using the `&` operator to return the structure

ⓓ. By using a macro definition

Correct Answer: By using the `return` statement with the structure

Explanation: To initialize and return a structure from a function in C, you use the `return` statement with the structure. This allows you to construct and return a complete structure back to the calling function, such as `main`.

96. What is the output of the following code?


#include <stdio.h>
struct Time {
    int hours;
    int minutes;
};
struct Time addTime(struct Time t1, struct Time t2) {
    struct Time sum;
    sum.hours = t1.hours + t2.hours;
    sum.minutes = t1.minutes + t2.minutes;
    if (sum.minutes >= 60) {
        sum.hours++;
        sum.minutes -= 60;
    }
    return sum;
}
int main() {
    struct Time time1 = {5, 45};
    struct Time time2 = {3, 30};
    struct Time totalTime = addTime(time1, time2);
    printf("Total Time: %d hours %d minutes\n", totalTime.hours, totalTime.minutes);
    return 0;
}

ⓐ. Total Time: 9 hours 15 minutes

ⓑ. Total Time: 5 hours 45 minutes

ⓓ. Compiler error

Correct Answer: Total Time: 9 hours 15 minutes

Explanation: The `addTime` function takes two `Time` structures as arguments and returns a `Time` structure representing their sum. In `main`, `time1` is (5, 45) and `time2` is (3, 30). After adding them, `totalTime` becomes (9, 15), which is printed as "Total Time: 9 hours 15 minutes".

97. How do you modify a structure passed to a function by reference?

ⓐ. Using the dot operator

ⓑ. Using the arrow operator

ⓓ. Using a pointer to the structure

Correct Answer: Using the dot operator

Explanation: When a structure is passed to a function by reference (via a pointer), you can modify its members directly using the dot operator within the function. This allows you to access and change the structure's data without needing to dereference the pointer.

98. What is the output of the following code?


#include <stdio.h>
struct Student {
    char name[20];
    int age;
};
void updateStudent(struct Student *s, int newAge) {
    s->age = newAge;
}
int main() {
    struct Student st = {"Emma", 21};
    updateStudent(&st, 22);
    printf("%s is %d years old\n", st.name, st.age);
    return 0;
}

ⓐ. Emma is 21 years old

ⓑ. Emma is 22 years old

ⓓ. Undefined behavior

Correct Answer: Emma is 22 years old

Explanation: The `updateStudent` function takes a pointer to a `Student` structure and updates its `age` member. In `main`, a `Student` structure `st` is initialized with name "Emma" and age 21. After calling `updateStudent(&st, 22);`, the `age` is modified to 22, resulting in "Emma is 22 years old".

99. How do you pass a structure containing a string to a function in C?

ⓐ. By passing the structure directly

ⓑ. By passing a pointer to the structure

ⓓ. By passing the length of the string

Correct Answer: By passing a pointer to the structure

Explanation: When a structure contains a string (character array), you typically pass a pointer to the structure as an argument to functions. This allows functions to access and modify the structure and its string members efficiently.

100. What is the output of the following code?


#include <stdio.h>
struct Employee {
    char name[20];
    int id;
};
void printEmployee(struct Employee *emp) {
    printf("Employee: %s, ID: %d\n", emp->name, emp->id);
}
int main() {
    struct Employee emp1 = {"John", 1001};
    struct Employee emp2 = {"Alice", 1002};
    printEmployee(&emp1);
    printEmployee(&emp2);
    return 0;
}

ⓐ. Employee: John, ID: 1001
Employee: Alice, ID: 1002

ⓑ. Employee: John, ID: 1002
Employee: Alice, ID: 1001

ⓓ. Compiler error

Correct Answer: Employee: John, ID: 1001
Employee: Alice, ID: 1002

Explanation: The `printEmployee` function takes a pointer to an `Employee` structure and prints its `name` and `id` members. In `main`, two `Employee` structures `emp1` and `emp2` are initialized with different values and passed to `printEmployee`, resulting in the correct output.

Structures MCQs – Part 1

Related MCQs