C: The confusing parts

C: The confusing parts

A guide to demystifying confusing parts of C programming language.


I hate being confused.

It makes me ask more questions.

I've encountered many confusing situations when working with C.

In this blog post, I aim to address most of the confusions.

Many things have been mentioned in my previous blog post already. It's a full guide to pointers in C where we begin by explaining how memory works in C.

Is type casting necessary?


Type casting explicitly converts one data type to another, like:

float myFloat = 3.14;
int myInt = (int) myFloat;  // Result: 3

Necessity of Type Casting

It's not always required. C often does implicit conversions for you. For instance, in mixed-type arithmetic, it'll promote types automatically.

int i = 5;
double d = 2.5;
double result = i * d;  // `i` is implicitly turned into a double.

Why use type casting?

  1. Clarity: Shows the programmer's intent.

  2. Prevent Warnings: Explicit casting can avert compiler warnings.

  3. Consistency: Ensures consistent behavior across different compilers or platforms.

Context of memory allocation

When using functions like malloc from the C Standard Library, it returns a void pointer, which can be pointed to any type. A common practice is to cast this pointer to the desired type.

int *arr = (int *) malloc(10 * sizeof(int));  // Explicitly cast to int*

Again, this isn't necessary. It's valid to assign a void pointer to another pointer type without a cast.

However, why it's good to do it:

  1. Readability: Casting can make it clear what type of data you intend to store.

  2. C++ Compatibility: If you're working in a mixed C/C++ environment, C++ requires the cast.

Indexing pointer gives me the value?

When you declare an array, say int arr[5];, it's kind of like setting up a row of five lockers, each big enough for an int. The name arr points to the start of these lockers.

If arr is just a pointer to the first locker, then arr[3] feels like it should be the fourth locker, right? But wait! Why does this work when arr isn’t an array, but a pointer? Here’s where things get tricky:

Under the hood, when you do arr[3], it's a shortcut for *(arr + 3). You're dereferencing a pointer. The +3 moves the pointer 3 int-sized steps forward, and the * gets the value from that spot.

To clarify, you are moving 3 steps forward from the first pointer since arr points to the first one.

Padding and Alignment



Every data type in C, be it int, char, or double, has a certain alignment requirement. In memory, data is stored sequentially in bytes. Think of this requirement as that data type's "comfort zone". For an int which is 4 bytes, it's like saying, "Hey, I like addresses that are divisible by 4." Why? Because it's way faster for the CPU to access them when they're in these comfort zones.

To clarify, this isn't about the data type's preference, but rather about the system's optimal way of fetching that data. It's a hardware thing. If the data isn't at a "preferred" address, it might take the CPU slightly longer to fetch it, or in some systems, it might even throw an error.


Now, when you're grouping different data types together in a struct, sometimes they won't all fit nicely in a row because of their alignment preferences. So, the compiler steps in like a helpful roommate and adds some extra space (padding) to make sure everyone's comfortable.

Let's say you have a char (which takes 1 byte) followed by an int (which, on most platforms, takes 4 bytes). The int might need to start at a memory address that's divisible by 4 for it to be accessed efficiently.

If our char was at address 1, then the next address, 2, won't be suitable for the int because it's not divisible by 4. The compiler will insert "extra space" (padding) of 2 bytes after the char to ensure the int starts at address 4, which is divisible by 4. This extra space is essentially unused bytes in memory to ensure that the subsequent data aligns properly.

Why should you care?

  1. Keeping data aligned makes your program run faster. It's like having all your favorite snacks within arm's reach. You don’t have to get up and search every time you want a bite.

  2. On some systems, if data isn't aligned right, the program can crash. Imagine trying to read a book, but some pages are missing. Would trip you up, wouldn't it?

Common confusions


You create a struct and think you know its size by adding up the sizes of its members. But then, the sizeof operator tells you it's bigger! That's padding sneaking in there.

struct WhatSizeAmI {
    char mysteryChar;  // Just 1 byte
    int mysteryInt;    // 4 bytes, usually
};  // You'd guess 5 bytes, but it might be 8 because of padding.

Rearrange and Save

Sometimes you can save space by just changing the order of members in a struct. It's kind of like rearranging apps on your phone to fit more on one screen. You're not removing anything, just rearranging.

Depending on the order, the compiler will add more or less padding in there.

Why this is hard to grasp?

  1. Different rules for different folks: Different systems and compilers might handle padding and alignment a bit differently. What's perfectly aligned on one system might not work at all on another system.

  2. Background Magic: Often, you don’t see this padding thing happening. It's like your compiler's sneaky background process. So when you do encounter it, it might feel like a curveball.

  3. The Coddling of High-Level Languages: If you've been chilling with languages like Python or Java, they handle these details for you. Jumping into C is like suddenly having to cook for yourself after years of takeout.

Static keyword: multiple meanings

Local variables

If you declare a variable static inside a function, it retains its value between function calls.

void counter() {
    static int count = 0;
    printf("%d\n", count);

Every time you call counter(), it'll print increasing numbers, not just 1 every time.

Global variables

Using static outside a function (for global variables or functions) means that the variable or function is limited to its defining file. Other files in your program won't see it.

static int hiddenVariable = 42;  // Can't be accessed from other source files.

What's so confusing?

  1. Different Contexts, Different Behaviors: The same keyword doing two very different things based on where it's used is bound to trip up folks. Retaining value? Limiting scope? Which one is it?

  2. Lingo Overlap: The term "static" is used in other contexts in programming, like "static memory allocation" or in object-oriented languages (e.g., static methods in Java or C++). This can add to the confusion.

  3. Visibility vs. Lifetime: For local variables, static affects how long it lives (its entire program's life). For globals, it changes who can see it (just its own file). Mixing those up can lead to painful debugging sessions.



Macros in C are handled by the preprocessor, a tool that runs before actual compilation.

  1. Simple Macros: Replace a name with a value.

     #define PI 3.14159
  2. Function-like Macros: Take arguments and can perform operations.

     #define SQUARE(x) ((x) * (x))
  3. Conditional Compilation: Decide which parts of code to compile.

     #ifdef DEBUG
         printf("Debug mode on!\n");

What's so confusing?

  1. They're Not Real Functions: Especially with function-like macros, it's easy to forget they're just text replacements. They don't have a real function's type safety or scoping rules.

  2. Multiple Evaluation: If your macro has side effects, things get wild.

     #define INCREMENT(x) ((x)++)
     int a = 5;
     int b = INCREMENT(a) + INCREMENT(a);  // Uh-oh! 'a' gets incremented twice.
  3. Parentheses: Due to operator precedence, you often need extra parentheses.

     #define MULTIPLE_BY_TWO(x) (x * 2)
     int c = MULTIPLE_BY_TWO(1 + 2);  // Expected 6, but you get 5.
  4. Debugging: Errors in macros can be a nightmare to debug because they don't exist after the preprocessor is done. Your compiler sees the replaced code, not the original macro.

When to use them?

  1. Flexibility: With macros, you can make configurable code. For example, you can easily switch between debug and release modes.

  2. Performance: Since they're just text replacements, there's no function call overhead like real functions.

  3. Code Reuse: Write once, use everywhere. A macro can be used across different data types, something functions can't do without being redefined or relying on more complex features like generics in other languages.

Union and its Power in Memory Overlapping


A union is a data structure that allows multiple variables to occupy the same memory space. Only one of its members can hold a value at any given time.

union Data {
    int i;
    float f;
    char str[20];

How to use it?

Declare and access its members like a struct.

union Data data;
data.i = 42;  // Now 'i' has a value.
data.f = 3.14;  // Oops! 'i' lost its value. Now 'f' holds the value.

Common confusions

  1. Not a struct: While they look similar, remember in a struct, each member gets its own space. In a union, they share.

  2. Size Matters: The size of a union is the size of its largest member. Not the sum of its members.

  3. Value Overwriting: Setting one member's value invalidates the others. They can't coexist.


We covered more confusing parts in C.

I hope you enjoyed this post!