### 1.

Pointers

#### Pointer Variables and Operators

**Code:**

```c

#include <stdio.h>

int main() {

int a = 10;

int *p; // Pointer variable

p = &a; // Assigning the address of a to p

printf("Value of a: %d\n", a);

printf("Address of a: %p\n", (void*)&a);

printf("Value of p (address of a): %p\n", (void*)p);

printf("Value at address p (value of a): %d\n", *p); // Dereferencing

return 0;

```

**Output:**

```

Value of a: 10

Address of a: 0x7ffeefbff5d4 (this will vary)

Value of p (address of a): 0x7ffeefbff5d4 (this will vary)

Value at address p (value of a): 10

```

#### Pointer Expressions

```c

#include <stdio.h>

int main() {

int arr[] = {10, 20, 30};

int *p = arr; // Points to the first element of the array

printf("First Element: %d\n", *p); // 10

p++; // Now it points to the second element

printf("Second Element: %d\n", *p); // 20

return 0;

```

**Output:**

```

First Element: 10

Second Element: 20

```

#### Pointer Arrays

**Code:**

```c

#include <stdio.h>

int main() {

int a = 10, b = 20, c = 30;

int *arr[3] = {&a, &b, &c}; // Array of pointers

for (int i = 0; i < 3; i++) {

printf("Value: %d\n", *arr[i]);

return 0;

```

**Output:**

```

Value: 10

Value: 20

Value: 30

```

### 2. Functions

#### Call by Value

**Code:**

```c

#include <stdio.h>

void add(int x) {

x++;

printf("Inside add: %d\n", x);

int main() {
 int a = 5;

add(a); // a remains unchanged

printf("In main: %d\n", a); // 5

return 0;

```

**Output:**

```

Inside add: 6

In main: 5

```

#### Call by Reference

**Code:**

```c

#include <stdio.h>

void add(int *x) {

(*x)++;

printf("Inside add: %d\n", *x);

int main() {

int a = 5;

add(&a); // Now a changes

printf("In main: %d\n", a); // 6

return 0;

}
```

**Output:**

```

Inside add: 6

In main: 6

```

#### Return Statements

**Code:**

```c

#include <stdio.h>

int add(int x, int y) {

return x + y;

int main() {

int sum = add(5, 10);

printf("Sum: %d\n", sum); // 15

return 0;

```

**Output:**

```

Sum: 15

```

#### Recursion
**Code:**

```c

#include <stdio.h>

int factorial(int n) {

if (n == 0) return 1; // Base case

return n * factorial(n - 1); // Recursive call

int main() {

printf("Factorial of 5: %d\n", factorial(5)); // 120

return 0;

```

**Output:**

```

Factorial of 5: 120

```

### 3. Structures

#### Defining and Accessing Structure Members

**Code:**

```c

#include <stdio.h>

struct Point {

int x;
 int y;

};

int main() {

struct Point p1;

p1.x = 5;

p1.y = 10;

printf("Point: (%d, %d)\n", p1.x, p1.y);

return 0;

```

**Output:**

```

Point: (5, 10)

```

#### Arrays of Structures

**Code:**

```c

#include <stdio.h>

struct Student {

char name[50];

int id;

};

int main() {

struct Student s[2] = {{"Alice", 1}, {"Bob", 2}};

printf("Student %s with ID %d\n", s[i].name, s[i].id);

return 0;

```

**Output:**

```

Student Alice with ID 1

Student Bob with ID 2

```

#### Passing Structures to Functions

**Code:**

```c

#include <stdio.h>

struct Point {

int x;

int y;

};

void printPoint(struct Point p) {

printf("Point: (%d, %d)\n", p.x, p.y);

int main() {

struct Point p1 = {5, 10};

return 0;

```

**Output:**

```

Point: (5, 10)

```

### 4. Unions

**Code:**

```c

#include <stdio.h>

union Data {

int i;

float f;

char c;

};

int main() {

union Data data;

data.i = 10;

printf("data.i: %d\n", data.i); // 10

data.f = 5.5;

printf("data.f: %f\n", data.f); // 5.5

// Note: data.i's value is now unpredictable

return 0;

```

**Output:**

```

data.i: 10

data.f: 5.500000

data.i (after setting f): 0 (or unpredictable)

```

### 5. Enumerations

**Code:**

```c

#include <stdio.h>

enum Direction {North, South, East, West};

int main() {

enum Direction dir;

dir = North;

printf("Direction: %d\n", dir); // 0 (default first value)

return 0;

```

**Output:**

```
Direction: 0

```

### 6. typedef

**Code:**

```c

#include <stdio.h>

typedef unsigned long ulong;

int main() {

ulong num = 5000;

printf("Number: %lu\n", num);

return 0;

```

**Output:**

```

Number: 5000

```

### 7. File I/O

#### Opening and Closing a File

**Code:**

```c

#include <stdio.h>
int main() {

FILE *fp;

fp = fopen("test.txt", "w"); // Open for writing

if (fp == NULL) {

printf("Error opening file.\n");

return -1;

fprintf(fp, "Hello, World!\n");

fclose(fp); // Close the file

return 0;

```

**Output:**

(No output on the console, but a file named `test.txt` will be created with the content.)

```plaintext

Hello, World!

```

#### Reading and Writing Text Files

**Code:**

```c

#include <stdio.h>

int main() {

FILE *fp;

char buffer[100];

// Writing to a file
 fp = fopen("test.txt", "w");

fprintf(fp, "This is a test.\n");

fclose(fp);

// Reading from a file

fp = fopen("test.txt", "r");

fgets(buffer, sizeof(buffer), fp);

printf("Content of file: %s", buffer);

fclose(fp);

return 0;

```

**Output:**

```

Content of file: This is a test.

```