Structures and User-Defined Types: struct, union, enum, typedef and Introduction to Namespaces Questions

Question 1

Define structure.

Accepted Answer

A **structure** is a user-defined type that groups variables of different data types under one name.

Question 2

What is union?

Accepted Answer

A **union** is a user-defined type where all members share the same memory location.

Question 3

What is enum?

Accepted Answer

An **enum** is a set of named integer constants.

Question 4

What is typedef?

Accepted Answer

`typedef` creates an **alias name** for an existing data type.

Question 5

What is namespace?

Accepted Answer

A **namespace** groups names to avoid conflicts in large programs.

Question 6

Which operator is used for scope resolution?

Accepted Answer

The scope resolution operator is **`::`**.

Question 7

Explain structure with one example.

Accepted Answer

A **structure** groups related fields of different data types. Example: `struct Student{int roll; char grade;};`
We create variable `Student s;` and access members using **`.`** like `s.roll=10`.
This helps represent real-world entities.

Question 8

Differentiate between struct and class (any three points).

Accepted Answer

In C++, `struct` and `class` are similar, but:
- Default access: **struct → public**, **class → private**
- Typical use: struct for simple data grouping; class for encapsulation
- Both support member functions and constructors

So the main difference is default access control.

Question 9

Explain union and its advantage.

Accepted Answer

A **union** stores different members in the **same memory location**, so only one member is valid at a time.
Advantage: **saves memory** (size equals largest member).
It is useful when a variable can hold one of several types.

Question 10

Differentiate between structure and union (brief).

Accepted Answer

In **structure**, each member has separate memory, so all members can hold values at once.
In **union**, all members share memory, so only one member is meaningful at a time and size equals largest member.
Union is used mainly for memory saving.

Question 11

Explain enum with example and use.

Accepted Answer

An **enum** defines named integer constants. Example: `enum Day{Mon,Tue,Wed};`
Use: improves readability and restricts values to a fixed set (avoid magic numbers).

Question 12

Why are namespaces needed in C++?

Accepted Answer

Namespaces avoid **name conflicts** when different libraries or modules have same identifiers. They group related names and we access them using **`::`** (e.g., `std::cout`). This makes large programs safer and organised.

Question 13

Explain structure (struct) in C++ with example and a diagram/table.

Accepted Answer

### **Explain structure (struct) in C++ with example and uses**

A **structure (struct)** is a user-defined data type used to group related variables of **different data types** under one name.

**Key points**:
- members are accessed using **dot (`.`)** operator for structure variables.
- helps represent real-world entities (student, employee, book).

Example (concept):
- `struct Student { int roll; char grade; };`
- `Student s; s.roll = 10;`

| Feature | Meaning |
|---|---|
| Purpose | group related fields |
| Member access | `.` (or `->` for pointer) |

```text
Student
 ├─ roll (int)
 └─ grade (char)
```

Thus, structures improve readability and data organisation in programs.

Question 14

Differentiate between structure and union with a table and diagram.

Accepted Answer

### **Differentiate between structure and union with a table**

Both `struct` and `union` group multiple members, but they differ mainly in memory allocation.

| Basis | **Structure** | **Union** |
|---|---|---|
| Memory for members | separate for each member | shared (same location) |
| Size | approx sum of members (plus padding) | size of largest member |
| Valid values | all members can hold values simultaneously | only one member meaningful at a time |
| Use | general data grouping | memory saving when one field used |

```text
struct: [a][b][c]  (separate)
union : [shared space] (a or b or c)
```

So union saves memory but must be used carefully to avoid overwriting other members.

Question 15

Explain namespaces in C++ and scope resolution operator with a flow/table.

Accepted Answer

### **Explain namespaces in C++ and scope resolution operator**

A **namespace** is used to group names (functions, variables, classes) and avoid **name conflicts**.

Example:
- `cout` is inside the **std** namespace, so we write **`std::cout`**.

Ways to use namespaces:
- `std::cout` (recommended in large projects)
- `using namespace std;` (convenient, but can cause conflicts)
- `using std::cout;` (selective)

| Method | Example | Note |
|---|---|---|
| Scope resolution | `std::cout` | safest |
| using directive | `using namespace std;` | may conflict |
| selective using | `using std::cout;` | balanced |

```text
Name conflict? → put names in namespace → access using :: → avoids clash
```

Thus namespaces make large programs/library usage safe and organised.

Structures and User-Defined Types: struct, union, enum, typedef and Introduction to Namespaces

8 more questions to unlock