printf("Value: %d\n", *ptr);

// Deallocate memory

free(ptr);

return 0;

Common Errors:

1. Memory Leaks: Failing to deallocate memory.

2. Dangling Pointers: Pointers that point to deallocated memory.

3. Null Pointer Dereference: Dereferencing a null pointer.

3(a) Define Structure? How to create and access Structure members?

Definition of Structure:

A structure (also known as a struct) is a collection of variables of different data types that are stored
together in memory. It is a user-defined data type that allows you to combine multiple variables into
a single unit.

Creating a Structure:

To create a structure, you use the struct keyword followed by the name of the structure and the
variables that make up the structure.

struct Person {

int age;

char name[20];

float height;

};

In this example, we have created a structure called Person that has three variables: age, name, and
height.

Declaring Structure Variables:

To use a structure, you need to declare variables of that structure type:

struct Person person1, person2;

Accessing Structure Members:

To access the members of a structure, you use the dot (.) operator.

person1.age = 25;

strcpy(person1.name, "John");
person1.height = 175.5;

printf("Age: %d\n", person1.age);

printf("Name: %s\n", person1.name);

printf("Height: %.2f\n", person1.height);

In this example, we are accessing the members of the person1 structure variable using the dot
operator.

Using Pointers to Access Structure Members:

You can also use pointers to access structure members.

struct Person *ptr = &person1;

(*ptr).age = 25; // or ptr->age = 25;

strcpy((*ptr).name, "John"); // or strcpy(ptr->name, "John");

(*ptr).height = 175.5; // or ptr->height = 175.5;

In this example, we are using a pointer ptr to access the members of the person1 structure variable.

Array of Structures:

You can also create an array of structures.

struct Person persons[5];

In this example, we have created an array of 5 Person structures.

Accessing Array of Structure Members:

To access the members of an array of structures, you use the array index and the dot operator.

persons[0].age = 25;

strcpy(persons[0].name, "John");

persons[0].height = 175.5;

printf("Age: %d\n", persons[0].age);

printf("Name: %s\n", persons[0].name);

printf("Height: %.2f\n", persons[0].height);

In this example, we are accessing the members of the first element of the persons array.

3(b) Explain the concept of Array of Structures?

Array of Structures:

An array of structures is a collection of structures of the same type stored in contiguous memory
locations. Each element of the array is a structure, and each structure can have multiple members.

Declaring an Array of Structures:

The syntax to declare an array of structures is:

struct structure_name array_name[size];

Example:

struct Student {

int roll_no;

char name[20];

float marks;

};

struct Student students[5];

In this example, we have declared an array of 5 structures of type Student.

Initializing an Array of Structures:

You can initialize an array of structures using the following syntax:

struct Student students[5] = {

{1, "John", 85.5},

{2, "Alice", 90.0},

{3, "Bob", 78.2},

{4, "Charlie", 92.1},

{5, "David", 88.3}

};

Accessing Members of an Array of Structures:

To access the members of an array of structures, you use the array index and the dot operator.

Example:

printf("Roll No: %d\n", students[0].roll_no);

printf("Name: %s\n", students[0].name);

printf("Marks: %.2f\n", students[0].marks);

In this example, we are accessing the members of the first element of the students array.

Advantages of Array of Structures:

1. Efficient memory usage: Array of structures allows for efficient memory usage, as multiple
structures are stored in contiguous memory locations.

2. Easy access: Members of an array of structures can be easily accessed using the array index and
dot operator.
3. Simplified code: Array of structures can simplify code, as you can perform operations on multiple
structures using a single loop.

4(a) Explain the concept of Structure pointer?

Structure Pointer:

A structure pointer is a pointer variable that points to a structure. It is a variable that holds the
memory address of a structure.

Declaring a Structure Pointer:

The syntax to declare a structure pointer is:

struct structure_name *pointer_name;

Example:

struct Student {

int roll_no;

char name[20];

float marks;

};

struct Student *ptr;

In this example, we have declared a structure pointer ptr that points to a structure of type Student.

Initializing a Structure Pointer:

You can initialize a structure pointer by assigning it the address of a structure.

Example:

struct Student student = {1, "John", 85.5};

struct Student *ptr = &student;

In this example, we have initialized the structure pointer ptr with the address of the structure
variable student.

Accessing Structure Members using a Structure Pointer:

To access the members of a structure using a structure pointer, you use the arrow operator (->).

Example:

printf("Roll No: %d\n", ptr->roll_no);

printf("Name: %s\n", ptr->name);

printf("Marks: %.2f\n", ptr->marks);

In this example, we are accessing the members of the structure pointed to by ptr using the arrow
operator.

Dereferencing a Structure Pointer:

You can dereference a structure pointer using the dereference operator (*).

Example:

(*ptr).roll_no = 2;

strcpy((*ptr).name, "Alice");

(*ptr).marks = 90.0;

In this example, we are dereferencing the structure pointer ptr and accessing its members using the
dot operator.

Advantages of Structure Pointers:

1. Efficient memory usage: Structure pointers allow for efficient memory usage, as you can pass
structures to functions without copying the entire structure.

2. Improved code readability: Structure pointers can improve code readability, as you can use the
arrow operator to access structure members.

3. Simplified code: Structure pointers can simplify code, as you can perform operations on structures
using a single pointer.

4 (b) Discuss about union?

Unions:

A union is a special data type in C that allows storing different types of data in the same memory
location. It is a collection of variables of different data types that share the same memory space.

Declaring a Union:

The syntax to declare a union is:

union union_name {

data_type member1;

data_type member2;

...

data_type memberN;

};

Example:

union Data {

int i;