15 Hidden C Language Traps Every Developer Must Avoid

C is a widely used programming language, but its low-level nature introduces many subtle bugs that can cause crashes, data loss, or security issues. This article lists fifteen typical C traps, explains why they occur, and offers concrete fixes.

1. Operator Precedence

Different operators have different precedence; misunderstanding this can lead to unexpected results.

int a = 5, b = 3;
int c = a++ * --b; // a becomes 6, b becomes 2, c = 10

Here ++ and -- bind tighter than *, so the increments happen before multiplication. Using parentheses makes the intention clear.

int a = 5, b = 3;
int c = ++a * b--; // a becomes 6, b becomes 2, c = 18

2. Case Sensitivity

Variable and function names are case‑sensitive; myVar and MyVar are distinct.

int MyVar = 5;
int myvar = 3;
printf("%d
", MyVar + myvar); // prints 8

Adopt a consistent naming convention to avoid confusion.

3. Array Out‑of‑Bounds

Accessing an index outside an array’s range leads to undefined behavior.

int arr[3] = {1, 2, 3};
int x = arr[3]; // out‑of‑bounds access

Always ensure the index is within 0 to size‑1.

4. Integer Overflow

When a value exceeds the range of its type, it wraps around.

unsigned char x = 255;
x += 1; // x becomes 0 due to overflow

Choose a type large enough for the expected range.

5. Null Pointer Dereference

Using a pointer that is NULL causes a crash.

int *p = NULL;
*p = 5; // undefined behavior

Check a pointer for NULL before dereferencing.

6. Random Number Seed

Calling rand() without seeding produces the same sequence each run.

for (int i = 0; i < 10; i++) {
    printf("%d ", rand()); // same numbers each execution
}

Seed the generator, e.g., srand(time(NULL));, to obtain varied results.

7. String Handling

Strings must be null‑terminated; forgetting the terminator or writing past the buffer yields garbage output.

char str[10] = "hello";
str[5] = 'w'; // missing '\0' after 'w'
printf("%s
", str); // may print "hellow" plus extra data

// Correct version
char str[10] = "hello";
str[5] = 'w';
str[6] = '\0';
printf("%s
", str); // prints "hellow"

8. Loop Condition Errors

An incorrect condition can cause infinite loops.

int i = 0;
while (i < 10) {
    printf("%d ", i);
    // missing i++ leads to endless loop
}

Verify that the loop variable is updated and the condition will eventually become false.

9. Variable Scope

Variables declared inside a block are not visible outside it.

int x = 1;
if (x == 1) {
    int y = 2;
}
printf("%d
", y); // error: y out of scope

Declare variables in the appropriate scope.

10. Type Casting

Implicit conversions can produce unexpected results, especially with integer division.

int a = 5;
double b = 2.0;
printf("%f
", a / b); // a is promoted, result is 2.5

// To ensure floating‑point division explicitly cast:
printf("%f
", (double)a / b);

11. Function Calls

The number and types of arguments must match the function declaration.

int add(int a, int b) { return a + b; }
printf("%d
", add(1, 2, 3)); // error: too many arguments

12. Struct Access

Accessing members through a null struct pointer causes a crash.

struct Person { char name[10]; int age; };
struct Person *p = NULL;
printf("%s
", p->name); // undefined behavior

13. File Operations

Always check the return value of fopen and close files properly.

FILE *fp = fopen("test.txt", "r");
if (!fp) {
    perror("open failed");
    return;
}
// ... use fp ...
fclose(fp);

14. Macro Definitions

Macros without parentheses can yield incorrect expansions.

#define SQUARE(x) x * x
int a = 2;
int b = SQUARE(a + 1); // expands to a + 1 * a + 1 -> wrong result

// Correct macro
#define SQUARE(x) ((x) * (x))

15. Multithreading

Concurrent access to shared resources like printf may interleave output; proper synchronization is required.

void *print_message(void *ptr) {
    char *message = (char *)ptr;
    printf("%s
", message);
    pthread_exit(NULL);
}

pthread_t t1, t2;
char *msg1 = "Thread 1";
char *msg2 = "Thread 2";
pthread_create(&t1, NULL, print_message, (void *)msg1);
pthread_create(&t2, NULL, print_message, (void *)msg2);

Use mutexes or other synchronization primitives to avoid race conditions.

Interview Question

What does the following code print and why?

int a = 0, b = 1, c = 2, d = 3;
if (a++ && b-- || c++ && d--) {
    printf("case - %d %d %d %d
", a, b, c, d);
} else {
    printf("case + %d %d %d %d
", a, b, c, d);
}

Explanation: a++ yields 0 (false), so the left side of && stops evaluating. The expression then evaluates c++ && d--; c++ is non‑zero (true), so d-- is evaluated, yielding true. The overall condition is true, so the if branch runs, printing case - 1 1 3 2.