History of C Programming

C programming language was developed in the early 1970s by Dennis Ritchie at Bell Labs. It was designed to be a system programming language to write an operating system. The UNIX operating system was the first major program written in C. Over the years, C has influenced many other languages, such as C++, C#, and Java.

Key milestones in the history of C:

Uses of C Programming

C is a versatile language used for various purposes:

Data Types in C

C has several fundamental data types:

Examples of declaring variables of different data types:

int age = 25;
float temperature = 36.5;
double salary = 12345.67;
char grade = 'A';
void function(); // Function declaration with no return type

Each data type has a specific size and range depending on the system architecture. For instance, the size of int can vary between systems, but it's typically 4 bytes on modern architectures.

Variables in C

Variables are used to store data values. They must be declared before use:

int number = 5;
float temperature = 36.5;
char grade = 'A';

Variable names should be meaningful and follow naming conventions. They must begin with a letter or an underscore (_), followed by letters, numbers, or underscores. Variable names are case-sensitive.

Examples of valid and invalid variable names:

int age; // Valid
float _height; // Valid
char firstName; // Valid
int 2ndPlace; // Invalid: starts with a number
float total$; // Invalid: contains an invalid character ($)

Arrays in C

Arrays are used to store multiple values of the same type. They are declared using square brackets:

int numbers[5] = {1, 2, 3, 4, 5};
char name[] = "Alice"; // String is an array of characters

Array indices start at 0 and can be accessed using the index number. Arrays are fixed in size, and their size must be specified at the time of declaration.

Example of accessing and modifying array elements:

int numbers[5] = {1, 2, 3, 4, 5};
printf("First element: %d\n", numbers[0]); // Outputs: 1
numbers[2] = 10;
printf("Third element: %d\n", numbers[2]); // Outputs: 10

Functions in C

Functions are blocks of code designed to perform a particular task. They are defined using the following syntax:

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    printf("Result: %d", result);
    return 0;
}

Functions help in organizing code and promoting code reuse. They can take parameters and return a value. If a function does not return a value, its return type is void.

Examples of function declarations and calls:

void greet() {
    printf("Hello, World!\n");
}

int main() {
    greet(); // Calls the greet function
    return 0;
}

Control Structures in C

C supports various control structures for flow control:

Examples of control structures:

// If...else
int x = 10;
if (x > 5) {
    printf("x is greater than 5\n");
} else {
    printf("x is less than or equal to 5\n");
}

// Switch
char grade = 'B';
switch (grade) {
    case 'A':
        printf("Excellent\n");
        break;
    case 'B':
        printf("Good\n");
        break;
    case 'C':
        printf("Average\n");
        break;
    default:
        printf("Invalid grade\n");
}

// For loop
for (int i = 0; i < 5; i++) {
    printf("%d ", i);
}

// While loop
int count = 0;
while (count < 5) {
    printf("%d ", count);
    count++;
}

// Do...while loop
int n = 0;
do {
    printf("%d ", n);
    n++;
} while (n < 5);

Pointers in C

Pointers are variables that store memory addresses of other variables. They are declared using an asterisk (*) before the variable name:

int number = 10;
int *p = &number;

printf("Value of number: %d\n", number);
printf("Address of number: %p\n", &number);
printf("Value at address stored in p: %d\n", *p);

Pointers are powerful but must be used with care to avoid errors such as null pointer dereferencing and memory leaks. Pointers are essential for dynamic memory allocation and can be used to pass large structures or arrays to functions efficiently.

Example of pointer arithmetic:

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

for (int i = 0; i < 3; i++) {
    printf("Value at arr[%d] = %d\n", i, *(ptr + i));
}

Structs in C

Structures (structs) are used to group different data types into a single unit. They are defined using the struct keyword:

struct Person {
    char name[50];
    int age;
};

int main() {
    struct Person person;
    strcpy(person.name, "Alice");
    person.age = 30;

    printf("Name: %s, Age: %d\n", person.name, person.age);
    return 0;
}

Structs are useful for representing complex data types and can be nested, allowing the creation of more complex data structures.

Example of nested structs:

struct Date {
    int day;
    int month;
    int year;
};

struct Person {
    char name[50];
    int age;
    struct Date birthdate;
};

int main() {
    struct Person person;
    strcpy(person.name, "Alice");
    person.age = 30;
    person.birthdate.day = 15;
    person.birthdate.month = 6;
    person.birthdate.year = 1990;

    printf("Name: %s, Age: %d, Birthdate: %d/%d/%d\n",
           person.name, person.age,
           person.birthdate.day,
           person.birthdate.month,
           person.birthdate.year);
    return 0;
}

File I/O in C

C provides functions for reading and writing files. File operations are performed using the FILE type and functions such as fopen, fprintf, fgets, and fclose:

FILE *file = fopen("example.txt", "w");
if (file != NULL) {
    fprintf(file, "Hello, World!\n");
    fclose(file);
}

file = fopen("example.txt", "r");
if (file != NULL) {
    char buffer[100];
    while (fgets(buffer, 100, file) != NULL) {
        printf("%s", buffer);
    }
    fclose(file);
}

File I/O allows programs to read from and write to files, enabling data persistence across program runs.

Example of binary file I/O:

struct Person {
    char name[50];
    int age;
};

int main() {
    struct Person person = {"Alice", 30};
    FILE *file = fopen("person.dat", "wb");
    if (file != NULL) {
        fwrite(&person, sizeof(struct Person), 1, file);
        fclose(file);
    }

    file = fopen("person.dat", "rb");
    if (file != NULL) {
        struct Person readPerson;
        fread(&readPerson, sizeof(struct Person), 1, file);
        printf("Name: %s, Age: %d\n", readPerson.name, readPerson.age);
        fclose(file);
    }
    return 0;
}