# Common C Mistakes

## Introduction

C programming, though powerful and efficient, leaves room for common mistakes that can lead to bugs and security vulnerabilities. This document aims to highlight some prevalent pitfalls in C programming, providing examples and guiding developers on how to avoid them.

## Missing Header Files

Forgetting to include necessary header files can result in undefined behavior. Consider the following example:

```c
// Missing the necessary header file
#include <stdio.h>

int main() {
    // Code that uses functions from the stdio library
    printf("Hello, World!");
    return 0;
}
```

**Solution:** Include the necessary header file:

```c
#include <stdio.h>

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

## Omitting Return Statements

Failure to include a return statement in a function that expects a return value can lead to unpredictable behavior. Example:

```c
int add(int a, int b) {
    int result = a + b;
    // Missing return statement
}

int main() {
    int sum = add(3, 4);
    printf("Sum: %d\n", sum);
    return 0;
}
```

**Solution:** Add the missing return statement:

```c
int add(int a, int b) {
    int result = a + b;
    return result;
}

int main() {
    int sum = add(3, 4);
    printf("Sum: %d\n", sum);
    return 0;
}
```

## Uninitialized Variables

Using variables before initializing them can lead to unpredictable results. Example:

```c
#include <stdio.h>

int main() {
    int x;
    printf("Value of x: %d\n", x);  // Using uninitialized variable
    return 0;
}
```

**Solution:** Initialize the variable before using it:

```c
#include <stdio.h>

int main() {
    int x = 0;  // Initialize variable
    printf("Value of x: %d\n", x);
    return 0;
}
```

## Buffer Overflows

Overrunning buffers is a common mistake that can result in memory corruption. Example:

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

int main() {
    char buffer[5];
    strcpy(buffer, "Overflow!");  // Buffer overflow
    printf("Buffer: %s\n", buffer);
    return 0;
}
```

**Solution:** Use safe functions to prevent buffer overflows:

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

int main() {
    char buffer[20];
    strncpy(buffer, "No Overflow!", sizeof(buffer));  
    // Use strncpy to avoid overflow
    printf("Buffer: %s\n", buffer);
    return 0;
}
```

This pattern continues for the remaining examples. Each mistake is followed by an example and a suggested solution. I'll continue with the rest upon your request.
