<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
        <title>Feature testing recommendations for C++</title>
        <style type="text/css">
                h1 h2 h3 h4 h5 h6
                {
                        page-break-after: avoid;
                }
                tr
                {
                        page-break-inside: avoid;
                }
                .editornote
                {
                        font-family: Cursive;
                        background-color: Yellow;
                }
        </style>
</head>
<body>
        <table border="1" summary="This table provides identifying information for this document.">
                <tr>
                        <th>Date:</th>
                        <td>2013-06-04</td>
                </tr>
                <tr>
                        <th>Reply to:</th>
                        <td>Clark Nelson</td>
                </tr>
                <tr>
                        <th>Title:</th>
                        <td>Feature testing recommendations for C++</td>
                </tr>
        </table>
        <h1>Feature testing recommendations for C++</h1>
        <h2>Contents</h2>
        <ol>
                <li><a href="#expl">Explanation and rationale for the approach</a> <ol>
                        <li><a href="#expl.prob">Problem statement</a></li>
                        <li><a href="#expl.soln">Characteristics of the proposed solution</a></li>
                </ol></li>
                <li><a href="#recs">Recommendations</a> <ol>
                        <li><a href="#recs.intro">Introduction</a></li>
                        <li><a href="#recs.cpp14">C++14 features</a></li>
                        <li><a href="#recs.cpp11">C++11 features</a></li>
                        <li><a href="#recs.condsupp">Conditionally-supported constructs</a></li>
                </ol></li>
        </ol>
        <h2 id="expl">Explanation and rationale for the approach</h2>
        <h3 id="expl.prob">Problem statement</h3>
        <p>The pace of innovation in the standardization of C++ makes long-term stability of
                implementations unlikely. Features are added to the language because programmers
                want to use those features. Features are added to (the working draft of) the standard
                as the features become well-specified. In many cases a feature is added to an implementation
                well before or well after the standard officially introducing it is approved.</p>
        <p>This process makes it difficult for programmers who want to use a feature to know
                whether it is available in any given implementation. Implementations rarely leap
                from one formal revision of the standard directly to the next; the implementation
                process generally proceeds by smaller steps. As a result, testing for a specific
                revision of the standard (e.g. by examining the value of the <code>__cplusplus</code>
                macro) often gives the wrong answer. Implementers generally don't want to appear
                to be claiming full conformance to a standard revision until all of its features
                are implemented. That leaves programmers with no portable way to determine which
                features are actually available to them.</p>
        <p>It is often possible for a program to determine, in a manner specific to a single
                implementation, what features are supported by that implementation; but the means
                are often poorly documented and ad hoc, and sometimes complex — especially
                when the availability of a feature is controlled by an invocation option. To make
                this determination for a variety of implementations in a single source base is complex
                and error-prone.</p>
        <h3><a id="expl.soln">Characteristics of the proposed solution</a></h3>
        <p>To preserve implementers' freedom to add features in the order that makes the most
                sense for themselves and their customers, implementers should indicate the availability
                of each separate feature by adding a definition of a macro with the name corresponding
                to that feature.</p>
        <p><strong>Important note:</strong> By recommending the use of these macros, WG21 is
                <strong>not</strong> making any feature optional; the absence of a definition for
                the relevant feature-test macro does not make an implementation that lacks a feature
                conform to a standard that requires the feature. However, if implementers and programmers
                follow these recommendations, portability of code between real-world implementations
                should be improved.</p>
        <p>To a first approximation, a feature is identified by the WG21 paper in which it is
                specified, and by which it is introduced into the working draft of the standard.
                Not every paper introduces a new feature worth a feature-test macro, but every paper
                that is not just a collection of issue resolutions is considered a candidate; exceptions
                are explicitly justified.</p>
        <p>For C++14, it is preferred for the feature-test macro to be named using some combination
                of words from the title of the paper. In the future, it is hoped that every paper
                will include its own recommendations concerning feature-test macro names.</p>
        <p>The value specified for a feature-test macro is based on the month in which the feature
                is voted into the working draft. In a case where a feature is subsequently changed
                in a significant way, but arguably remains the same feature, the value of the macro
                can be changed to indicate the “revision level” of the specification
                of the feature. However, in most cases it is expected that the presence of a feature
                can be determined by the presence of any non-zero macro value; for example:</p>
        <pre>#if __cpp_binary_literals
int const packed_zero_to_three = 0b00011011;
#else
int const packed_zero_to_three = 0x1B;
#endif</pre>
        <p><em>Note: There are cases where the decision between adding a new macro and changing
                the value of an existing macro will be subjective; <code>constexpr</code> is a good
                example.</em></p>
        <p>To avoid the user's namespace, names of macros for language features are prefixed
                by “<code>__cpp_</code>”; for library features, by “<code>__cpp_lib_</code>”.
                A library feature that doesn't introduce a new header is expected to be defined
                by the header(s) that implement the feature.</p>
        <p><em>Note: Whether macros for language features and new library headers should be
                specified as predefined or defined in a new header is still under discussion.</em></p>
        <h2><a id="recs">Recommendations</a></h2>
        <h3><a id="recs.intro">Introduction</a></h3>
        <p>For the sake of improved portability between partial implementations of various C++
                standards, WG21 (the ISO technical committee for the C++ programming language) recommends
                that implementers and programmers follow the guidelines in this document concerning
                feature-test macros.</p>
        <p>Implementers who provide a new feature should define a macro with the recommended
                name, in the same circumstances under which the feature is available (for example,
                taking into account relevant command-line options), to indicate the presence of
                support for that feature.</p>
        <p>Programmers who wish to determine whether a feature is available in an implementation
                should base that determination on the state of the macro with the recommended name.
                (The absence of a tested feature may result in a program with decreased functionality,
                or the relevant functionality may be provided in a different way. A program that
                strictly depends on support for a feature can just try to use the feature unconditionally;
                on an implementation lacking necessary support, translation will presumably fail.)</p>
        <h3><a id="recs.cpp14">C++14 features</a></h3>
        <p>The following table itemizes all the changes that were made to the working draft
                for C++14 as specified in a WG21 technical document. (Changes that were made as
                specified in a core or library issue are not included.) The table is sorted by the
                section of the standard primarily affected.</p>
        <table border="1">
                <thead>
                        <tr>
                                <th colspan="6">Significant changes to C++14</th>
                        </tr>
                        <tr>
                                <th>Doc. No.</th>
                                <th>Title</th>
                                <th>Primary Section</th>
                                <th>Macro name<br />
                                        <span class="editornote">Singular vs. plural consistency</span></th>
                                <th>Value</th>
                                <th>Header</th>
                        </tr>
                </thead>
                <tbody>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf">N3472</a>
                                </td>
                                <td>Binary Literals in the C++ Core Language</td>
                                <td>2.14</td>
                                <td><code>__cpp_binary_literals</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3323.pdf">N3323</a>
                                </td>
                                <td>A Proposal to Tweak Certain C++ Contextual Conversions</td>
                                <td>4</td>
                                <td><code>__cpp_contextual_conversions</code></td>
                                <td>201210</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3648.html">N3648</a>
                                </td>
                                <!--feedback-->
                                <td>Wording Changes for Generalized Lambda-capture</td>
                                <td>5.1</td>
                                <td><code>__cpp_generalized_capture</code><br />
                                        <code>__cpp_init_capture</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3649.html">N3649</a>
                                </td>
                                <!--feedback-->
                                <td>Generic (Polymorphic) Lambda Expressions</td>
                                <td>5.1</td>
                                <td><code>__cpp_generic_lambda</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3664.html">N3664</a>
                                </td>
                                <td>Clarifying Memory Allocation</td>
                                <td>5.3</td>
                                <td colspan="3"><em>Relaxation of a restriction on implementations, not a new feature;
                                        no macro needed.</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3624.html">N3624</a>
                                </td>
                                <td>Core Issue 1512: Pointer comparison vs qualification conversions</td>
                                <td>5.9, 5.10</td>
                                <td colspan="3"><em>Core issue fix, not a feature; no macro needed</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html">N3652</a>
                                </td>
                                <td>Relaxing constraints on constexpr functions / constexpr member functions and implicit
                                        const</td>
                                <td>5.19, 7.1</td>
                                <td><code>__cpp_relaxed_constexpr</code><br />
                                        <code>__cpp_constexpr_iteration</code><br />
                                        <code>__cpp_constexpr_2014</code><br />
                                        <code>__cpp_constexpr</code> </td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td rowspan="2"><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3638.html">
                                        N3638</a></td>
                                <!--feedback-->
                                <td rowspan="2">Return type deduction for normal functions</td>
                                <td rowspan="2">7.1</td>
                                <td><code>__cpp_decltype_auto</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><code>__cpp_return_type_deduction</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3639.html">N3639</a>
                                </td>
                                <td>Runtime-sized arrays with automatic storage duration</td>
                                <td>8.3</td>
                                <td><code>__cpp_runtime_array</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3653.html">N3653</a>
                                </td>
                                <td>Member initializers and aggregates</td>
                                <td>8.5</td>
                                <td><code>__cpp_aggregate_nsdmi</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3667.html">N3667</a>
                                </td>
                                <td>Drafting for Core 1402</td>
                                <td>12.8</td>
                                <td colspan="3"><em>Core issue fix, not a feature; no macro needed</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3651.pdf">N3651</a>
                                </td>
                                <td>Variable Templates</td>
                                <td>14, 14.7</td>
                                <td><code>__cpp_variable_templates</code></td>
                                <td>201304</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3669.pdf">N3669</a>
                                </td>
                                <td>Fixing constexpr member functions without const</td>
                                <td><em>various</em></td>
                                <td colspan="3"><em>Library fix, not a feature; no macro needed</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3673.html">N3673</a>
                                </td>
                                <td>C++ Library Working Group Ready Issues Bristol 2013</td>
                                <td><em>various</em></td>
                                <td colspan="3"><em>Library issue fixes, not a feature; no macro needed</em></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">N3471</a>
                                </td>
                                <td>Constexpr Library Additions: utilities</td>
                                <td>20.2-20.4</td>
                                <td rowspan="3"><code>__cpp_lib_constexpr_functions</code></td>
                                <td rowspan="3">201210</td>
                                <td><code><utility></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3469.html">N3469</a>
                                </td>
                                <td>Constexpr Library Additions: chrono</td>
                                <td>20.11</td>
                                <td><code><chrono></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3470.html">N3470</a>
                                </td>
                                <td>Constexpr Library Additions: containers</td>
                                <td>23.3</td>
                                <td><code><array></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html">N3658</a>
                                </td>
                                <!--feedback-->
                                <td>Compile-time integer sequences</td>
                                <td>20</td>
                                <td><code>__cpp_lib_integer_sequence</code></td>
                                <td>201304</td>
                                <td><code><utility></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html">N3668</a>
                                </td>
                                <!--feedback-->
                                <td>exchange() utility function</td>
                                <td>20</td>
                                <td><code>__cpp_lib_exchange_function</code></td>
                                <td>201304</td>
                                <td><code><utility></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3670.html">N3670</a>
                                </td>
                                <td>Wording for Addressing Tuples by Type</td>
                                <td>20.2-20.4</td>
                                <td><code>__cpp_lib_tuples_by_type</code></td>
                                <td>201304</td>
                                <td><code><utility></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3672.html">N3672</a>
                                </td>
                                <td>A proposal to add a utility class to represent optional objects</td>
                                <td>20.5</td>
                                <td><code>__cpp_lib_header_optional</code></td>
                                <td>201304</td>
                                <td><em>predefined</em><br />
                                        <span class="editornote">How to handle new headers?</span></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm">N3656</a>
                                </td>
                                <!--feedback-->
                                <td>make_unique</td>
                                <td>20.7</td>
                                <td><code>__cpp_lib_make_unique</code></td>
                                <td>201304</td>
                                <td><code><memory></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm">N3421</a>
                                </td>
                                <!--feedback-->
                                <td>Making Operator Functors greater<></td>
                                <td>20.8</td>
                                <td><code>__cpp_lib_operator_functors</code><br />
                                        <code>__cpp_lib_transparent_operators</code> </td>
                                <td>201210</td>
                                <td><code><functional></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3462.html">N3462</a>
                                </td>
                                <!--feedback-->
                                <td>std::result_of and SFINAE</td>
                                <td>20.9</td>
                                <td><code>__cpp_lib_result_of_sfinae</code></td>
                                <td>201210</td>
                                <td><code><functional></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3545.pdf">N3545</a>
                                </td>
                                <td>An Incremental Improvement to integral_constant</td>
                                <td>20.9</td>
                                <td><code>__cpp_lib_improved_integral_constant</code></td>
                                <td>201304</td>
                                <td><code><type_traits></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf">N3655</a>
                                </td>
                                <td>TransformationTraits Redux</td>
                                <td>20.9</td>
                                <td><code>__cpp_lib_transformation_trait_aliases</code></td>
                                <td>201304</td>
                                <td><code><type_traits></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3642.pdf">N3642</a>
                                </td>
                                <td>User-defined Literals for Standard Library Types</td>
                                <td>20.11, 21.7</td>
                                <td><code>__cpp_lib_type_udls</code></td>
                                <td>201304</td>
                                <td><code><string></code><br />
                                        <code><chrono></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3662.html">N3662</a>
                                </td>
                                <!--feedback-->
                                <td>C++ Dynamic Arrays</td>
                                <td>23.2, 23.3</td>
                                <td><code>__cpp_lib_header_dynarray</code></td>
                                <td>201304</td>
                                <td><em>predefined</em><br />
                                        <span class="editornote">How to handle new headers?</span></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3657.htm">N3657</a>
                                </td>
                                <!--feedback-->
                                <td>Adding heterogeneous comparison lookup to associative containers</td>
                                <td>23.4</td>
                                <td><code>__cpp_lib_heterogeneous_comparison</code><br />
                                        <code>__cpp_lib_generic_associative_lookup</code> </td>
                                <td>201304</td>
                                <td><code><map></code><br />
                                        <code><set></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3644.pdf">N3644</a>
                                </td>
                                <!--feedback-->
                                <td>Null Forward Iterators</td>
                                <td>24.2</td>
                                <td><code>__cpp_lib_null_iterators</code></td>
                                <td>201304</td>
                                <td><code><iterator></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3671.html">N3671</a>
                                </td>
                                <td>Making non-modifying sequence operations more robust</td>
                                <td>25.2</td>
                                <td><code>__cpp_lib_robust_sequences</code><br />
                                        <span class="editornote">Is this name optimal?</span> </td>
                                <td>201304</td>
                                <td><code><algorithm></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3654.html">N3654</a>
                                </td>
                                <td>Quoted Strings Library Proposal</td>
                                <td>27.7</td>
                                <td><code>__cpp_lib_quoted_string_io</code></td>
                                <td>201304</td>
                                <td><code><iomanip></code></td>
                        </tr>
                        <tr>
                                <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3659.html">N3659</a>
                                </td>
                                <td>Shared locking in C++</td>
                                <td>30.4</td>
                                <td><code>__cpp_lib_shared_locking</code></td>
                                <td>201304</td>
                                <td><code><mutex></code></td>
                        </tr>
                </tbody>
        </table>
        <h3><a id="recs.cpp11">C++11 features</a></h3>
        <p>This table is not intended to be formally complete; it is intended only to cover
                variations of current (as of 2013) commercial importance.</p>
        <table border="1">
                <thead>
                        <tr>
                                <th colspan="6">Significant features of C++11</th>
                        </tr>
                        <tr>
                                <th>Doc. No.</th>
                                <th>Title</th>
                                <th>Primary Section</th>
                                <th>Macro name</th>
                                <th>Value</th>
                                <th>Header</th>
                        </tr>
                </thead>
                <tbody>
                        <tr>
                                <td>N2249</td>
                                <td>New Character Types in C++</td>
                                <td>2.13</td>
                                <td><code>__cpp_new_character_types</code></td>
                                <td>200704</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td rowspan="2">N2442</td>
                                <td rowspan="2">Raw and Unicode String Literals Unified Proposal</td>
                                <td rowspan="2">2.13</td>
                                <td><code>__cpp_raw_literals</code><br />
                                        <code>__cpp_raw_strings</code></td>
                                <td>200710</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td><code>__cpp_unicode_literals</code><br />
                                        <code>__cpp_unicode_strings</code></td>
                                <td>200710</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2765</td>
                                <td>User-defined Literals</td>
                                <td>2.13, 13.5</td>
                                <td><code>__cpp_user_defined_literals</code></td>
                                <td>200809</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2235</td>
                                <td>Generalized Constant Expressions</td>
                                <td>5.19, 7.1</td>
                                <td><code>__cpp_generalized_constant</code><br />
                                        <code>__cpp_constexpr</code></td>
                                <td>200704</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2343</td>
                                <td>Decltype</td>
                                <td>7.1</td>
                                <td><code>__cpp_decltype</code></td>
                                <td>200707</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2761</td>
                                <td>Towards support for attributes in C++</td>
                                <td>7.6</td>
                                <td><code>__cpp_attributes</code></td>
                                <td>200809</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2118</td>
                                <td>A Proposal to Add an Rvalue Reference to the C++ Language</td>
                                <td>8.3</td>
                                <td><code>__cpp_rvalue_reference</code></td>
                                <td>200610</td>
                                <td><em>predefined</em></td>
                        </tr>
                        <tr>
                                <td>N2242</td>
                                <td>Proposed Wording for Variadic Templates</td>
                                <td>8.3, 14</td>
                                <td><code>__cpp_variadic_templates</code></td>
                                <td>200704</td>
                                <td><em>predefined</em></td>
                        </tr>
                </tbody>
        </table>
        <h3 id="recs.condsupp">Conditionally-supported constructs</h3>
        <p>The standard requires implementations to document the conditionally-supported constructs
                it does <strong>not</strong> support. For consistency, the recommendation is to
                define a macro for each conditionally-supported construct that is diagnosed (not
                supported)</p>
        <table border="1">
                <thead>
                        <tr>
                                <th>Reference</th>
                                <th>Description</th>
                                <th>Macro name</th>
                        </tr>
                </thead>
                <tbody>
                        <tr>
                                <td>2.9p2</td>
                                <td>The appearance of either of the characters <code>’</code> or <code>\</code> or of
                                        either of the character sequences <code>/*</code> or <code>//</code> in a <var>q-char-sequence</var>
                                        or an <var>h-char-sequence</var> is conditionally supported with implementation-defined
                                        semantics, as is the appearance of the character <code>"</code> in an <var>h-char-sequence</var>.
                                </td>
                                <td><code>__cond_no_weird_header_names</code></td>
                        </tr>
                        <tr>
                                <td>2.14.3p1</td>
                                <td>A multicharacter literal, or an ordinary character literal containing a single <var>
                                        c-char</var> not representable in the execution character set, is conditionally-supported,
                                        has type <code>int</code>, and has an implementation-defined value. </td>
                                <td><code>__cond_no_multicharacter_literals</code></td>
                        </tr>
                        <tr>
                                <td>2.14.3p3</td>
                                <td>Escape sequences in which the character following the backslash is not listed in
                                        Table 7 are conditionally-supported, with implementation-defined semantics.</td>
                                <td><em>Probably no single macro would make sense for this.</em></td>
                        </tr>
                        <tr>
                                <td>2.14.5p13</td>
                                <td>Any other concatenations are conditionally supported with implementation-defined
                                        behavior.</td>
                                <td><em>Probably no single macro would make sense for this.</em></td>
                        </tr>
                        <tr>
                                <td>5.2.2p7</td>
                                <td>Passing a potentially-evaluated argument of class type (Clause 9) having a nontrivial
                                        copy constructor, a non-trivial move constructor, or a non-trivial destructor, with
                                        no corresponding parameter, is conditionally-supported with implementation-defined
                                        semantics.</td>
                                <td><code>__cond_no_passing_non_pod_by_ellipsis</code></td>
                        </tr>
                        <tr>
                                <td>5.2.10p8</td>
                                <td>Converting a function pointer to an object pointer type or vice versa is conditionally-supported.
                                </td>
                                <td><code>__cond_no_fun_obj_ptr_conversion</code></td>
                        </tr>
                        <tr>
                                <td>7.4p1</td>
                                <td>The asm declaration is conditionally-supported; its meaning is implementation-defined.
                                </td>
                                <td><code>__cond_no_asm_declaration</code></td>
                        </tr>
                        <tr>
                                <td>7.5p2</td>
                                <td>Use of a <var>string-literal</var> other than <code>"C"</code> or <code>"C++"</code>
                                        is conditionally-supported, with implementation-defined semantics.</td>
                                <td><em>Probably no single macro would make sense for this.</em></td>
                        </tr>
                        <tr>
                                <td>7.6.1p3</td>
                                <td>The use of an <var>attribute-scoped-token</var> is conditionally-supported, with
                                        implementation-defined behavior.</td>
                                <td><code>_cond_no_attribute_scoped_token</code></td>
                        </tr>
                        <tr>
                                <td>14p4</td>
                                <td>Use of a linkage specification other than C or C++ with any of these constructs
                                        is conditionally-supported, with implementation-defined semantics.</td>
                                <td><code>_cond_no_template_linkage_spec</code></td>
                        </tr>
                </tbody>
        </table>
</body>
</html>