C Programming

bySreelal •
0

 


Introduction to C Programming

C is a general-purpose programming language that is powerful, efficient, and widely used for system and application software. It provides a good foundation for learning other programming languages, as many languages like C++, Java, and Python have similar syntax.

Setting Up the Environment

Before we start, you need a C compiler. Here are some popular options:

  • GCC (GNU Compiler Collection): Available on Linux and macOS. Can be installed on Windows via MinGW.
  • Clang: A compiler for C language family, used by Apple.
  • Visual Studio: Includes a C/C++ compiler.

Writing and Running a Simple Program

Let's start with the classic "Hello, World!" program:

c
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

Explanation:

  • #include <stdio.h>: This is a preprocessor command that includes the standard input-output library, necessary for using printf.
  • int main(): The main function where the program execution begins.
  • printf: A function to print text to the console.
  • return 0;: Indicates that the program ended successfully.

To compile and run this program:

  1. Save it as hello.c.
  2. Open a terminal or command prompt.
  3. Compile it using gcc hello.c -o hello (or using your compiler of choice).
  4. Run it with ./hello on Linux/macOS or hello.exe on Windows.

Basics of C

Data Types and Variables

C provides several data types for handling various kinds of data:

  • Basic Data Types:

    • int: Integer type, used for whole numbers.
    • float: Single-precision floating-point.
    • double: Double-precision floating-point.
    • char: Single character.
    • void: Represents the absence of type.

  • Modifiers:

    • short, long: Change the size of the data type.
    • signed, unsigned: Signage of the data type.

Example:

c
#include <stdio.h>

int main() {
    int age = 30;
    float height = 5.9;
    double balance = 123456.78;
    char initial = 'A';

    printf("Age: %d\n", age);
    printf("Height: %.1f\n", height);
    printf("Balance: %.2f\n", balance);
    printf("Initial: %c\n", initial);

    return 0;
}

Operators

C provides various operators for performing operations on data:

  • Arithmetic Operators: +, -, *, /, %
  • Relational Operators: ==, !=, >, <, >=, <=
  • Logical Operators: &&, ||, !
  • Increment/Decrement Operators: ++, --
  • Assignment Operators: =, +=, -=, *=, /=, %=

Example:

c
#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int sum = a + b;
    int diff = a - b;
    int product = a * b;
    int quotient = b / a;
    int remainder = b % a;

    printf("Sum: %d\n", sum);
    printf("Difference: %d\n", diff);
    printf("Product: %d\n", product);
    printf("Quotient: %d\n", quotient);
    printf("Remainder: %d\n", remainder);

    return 0;
}

Control Structures

Conditional Statements

  • if: Executes a block of code if a condition is true.
  • else: Executes a block of code if the condition is false.
  • else if: Checks multiple conditions.

Example:

c
#include <stdio.h>

int main() {
    int number = 10;

    if (number > 0) {
        printf("The number is positive.\n");
    } else if (number < 0) {
        printf("The number is negative.\n");
    } else {
        printf("The number is zero.\n");
    }

    return 0;
}

Switch Statement

The switch statement is used to select one of many code blocks to be executed.

Example:

c
#include <stdio.h>

int main() {
    int choice = 2;

    switch (choice) {
        case 1:
            printf("You chose option 1.\n");
            break;
        case 2:
            printf("You chose option 2.\n");
            break;
        case 3:
            printf("You chose option 3.\n");
            break;
        default:
            printf("Invalid choice.\n");
    }

    return 0;
}

Loops

  • for: Executes a block of code a specific number of times.
  • while: Executes a block of code while a condition is true.
  • do-while: Executes a block of code at least once, then repeats while a condition is true.

Examples:

c
#include <stdio.h>

int main() {
    // For loop
    for (int i = 0; i < 5; i++) {
        printf("For Loop Iteration: %d\n", i);
    }

    // While loop
    int j = 0;
    while (j < 5) {
        printf("While Loop Iteration: %d\n", j);
        j++;
    }

    // Do-while loop
    int k = 0;
    do {
        printf("Do-While Loop Iteration: %d\n", k);
        k++;
    } while (k < 5);

    return 0;
}

Functions

Functions are used to divide a program into smaller, manageable, and reusable blocks.

Function Definition and Declaration

A function consists of a declaration, definition, and calling.

Example:

c
#include <stdio.h>

// Function declaration
int add(int a, int b);

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

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

Recursion

Recursion is a process where a function calls itself.

Example (Factorial Calculation):

c
#include <stdio.h>

// Recursive function to calculate factorial
int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int number = 5;
    printf("Factorial of %d is %d\n", number, factorial(number));
    return 0;
}

Arrays and Strings

Arrays

An array is a collection of elements of the same type stored in contiguous memory locations.

Example:

c
#include <stdio.h>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("Element at index %d: %d\n", i, numbers[i]);
    }

    return 0;
}

Strings

Strings in C are arrays of characters terminated by a null character \0.

Example:

c
#include <stdio.h>

int main() {
    char name[] = "Alice";
    printf("Name: %s\n", name);
    return 0;
}

String Functions

C provides several standard library functions for string manipulation, such as strlen, strcpy, strcat, and strcmp.

Example:

c
#include <stdio.h>
#include <string.h>

int main() {
    char str1[20] = "Hello";
    char str2[20] = "World";
    
    // String length
    printf("Length of str1: %lu\n", strlen(str1));
    
    // String copy
    strcpy(str1, str2);
    printf("After copying str2 to str1: %s\n", str1);
    
    // String concatenation
    strcat(str1, "!");
    printf("After concatenation: %s\n", str1);
    
    // String comparison
    if (strcmp(str1, str2) == 0) {
        printf("str1 and str2 are equal.\n");
    } else {
        printf("str1 and str2 are not equal.\n");
    }

    return 0;
}

Pointers

Pointers are variables that store the memory address of another variable.

Pointer Basics

Example:

c
#include <stdio.h>

int main() {
    int number = 10;
    int *ptr = &number;  // Pointer to number

    printf("Value of number: %d\n", number);
    printf("Address of number: %p\n", (void*)&number);
    printf("Pointer ptr points to: %p\n", (void*)ptr);
    printf("Value pointed by ptr: %d\n", *ptr);

    return 0;
}

Pointer Arithmetic

Example:

c
#include <stdio.h>

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int *ptr = numbers;

    for (int i = 0; i < 5; i++) {
        printf("Value at index %d: %d\n", i, *(ptr + i));
    }

    return 0;
}

Passing Pointers to Functions

Example:

c
#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

Structures and Unions

Structures

Structures allow grouping of different data types under a single name.

Example:

c
#include <stdio.h>

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

int main() {
    struct Person person1;
    
    strcpy(person1.name, "John");
    person1.age = 30;
    person1.height = 5.9;

    printf("Name: %s\n", person1.name);
    printf("Age: %d\n", person1.age);
    printf("Height: %.1f\n", person1.height);

    return 0;
}

Unions

Unions are similar to structures but share the same memory location for all their members.

Example:

c
#include <stdio.h>

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

int main() {
    union Data data;

    data.intValue = 10;
    printf("Integer value: %d\n", data.intValue);

    data.floatValue = 220.5;
    printf("Float value: %.2f\n", data.floatValue);

    data.charValue = 'A';
    printf("Character value: %c\n", data.charValue);

    return 0;
}

Dynamic Memory Allocation

C provides functions for dynamic memory allocation: malloc, calloc, realloc, and free.

Example:

c
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5;

    // Allocate memory for 5 integers
    ptr = (int*)malloc(n * sizeof(int));
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        ptr[i] = i + 1;
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // Free allocated memory
    free(ptr);

    return 0;
}

Advanced Topics

File I/O

C provides functions for file input and output: fopen, fclose, fread, fwrite, fprintf, fscanf, etc.

Example:

c
#include <stdio.h>

int main() {
    FILE *file;
    char text[100];

    // Writing to a file
    file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    fprintf(file, "Hello, File!\n");
    fclose(file);

    // Reading from a file
    file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    while (fgets(text, sizeof(text), file) != NULL) {
        printf("%s", text);
    }
    fclose(file);

    return 0;
}

Preprocessor Directives

The C preprocessor is used to modify your program before it is compiled. Common directives include #define, #include, #ifdef, and #ifndef.

Example:

c
#include <stdio.h>

#define PI 3.14159
#define CIRCLE_AREA(radius) (PI * (radius) * (radius))

int main() {
    int radius = 5;
    printf("Area of circle with radius %d: %.2f\n", radius, CIRCLE_AREA(radius));
    return 0;
}

Bitwise Operations

Bitwise operators allow manipulation of individual bits within a data item.

Example:

c
#include <stdio.h>

int main() {
    unsigned int a = 5;  // 0101 in binary
    unsigned int b = 9;  // 1001 in binary

    printf("a & b: %d\n", a & b);  // Bitwise AND
    printf("a | b: %d\n", a | b);  // Bitwise OR
    printf("a ^ b: %d\n", a ^ b);  // Bitwise XOR
    printf("~a: %d\n", ~a);        // Bitwise NOT
    printf("b << 1: %d\n", b << 1);  // Left shift
    printf("b >> 1: %d\n", b >> 1);  // Right shift

    return 0;
}

Advanced Data Structures

Linked Lists

Example:

c
#include <stdio.h>
#include <stdlib.h>

// Node structure
struct Node {
    int data;
    struct Node *next;
};

// Function to print the linked list
void printList(struct Node *node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}

int main() {
    struct Node *head = NULL;
    struct Node *second = NULL;
    struct Node *third = NULL;

    // Allocate nodes in the heap
    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node*)malloc(sizeof(struct Node));

    head->data = 1;  // Assign data to first node
    head->next = second;  // Link first node with second

    second->data = 2;  // Assign data to second node
    second->next = third;  // Link second node with third

    third->data = 3;  // Assign data to third node
    third->next = NULL;  // Terminate the list

    // Print the linked list
    printList(head);

    // Free allocated memory
    free(head);
    free(second);
    free(third);

    return 0;
}

Stacks and Queues

Stacks and queues are abstract data types that can be implemented using arrays or linked lists.

Stack Example:

c
#include <stdio.h>
#include <stdlib.h>

#define MAX 5

// Stack structure
struct Stack {
    int top;
    int items[MAX];
};

// Function to initialize the stack
void initialize(struct Stack *s) {
    s->top = -1;
}

// Function to check if the stack is full
int isFull(struct Stack *s) {
    return s->top == MAX - 1;
}

// Function to check if the stack is empty
int isEmpty(struct Stack *s) {
    return s->top == -1;
}

// Function to push an element onto the stack
void push(struct Stack *s, int item) {
    if (isFull(s)) {
        printf("Stack overflow\n");
        return;
    }
    s->items[++s->top] = item;
}

// Function to pop an element from the stack
int pop(struct Stack *s) {
    if (isEmpty(s)) {
        printf("Stack underflow\n");
        return -1;
    }
    return s->items[s->top--];
}

// Function to print the stack elements
void printStack(struct Stack *s) {
    for (int i = 0; i <= s->top; i++) {
        printf("%d ", s->items[i]);
    }
    printf("\n");
}

int main() {
    struct Stack stack;
    initialize(&stack);

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printStack(&stack);

    pop(&stack);

    printStack(&stack);

    return 0;
}

Queue Example:

c
#include <stdio.h>
#include <stdlib.h>

#define MAX 5

// Queue structure
struct Queue {
    int front, rear;
    int items[MAX];
};

// Function to initialize the queue
void initialize(struct Queue *q) {
    q->front = q->rear = -1;
}

// Function to check if the queue is full
int isFull(struct Queue *q) {
    return q->rear == MAX - 1;
}

// Function to check if the queue is empty
int isEmpty(struct Queue *q) {
    return q->front == -1 || q->front > q->rear;
}

// Function to enqueue an element
void enqueue(struct Queue *q, int item) {
    if (isFull(q)) {
        printf("Queue overflow\n");
        return;
    }
    if (q->front == -1) {
        q->front = 0;
    }
    q->items[++q->rear] = item;
}

// Function to dequeue an element
int dequeue(struct Queue *q) {
    if (isEmpty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    return q->items[q->front++];
}

// Function to print the queue elements
void printQueue(struct Queue *q) {
    for (int i = q->front; i <= q->rear; i++) {
        printf("%d ", q->items[i]);
    }
    printf("\n");
}

int main() {
    struct Queue queue;
    initialize(&queue);

    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&queue, 30);

    printQueue(&queue);

    dequeue(&queue);

    printQueue(&queue);

    return 0;
}

Error Handling

C provides mechanisms for error handling, such as errno and perror.

Example:

c
#include <stdio.h>
#include <errno.h>
#include <string.h>

int main() {
    FILE *file = fopen("nonexistent.txt", "r");

    if (file == NULL) {
        printf("Error opening file: %s\n", strerror(errno));
    } else {
        fclose(file);
    }

    return 0;
}

Conclusion

This guide covered a range of topics in C programming, from basics to advanced concepts. Here are some recommended steps to continue improving your C programming skills:

  1. Practice: Write programs to reinforce the concepts you've learned.
  2. Explore Libraries: Learn about and use standard C libraries to perform various tasks.
  3. Build Projects: Work on small projects to apply what you've learned.
  4. Read Books: Consider reading C programming books like "The C Programming Language" by Kernighan and Ritchie.
  5. Participate in Online Coding Platforms: Websites like LeetCode and HackerRank offer challenges to improve your coding skills.

Post a Comment

Previous Post Next Post