Convert Binary to Decimal in C

Beginner
⏱️ 11 min read
📚 Updated: May 2026
🎯 2 Code Examples
Base conversion

What you’ll learn

  • How positional notation turns a binary bit pattern into a decimal integer.
  • Two C styles: digit peel (integer that looks like 101010) and Horner on a char string.
  • Why integer powers beat pow here, how to validate digits, and a browser live preview.

Overview

Binary uses powers of two from the rightmost bit (least significant). This page shows the same math two ways in C: peel digits from a “binary-looking” integer, or scan a string of '0' and '1' characters with Horner’s rule.

Two programs

Digit peel (reference style, fixed) plus string Horner.

Live preview

Type a bit string; see decimal via parseInt(..., 2) for a quick check.

Fixes vs naive pow

Exact integer weights, digit checks, and long long where helpful.

Prerequisites

Loops, integer division and modulo, and the idea of place value (ones, twos, fours, …).

  • #include <stdio.h>, int main(void), and printing with printf.
  • Optional: C string literals and char * for Example 2.

What does binary to decimal mean?

Each bit position i (starting at 0 on the right) contributes bi · 2i where bi ∈ {0, 1}. The decimal value is the sum of those contributions.

The reference stores the pattern as a normal decimal integer 101010 so each base-ten digit is one bit; the loop reads bits from right to left.

Binary base 2
Decimal base 10
Example 1010102 = 42

Expanded form

Reading 101010 from most to least significant bit (left to right as written),

1010102

1·25 + 0·24 + 1·23 + 0·22 + 1·21 + 0·20 = 32 + 8 + 2 = 42.

Intuition

10102 Decimal 10
Sum
8 + 2 = 10
1112 Decimal 7
Sum
4 + 2 + 1 = 7

Takeaway: each 1 flips on a power of two; each 0 skips that power.

Live preview

Enter a string of 0 and 1 characters (optional spaces). Uses parseInt(s, 2) for a quick decimal value. Empty or invalid characters are rejected.

For long strings, JavaScript may lose precision past 53 bits.

Live result
Press “Convert” to see the decimal value.

Algorithm (digit-stored form)

Goal: interpret a nonnegative integer whose decimal digits are only 0 or 1 as a binary pattern and return its decimal value.

Start value = 0, weight 1

Weight will double each step: 1, 2, 4, …

While the working number is nonzero

Take d = n % 10. If d is not 0 or 1, reject. Else add d * weight to value.

Shift

Divide n by 10, multiply weight by 2, repeat.

📜 Pseudocode

Pseudocode
function binaryDigitsToDecimal(n):  // n has only 0/1 decimal digits
    value ← 0
    weight ← 1
    while n > 0:
        d ← n mod 10
        if d not in {0, 1}: return error
        value ← value + d * weight
        n ← floor(n / 10)
        weight ← weight * 2
    return value
1

Digit peel (integer 101010, no math.h)

Matches the reference flow but uses an exact doubling weight instead of pow(2, i), validates digits, and widens the accumulator.

c
#include <stdio.h>

/* Returns 1 if n contains only decimal digits 0 and 1 (and n >= 0) */
static int is_binary_digit_form(long long n) {
    if (n < 0) {
        return 0;
    }
    if (n == 0) {
        return 1;
    }
    while (n > 0) {
        int d = (int)(n % 10);
        if (d > 1) {
            return 0;
        }
        n /= 10;
    }
    return 1;
}

/* Converts e.g. 101010 (decimal digits) to 42; returns -1 on invalid input */
long long binaryDigitsToDecimal(long long binaryForm) {
    long long value = 0;
    long long weight = 1;
    long long n = binaryForm;

    if (!is_binary_digit_form(binaryForm)) {
        return -1;
    }

    while (n > 0) {
        int digit = (int)(n % 10);
        value += (long long)digit * weight;
        n /= 10;
        weight *= 2;
    }

    return value;
}

int main(void) {
    long long binaryForm = 101010;
    long long dec = binaryDigitsToDecimal(binaryForm);

    if (dec < 0) {
        printf("Invalid binary digit pattern.\n");
        return 1;
    }

    printf("Binary (digit form): %lld\n", binaryForm);
    printf("Decimal: %lld\n", dec);
    return 0;
}

Explanation

The least significant decimal digit of 101010 is the least significant binary bit, so the first peeled digit pairs with weight 1, then 2, then 4, and so on.

weight *= 2;

Exact powers of two. Replaces pow(2, i) without floating point.

if (d > 1) return 0;

Reject invalid “binary” digits. A digit 2–9 must not be treated as a bit.

2

Horner’s method on a bit string

Natural when input arrives as text: scan most-significant bit first without reversing.

c
#include <stdio.h>

/* Returns -1 if s is NULL or contains non-binary characters */
long long binaryStringToDecimal(const char *s) {
    long long v = 0;

    if (s == NULL || *s == '\0') {
        return -1;
    }

    for (; *s != '\0'; ++s) {
        if (*s != '0' && *s != '1') {
            return -1;
        }
        v = v * 2 + (*s - '0');
    }

    return v;
}

int main(void) {
    const char bits[] = "101010";
    long long dec = binaryStringToDecimal(bits);

    if (dec < 0) {
        printf("Invalid binary string.\n");
        return 1;
    }

    printf("Binary (string): %s\n", bits);
    printf("Decimal: %lld\n", dec);
    return 0;
}

Explanation

Each step doubles the running value (shift left in binary) and adds the new bit.

v = v * 2 + (*s - '0');

Horner update. Equivalent to v = (v << 1) | bit for unsigned bit variables.

Optimization

Bit shifts. When you already have validated 0/1 ints, value |= (digit << i) or accumulate with shifts can replace multiply-add patterns.

Library path. For whole-string conversion, strtoull(s, NULL, 2) is standard if the input fits a C string and you accept library parsing rules.

Interview: explain both LSD peel and Horner; mention validation and overflow.

❓ FAQ

The classic classroom trick stores the bit pattern as a decimal integer whose digits are only 0 and 1. The code peels digits with % 10. In real C for literals, you can use 0b101010 (C23/C++14 style) or a string with strtol(..., 2) depending on your compiler and task.
Floating-point exponents can round incorrectly for large i. Integer doubling (multiply a running power of two by 2) or bit shifts for 0/1 digits keep the sum exact for typical sizes.
That is not a valid binary digit. The samples validate each peeled digit and return an error sentinel or status code so garbage digits are not treated as bits.
Scan left to right: start value 0, then for each character c, value = value * 2 + (c - '0'). That avoids reversing digits and matches how people read the string.
Yes. Many bits or a large accumulated decimal can exceed int or even long long. Widen types or check bounds for your problem constraints.
Proportional to the number of bits or digits: O(k) for k binary digits.

🔄 Input / output examples

Example 1 prints the digit-form value and decimal. Example 2 prints the string and decimal.

Input formMeaningDecimal
101010 (long long)Six-bit pattern42
"101010" stringSame pattern42
102Invalid digit 2Error / -1 in sample

Edge cases and pitfalls

Confusing the digit-stored integer with a binary literal is the main conceptual trap; invalid digits and overflow are the main engineering traps.

Meaning

101010 in source code

That token is a decimal integer unless you use a binary literal prefix supported by your compiler. The conversion routine interprets its decimal digits as bits.

Digits

Values outside {0,1}

Without validation, a digit like 9 would be treated as 9 · 2k in the peel loop—nonsense for binary.

Floats

pow(2, i)

Can mis-round for large i. Prefer integer doubling or exact shifts.

Length

Very long bit strings

Horner on long long overflows when the true value exceeds the type; use a big-integer approach or a wider type policy.

⏱️ Time and space complexity

ApproachTimeExtra space
Digit peel or Horner on k bitsO(k)O(1)

Both sample programs use only a few scalars besides input storage.

Summary

  • Math: sum of bi 2i for bits bi.
  • Code: digit peel with doubling weight, or Horner on a char string; avoid naive pow for exact integers.
  • Watch-outs: meaning of 101010 in C source, digit validation, overflow on long strings.
Did you know?

The pattern 101010 in base two means 32 + 8 + 2 = 42 in base ten. In the first C sample, that pattern is stored as the ordinary decimal integer 101010 so each base-ten digit is a binary bit; it is not the C binary literal 0b101010 (C99 and later).

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

9 people found this page helpful

C Program to find Biggest of three numbers C Program to find Common Divisors