C++14 seems to be coming and compilers are already trying to implement the core features of this new revision. I was having a look at GCC support for these core features and noticed something about the binary literals part: GCC implements them but seems to make a difference between GNU binary literals and C++14 binary literals. Here are the respective references for both:
- GNU binary literals
- C++1y binary literals
I tried to find some differences between the two of them since GCC seems to make the difference, but could not find anything. Does any of you know more about possible incompatibilities?
From the commit diff which introduced support in gcc 4.9, the only difference is that gcc now accepts binary literals as a language feature of C++1y, and doesn't warn that they're a gcc extension if C++1y support is specified. There is no change to the actual implementation.
Previously:
warning : binary constants are a GCC extension
Now, unless -std=c++1y is specified:
warning : binary constants are a C..1y feature or GCC extension
I'm guessing that the difference is since one is an extension, then people wouldn't be too inclined to use it while the other is standard compliant and accessible without turning on extensions. It's a formality.
The first document you point to is the GNU implementation of binary literals as an extension to the C language (ie, it is a non-standard feature of C and that document defines how gcc implements an extension to the language).
The second document you point to is a proposal to add binary literals to the C++11 language, but as far as I know it has not been accepted either (*) and that means it's not part of standard C++ either, it remains as a language extension provided by gcc.
As far as I can see this feature would be non-portable across compilers, but you could define your own binary literal implementation in C++11 by using user defined literals.
(*) s/not accepted/I can't find any reference to binary literals in N3485 "Working Draft, Standard for Programming Language C++", but it might be a feature accepted for the next standard of C++.
