C++ Decimal to Octal Conversion

Beginner
6 min read
Updated: Oct 2026
2 programs
Live preview
Definition

What Is Decimal to Octal Conversion?

Decimal (base 10) is the everyday number system. Octal (base 8) uses only digits 0–7. Conversion means rewriting a nonnegative integer using powers of eight instead of powers of ten.

Remember
Rightmost octal digit = 8⁰ (value 1)
Next digit             = 8¹ (value 8)
Next digit             = 8² (value 64)
…

Example: 57₁₀
  57 ÷ 8 → rem 1, then 7
  reverse → 71₈
  Check: 7×8 + 1 = 57
DecimalRemainders (LSD first)Octal
80, then 110
571, then 771
640, 0, then 1100
Approach

How to Convert Decimal to Octal in C++

Four clear steps — then pick a remainder loop or std::oct.

  1. Accept a nonnegative integer n.
  2. If n == 0, return "0" immediately.
  3. Collect digits with n % 8 and n /= 8, then reverse — or stream with std::oct.
  4. Print or return the octal string.
MethodIdeaTimeBest for
Remainder + reverseAppend n % 8, divide by 8, reverse digitsO(log n)Interviews, learning place values
std::octFormat n as base 8 via iostreamO(log n)Production code, short answers

Pseudocode

Pseudocode
function DecimalToOctal(n):          // n >= 0
    if n == 0:
        return "0"

    digits = []
    while n > 0:
        digits.append(n mod 8)       // LSD first
        n = floor(n / 8)

    reverse(digits)
    return join(digits)
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
Valid digitsOnly 0–7
Next digitn % 8
Shrink nn /= 8
OrderFirst remainder = rightmost digit
Built-inoss << std::oct << n
Binary link1 octal digit = 3 binary bits
Classic check57 → 71
Try it

Live Preview

Enter a nonnegative integer to see remainders and the octal result.

Whole numbers n ≥ 0 (capped at 999999999). Tap a chip or type a value.

Result
Decimal    = 57
Remainders = 1, 7  (LSD → MSD)
Octal      = 71
Check      = 7×8 + 1 = 57
Trace

Worked Walkthrough — n = 57

Divide by 8. Stack remainders from right to left, then reverse for the final string.

Calculation
57 ÷ 8 = 7 remainder 1   ← LSD (rightmost)
 7 ÷ 8 = 0 remainder 7   ← MSD (leftmost)

Remainders collected: 1, 7
Reverse for output:   7, 1
Octal:                71

Verify: 7×8¹ + 1×8⁰ = 56 + 1 = 57 ✓
Code

C++ Programs

Start with the remainder loop so you can explain every digit. Then use std::oct for a short production-style answer.

Example 1 — Remainder + Reverse

Collect n % 8 digits LSD-first, reverse them, then return the octal string.

C++
#include <iostream>
#include <string>
#include <algorithm>
#include <stdexcept>

std::string decimalToOctal(int n) {
    if (n < 0) {
        throw std::invalid_argument("Expected a nonnegative integer.");
    }

    if (n == 0) {
        return "0";
    }

    std::string digits;
    while (n > 0) {
        digits.push_back(static_cast<char>('0' + (n % 8)));
        n /= 8;
    }

    std::reverse(digits.begin(), digits.end());
    return digits;
}

int main() {
    std::cout << decimalToOctal(57) << "\n"; // 71
    std::cout << decimalToOctal(0) << "\n";  // 0
    std::cout << decimalToOctal(64) << "\n"; // 100
    return 0;
}

How It Works

  1. Reject negatives so the learning version stays focused on nonnegative conversion.
  2. Return "0" when n is zero — otherwise the loop would produce an empty string.
  3. While n > 0, append n % 8 (current LSD) and replace n with n / 8.
  4. std::reverse puts the most significant digit first.
  5. Return the string (for 57: remainders 1, 7 → reverse → "71").
Trace — 57
n = 57 → append 1, n = 7
n = 7  → append 7, n = 0

buffer = "17"
reverse → "71"

Example 2 — std::oct

Guard negatives, then let an iostream format the number as base 8.

C++
#include <iostream>
#include <sstream>
#include <string>
#include <stdexcept>

std::string decimalToOctal(int n) {
    if (n < 0) {
        throw std::invalid_argument("Expected a nonnegative integer.");
    }

    std::ostringstream oss;
    oss << std::oct << n;
    return oss.str();
}

int main() {
    std::cout << decimalToOctal(57) << "\n"; // 71
    std::cout << decimalToOctal(0) << "\n";  // 0
    std::cout << decimalToOctal(8) << "\n";  // 10

    // Bonus: same idea for binary via bitset or a manual loop
    std::cout << std::oct << 57 << "\n"; // 71
    return 0;
}

How It Works

  1. Reject negatives so the contract matches the remainder method.
  2. Open a string stream and insert std::oct before the value.
  3. Zero is handled for you — streaming 0 with std::oct returns "0".
  4. Optional check: octal 71 groups as three-bit chunks 111 001 in binary.
  5. Use the remainder loop in interviews; prefer std::oct in real projects.

Edge Cases & Pitfalls

Check these before calling the solution done.

Zero

Special-case 0

A plain while n > 0 loop prints nothing — return "0".

Order

Reverse remainders

Printing in collection order reverses the digits (57 would show as 17).

Negatives

Define a policy

This tutorial rejects negatives. Do not silently take an absolute value unless the problem says so.

Wrong base

Use % 8 and / 8

Copy-pasting a binary solution with % 2 produces binary, not octal.

Analysis

Time and Space Complexity

ProgramTimeExtra space
Remainder + reverseO(log n)O(log n)
std::oct streamO(log n)O(log n)

Digit count is about log8 n for positive n.

Remember

Key Takeaways

  • Core loop: take n % 8, then n /= 8, until n is 0.
  • Reverse: first remainder is the rightmost digit.
  • Two options: manual remainder loop, or std::oct.
  • Test set: 57 → 71; 64 → 100; 0 → 0.

One line: collect n % 8 remainders and reverse them — or stream with std::oct.

Frequently Asked Questions

Repeatedly take n % 8 (the next digit) and n /= 8 until n becomes 0, then reverse the digits. Or stream the value with std::oct.
The first remainder is the least significant digit. Reversing prints the usual left-to-right octal form.
A while n > 0 loop never runs, so return "0" before the loop (or use std::oct, which already prints 0).
It tells an iostream to format the next integer in base 8. For example, streaming 57 with std::oct prints 71.
One octal digit equals exactly three binary bits. Octal 7 is binary 111; octal 71 is binary 111001.
The remainder method produces O(log₈ n) digits, which is O(log n). Extra space for the digit buffer is also O(log n).

Next: Disarium Number

Check whether a number equals the sum of its digits raised to their positions.

Disarium number tutorial →

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)

10 people found this page helpful

C++ Decimal to Binary Conversion C++ Disarium Number Program