DEV Community: hassaan-syed

Why 0.1 + 0.2 != 0.3 in C? Understanding Floating Point Numbers

hassaan-syed — Sun, 05 Apr 2026 16:46:23 +0000

HISTORY:IEEE 754 was invented in 1985 to standardize floating-point arithmetic, ensuring consistent, reliable, and portable numerical results across different computer hardware.

#include <stdio.h>

int main() {
    float a = 0.1;
    float b = 0.2;

    if (a + b == 0.3)
        printf("Equal\n");
    else
        printf("Not Equal\n");

    return 0;
}

WHAT DO YOU EXPECT?
Eqaul or Not Equal,If Equal then your wrong because,
computer dont know the . as a decimal so for that we usedb IEEE754 standard for better uderstanding the real problem let us do by example.

Computers don’t understand numbers like we do.
We use decimal (base 10):
0.1 → one tenth

But computers use binary (base 2):
0s and 1s only

Now here’s the catch:
Some decimal numbers cannot be represented exactly in binary

Just like:
1/3 = 0.3333... (infinite in decimal)

Similarly:
0.1 in binary = 0.0001100110011... (infinite)

then,What is actaully stored in computer
like eg : float 0.1
it stores the nearest approx value
like : 0.10000000149011612 (in binary)

WE CAN PROVE BY CODING

#include <stdio.h>

int main() {
    float a = 0.1;
    float b = 0.2;

    printf("%.20f\n", a);
    printf("%.20f\n", b);
    printf("%.20f\n", a + b);

    return 0;
}

OUTPUT
0.10000000149011611938 0.20000000298023223877 0.30000001192092895508

NOW,lets understand how really its stores in binary so called "Format"
its is simple its stores in 4bytes
this bytes are divided into fixed paths we call as:
1.sign

2.exponent
3.mantisa

this are actaully important so keep in mind

Sign (S)
Decides whether the number is positive or negative
Uses 1 bit only
0 → Positive (+)
1 → Negative (−)

Example:
+5.2 → Sign = 0
-5.2 → Sign = 1

Exponent (E)
Controls the scale (magnitude) of the number
Think of it like moving the decimal point

“How big or how small is the number?”
Higher exponent → Bigger number

Lower exponent → Smaller number

Example idea:
1.23 × 10³ = 1230 (big)
1.23 × 10⁻³ = 0.00123 (small)

In binary, the exponent does the same job.

Fraction / Mantissa (F)
Stores the actual digits (precision) of the number
This is the main value part.

“What are the exact digits of the number?”
More fraction bits → More accuracy

Less fraction bits → Less accuracy

let me ask something?
do you know what is sign copy if yes comment please

THANK YOU FOR READING
"Take it from me that all knowledge is useless until it is connected with your life, because the purpose of knowledge is nothing but to show you the splendors of yourself!"

What’s Inside Your .o File? A Beginner-Friendly Guide to the Linux nm Command

hassaan-syed — Fri, 20 Feb 2026 05:51:13 +0000

What Is the nm Command?
nm is a Linux command that shows the symbols from symbol table of an object file or executable.

In simple words:
nm tells you what functions and variables exist inside a compiled file.

It is commonly used after compilation to inspect what got created inside the object file.

nm file.o

what is symbol?
A symbol is simply a name that represents something in your program.A symbol in C programming is simply the name of a function or global variable that the compiler records inside a compiled file so that the linker and other parts of the system can identify and connect different pieces of code together

That “something” is usually:

A function
A global variable

Symbol table

| Symbol | Meaning       | Simple Explanation            |
| ------ | ------------- | ----------------------------- |
| T      | Text (global) | Global function               |
| t      | Text (local)  | Static function               |
| D      | Data (global) | Global initialized variable   |
| d      | Data (local)  | Static initialized variable   |
| B      | BSS (global)  | Global uninitialized variable |
| b      | BSS (local)   | Static uninitialized variable |
| U      | Undefined     | Used but defined elsewhere    |

each section meaning

Text (.text) → Stores functions (code)
*Data *(.data) → Stores initialized variables
*BSS *(.bss) → Stores uninitialized variables
*Undefined *(U) → Function exists, but defined somewhere else

Memory Layout :

lets under stand by example

#include <stdio.h>

// Global variable
int global_var = 10;

// Static global variable
static int static_var = 20;

// Global function
void global_function() {
    printf("Inside global function\n");
}

// Static function
static void static_function() {
    printf("Inside static function\n");
}

int main() {
    global_function();
    static_function();
    return 0;
}

compilation stages:
step 1 "compile into object file"
gcc -c file.c
~This file.o is created

step 2 "nm command"
nm file.o
~you can might see someting like this

OUTPUT:
0000000000000000 T global_function 0000000000000000 T main 0000000000000000 t static_function 0000000000000000 D global_var 0000000000000000 d static_var U printf

Important Note for Beginners
✔️ Global variables → become symbols
✔️ Functions → become symbols
❌ Local variables inside functions → usually NOT symbols
ex:
void func() { int x = 10; // Not a symbol (local) }
x is temporary and does not appear in nm.

why local variable are not in output?

Local variables are not shown in nm because they are not needed for linking. The purpose of the symbol table (the one nm shows) is to help the linker connect different files together, and local variables do not participate in that process.Its exists only inside its function, lives temporarily on the stack segment

Understanding strlen() Internally by Writing It From Scratch in C

hassaan-syed — Fri, 06 Feb 2026 07:04:42 +0000

Let us understand the internal concept of strlen().

strlen() is a predefined function which is used to know the length of a given string.

Syntax of strlen:
strlen(variable_name);

Example:
char str[6] = "hello"; // here length = 5

char str[6] = "hello";
strlen(str);   // Output: 5

strlen(str);

Firstly, what is a string?

In C, a string is not a data type.
A string is a collection of characters which always ends with a special character '\0', also known as the null character.

This null character indicates the end of the string.
It does not mean “nothing in memory”, but it tells functions where the string stops.

Header file information:
There are some library files which include many function declarations to perform different tasks.
Here, we are learning about the strlen() function, which comes under the <string.h> header file.

Let us start from scratch — how strlen() works internally.

Prototype of strlen:

int my_strlen(const char *str);

Explanation:
int → return type (returns length of string)
my_strlen → function name
const char *str →

char * is a character pointer which stores the base address of the string
const is used so that the value of the string cannot be modified inside the function (this helps avoid bugs)
str is the variable name (kept meaningful and relatable)

code:

int my_strlen(const char *str)
{
    int cnt = 0;
    while (str[cnt] != '\0')
    {
        cnt++;
    }
    return cnt;
}

We use a pointer to traverse the string from one character to another while counting.

How this works step by step:

When we pass the argument:
my_strlen(str);
-The base address of the string is passed to the function.

Counter initialization:
-Here, cnt is an integer variable used to count the number of characters in the string.

While loop condition:
-We know that every string ends with the null character '\0'.
So the loop runs until '\0' is encountered.
-Although we are using str[cnt], internally this works using pointer arithmetic.

Incrementing the counter:
-Each increment moves to the next character of the string and increases the count.

Memory Representation:

Loop termination:
When str[cnt] becomes '\0':

The condition becomes false
The while loop terminates
The function returns the value of cnt

THIS IS MY MY_STRING.H(project)
Full code on GitHub: my_string.h

Why does it return the length of the string?

Because:

Every character is counted
The null character '\0' is not counted
Counting stops exactly at the end of the string

Final understanding:

By writing strlen() from scratch, I understood:

How strings are stored in memory
Why the null character is important
How string traversal works internally in C