SG10 is a working group for C++ users to try and figure out how to port between C++11 and C++14. It’s part of the ISO C++ standardization plan for post-C++11 work.
SG 10 first met in Bristol, United Kingdom during the spring of 2013. There have been two teleconfences, and an archived mailing list has been set up for discussion.
The goal is to have some consensus for an approach that vendors can use as C++14 is implemented. In particular, draft recommendations are due prior to the start of the Chicago meeting starting on August 23, 2013.
Below is a summary of the macro interface for relevant languages (C and C++), operating systems (), and notable implementations (GNU, EDG, Clang, Boost).
6.10.8 Predefined macro names
220.127.116.11 Mandatory macros
18.104.22.168 Environment macros
__STDC_UTF_16__ (char16_t types are UTF-16 encoded)
__STDC_UTF_32__ (char32_t types are UTF-32 encoded)
22.214.171.124 Conditional feature macros
__STDC_ANALYZABLE__ (1 iff conforms to Annex L)
__STDC_IEC_559__ (1 iff IEC 60559 floating point)
__STDC_IEC_559_COMPLEX__ (1 iff IEC 60559 complex)
__STDC_LIB_EXT1__ (201ymmL Annex K, bounds checking interfaces)
__STDC_NO_ATOMICS__ (1 iff no atomics)
__STDC_NO_COMPLEX__ (1 iff no complex.h types)
__STDC_NO_THREADS__ (1 iff no threads)
__STDC_NO_VLA__ (1 if no VLA)
See the unistd.h include file.
2.1.3 POSIX Conformance
_POSIX_VERSION (200809L iff all mandatory functions and headers)
Defined with value > 1:
_POSIX_NO_TRUNC (!-1, pathnames smaller than NAME_MAX ok)
Defined with value = 200809L
Defined with a value > 0
Defined optionally (-1 means no, 0 maybe, >0 means yes)
User defined to specify version
As of the post-C++11 draft standard, N3485, the current lay of the land is divided into:
16.8 Predefined macro names [cpp.predefined]
__DATE__ ("Mmm dd yyy")
__STDC_HOSTED__ (1 iff hosted, 0 iff freestanding)
__STDCPP_STRICT_POINTER_SAFETY__ (1 iff string pointer safety as per 126.96.36.199)
__STDCPP_THREADS__ (1 iff more than single thread supported)
Some other notable implementation interfaces follow.
From “The C Preprocessor” manual, section 3.7 on Predefined Macros.
__OPTIMIZE__ (iff -On, where n > 0)
__NO_INLINE__ (if -finline)
__SIZE_TYPE__ + others (correct underlying type)
__SIZEOF_INT__ + others (size of type)
__EXCEPTIONS (if -fexceptions)
__GXX_WEAK (1 if comdat, weak supported)
__GXX_RTTI (if -frtti)
__STRICT_ANSI__ (no GNU extensions)
See Feature Checking Macros. Uses a generalized mechanism via “builtin function-like” macros.
Proposed Language Predefines
The plan is to start with new language features, and to offer several modular macros that sub-divide the C++2014 feature set, while retaining a relationship with the main versioning macro (__cplusplus).
In addition, there is much interest in a solution that could be used to resolve some of the lingering portability issues with C++2011 (constexpr, variadic templates), and even C++2003 (exceptions, RTTI).
Starting with proposed C++11/14 language features, add predefined macros of the form:
__cpp + language feature
So, for constexpr, the macro becomes:
The value is determined to be:
1) if C++11 constexpr is not supported, __cpp_constexpr < 201103L
2) if C++11 constexpr is supported, __cpp_constexpr >= 201103L
3) if C++14 constexpr is supported, __cpp_constexpr > 201103L
In the last case, there is a bit of ambiguity. How do you distinguish between a C++11 conformant compiler, an experimental C++14 compiler of a particular vintage, and a C++14 conformant compiler?
One way would be to use the same form used by __cplusplus. This macro value is computed from the year + month of the standard’s adoption by ISO. In a similar manner, pre-standard features could be defined as the year + month that the feature was voted into the working C++ draft.
Take the evolution of constexpr, as a useful for-instance. Using
Set it to the following values based on different language dialect flags, and compare to the primary C++ macro, __cplusplus.
|pre-c++14 with N3302/N3470/3469/3471 lib changes
|pre-c++14 with above + N3652 (relaxed) language changes
Proposed Library Defines
Starting with proposed C++11/14 library features, add macros of the form:
__cpp_lib_ + header name
So, for C++11 , the macro becomes:
The value is determined to be:
1) if C++11 futures is not supported, __cpp_lib_futures < 201103L
2) if C++11 futures is supported, __cpp_lib_futures >= 201103L
3) if C++14 futures is supported, __cpp_lib_futures > 201103L
This would require library implementors to create a header file with this macro definition. (As opposed to not having the header, or pre-defining this macro, or having the library feature testing macros live in one particular header.)
Guarding for C++11 constexpr:
#if __cplusplus_constexpr >= 201103L
constexpr int i = 66;
Guarding for C++14 relaxed constexpr, given C++11 assumed.
#if __cplusplus_constexpr >= 201304L
constexpr int h(int k)
int x = incr(k);
1. Macro conventions.
The macro naming convention, the numbers of macros, type, form, etc. are all up for debate.
Some consensus on:
a. Against function-style macros in the committee, but no explicit rationale for this.
b. The prefix with the most support is: __cpp_.
c. Language feature macros should be pre-defined and not tied to a particular header.
2. What about feature testing in older versions of C++?
In the C++11 standard, two new macros were added, proto feature-testing macros. These macros may establish a naming precedent.
If the committee feels like this is not precedent, and that new functionality means new name, than hopefully these will be incorporated this into whatever naming scheme is now proposed, and the C++11 forms deprecated.
3. Longest-standing feature-testing portability wart is from 1997, starting with the language features exceptions and run-time type identification.
Solving generalized feature testing in a manner simpatico with the both older and newer language features is highly desirable. Some background on GNU issues with this is PR 25191.
4. How do individual feature tests fit in with the global version macro for C++ (__cplusplus)?
Right now, there’s only one real macro, so everything depends on it. But when there are more, how do the multiple feature test macros interact with __cplusplus? Is there a general way to indicate that there is a compiler setting or command line flag that has explicitly disabled parts of the specified language dialect?
No, there is not. Should there be just one, or should a bunch of smaller macros also be checked?
Surveying a couple compilers for standard operating procedures, it seems as if the usual behavior is to treat the command line dialect flag as the base language target, rather than indicating full or strict conformance.
Then, strict language conformance is available via specific command-line flags (-ansi, or -std=c++98), and defines __STRICT_ANSI__ or another equivalent macro.
So, distinguishing between some vendor extensions and strict standard conformance is possible at compile time.
But disabling whole chunks of the regularly-supported language, like specific builtin types or language features, doesn’t distinguish itself in the same manner at compile time. .
For instance, in the C++11 dialect, gnu/clang/edg front ends set __cplusplus to 201103L. Even when language features required for full conformance, like exceptions or long long integers, are explicitly disabled.
The C language has the idea of a pre-defined macro that indicates conformance (__STDC__), and separates out dialect (__STDC_VERSION__). In practice, __STDC__ may indicate conformance + extensions, or explicitly non-conformant behavior. So, not especially useful.
In C++ these macros are explicitly implementation-defined, so even less useful.
Posix has a runtime test that can be used to determine functionality, ie sysconf.
5. What about multi-vendor setups hosted on a single operating system?