Structures, Unions & Pointers in C: 17 MCQs with answers

A · A collection of variables of different types under one name

A structure groups variables of different types under a single name, unlike an array which holds same-type elements.

B · `s.roll`

For a structure variable, use the dot operator: `s.roll`.

A · Size of the largest member

All union members share the same memory, so the union's size is that of its largest member.

D · Arrow (`->`)

The arrow operator `->` accesses members via a pointer, e.g., `p->member`.

D · `(*p).member`

`p->member` is shorthand for `(*p).member`; the parentheses are required because `.` binds tighter than `*`.

A · True

The size of a union equals the size of its largest member, because all members share the same memory location.

B · Because of padding for alignment

The compiler inserts padding bytes to align members to natural boundaries, increasing the total size.

D · Only the last written member

Union members overlap; writing one overwrites the others. Only the most recently written member is meaningful.

A · To avoid copying the entire structure

Passing by pointer passes only an address, avoiding the cost of copying all bytes. Modification is a separate benefit.

D · `struct Node { int data; struct Node *next; };`

A self-referential structure contains a pointer to its own type, enabling linked data structures.

D · The data pointed to cannot be modified through `p`

`const struct T *p` means the pointed-to data is read-only through `p`; the pointer itself can change.

D · Representing a value that can be an int, float, or string at different times

Unions are ideal for variant data where only one type is active at a time.

A · It parses as `*(p.member)`, which is incorrect

The dot operator has higher precedence than `*`, so `*p.member` means `*(p.member)`, not `(*p).member`.

D · Reorder members from largest to smallest

Placing larger members first often minimizes padding because alignment gaps are reduced.

D · A union with a tag field indicating which member is active

A tagged union combines a tag (often an enum) with a union to safely track the active member.

C · Not portable and usually not what you want

The bytes are reinterpreted according to the new type; the result depends on representation and is not portable.

B · 10

The correct option is '10' because the `show` function accesses the `roll` member of the `Student` structure using the pointer `p` and the arrow operator `->`, which correctly dereferences to the `roll` member.