How to write an octal floating point literal in C++?

Question

Somehow i have always assumed that floating point and integer values are processed the same except one would have a '.' character.

So for the code like this:

auto i = 0100;
std::cout << i;

I get the expected output 64;

However, when i try the following code:

auto d = 0100.0;
std::cout << d;

I get output 100, which is not what was expected. Now it is possible that the floating point part does not deal with a leading 0. So i have attempted something which really should have worked:

auto d = 1.0e-010;
std::cout << d;

Since exponent is actually an integer value itself, it made sense that it would understand the octal value, but the output was 1e-10.

Is this an issue that comes from the standard or from g++ (my compiler)? How would i go about writing an octal floating point number?

Hexadecimal seem to behave differently:

auto d = 0x100.0;

Gives error: hexadecimal floating constants require an exponent

However:

auto d = 0x1e3;
std::cout << d;

produces 483. While

auto d = 0x1e0x3;

Gives error: unable to find numeric literal operator ‘operator"" x3’

What have you tried (besides this)? Where did you get stuck? What did you research? — Steven Hansen, Sep 17 '15 at 08:29
Seriously? Why on earth do you want an octal floating point literal? — Karoly Horvath, Sep 17 '15 at 08:58
I think it's a perfectly legitimate question. I was just curious. — Karoly Horvath, Sep 17 '15 at 09:19
@KarolyHorvath Sorry for overreaction. I have no *need* for it, that is immediate. Am trying to expand my knowledge of some aspects of the language. — v010dya, Sep 17 '15 at 10:22
We are talking here about a language that you can study for a decade and you'll still have plenty of dark corners left in it... Why don't you study something you actually *need*? — Karoly Horvath, Sep 17 '15 at 11:27
@KarolyHorvath one studies what one is interested in. There may be nothing one needs at the moment, so why not study interesting things? — Ruslan, Apr 14 '16 at 07:43

score 4 · Answer 1 · edited May 23 '17 at 10:28

Floating point literals cannot be written in octal in C++. You'll have to settle for decimal.

Standard C++ doesn't allow hexadecimal floating point literals either. However, C does (since C99) and compilers supporting it may allow hexadecimal in C++ too as an extension to the language.

Hexadecimal seem to behave differently

Yes. Refer to this answer for details on how to write hexadecimal floating point literals.

blojayble · Answer 2 · 2015-09-17T13:11:26.750

You could make one yourself using C++11's user defined literals.

#include <iostream>
#include <cmath>
using namespace std;

long double operator"" _oct (long double oct)
{
    int i = 0;
    long double rem, fract, decimal = 0.0;
    long whole = (long)oct;
    fract = oct - whole;

    // whole part
    while (whole != 0)
    {
        rem = fmod(whole,10);
        whole/=10;
        decimal += rem*pow(8,i++);
    }
    i = 1; 
    // fractional part
    while(fract != 0){
        fract *= 10;
        rem = round(fract);
        decimal += rem*pow(8,-i++);
        fract -= rem;
    }
    return decimal;
}

int main() {
    cout << 10.1_oct; //8.125
    return 0;
}

score 1 · Accepted Answer · edited May 23 '17 at 12:31

user2079303 and blojayble have both given excellent answers, however, both were a bit incomplete. So here is expansion on both of them and additional information which was found.

There are no octal floating point numbers in C++… for a reason

The standard does not define octal floating point numbers, and compilers obey this particular rule to the letter. Leading 0 is read as just another decimal digit in the whole part or in the exponent.

Potential reason for this is the ambiguity of the number like 0.2. Most people would mean by this ⅕; while if octal floating point numbers were a reality it would be ¼ for the same reason why 0 is an octal literal (see here).

There are no hexadecimal floating point numbers in C++, but…

…, but there are in C. So many compilers allow one to use them, but they are a bit weird.

Firstly, they do not work without an exponent part. So writing 0x12a.b3 will likely not work.

Secondly, in hexadecimal notation e is not an exponent, since it's a digit 14. Therefore, p is used (probably meaning something like "power").

Thirdly, the exponent is hexadecimal is not 10 (of course), but it is not 16 (for some reason). Rather it is 2. So 0x12.4p3 becomes ( 1×16¹ + 2×16⁰ + 4×16⁻¹ ) × 2³ = ( 16 + 2 + ¼ ) × 8 = 146.

It is relatively trivial to define own literals in C++11

blojayble has provided own realisation, but i thought that it would be best to redo it making it into a constexpr. The end result is the following code:

constexpr unsigned long long operator"" _oct(unsigned long long l)
{
    return
        (l < 9) ? l :
        operator"" _oct(l/10)*8 + l%10;
}
constexpr long double operator"" _oct(long double d)
{
    return
        (d == 0) ? 0.0 :
        (d < 1) ? 0.125*(((int)(d*10)) + operator"" _oct(d*10-((int)(d*10)))) :
        operator"" _oct((unsigned long long)d) + operator"" _oct(d-(unsigned long long)d);
}

How to write an octal floating point literal in C++?

3 Answers3