Wiki

Clone wiki

YSLib / StandardUsing.en-US

Introduction

This page specifies the language features from the standard shall be used in this project, by introducing several rules and then clearifying which features are applied to the project from specific project build revision and time.

Unless otherwise specified, date is in UTC+8.

Notation

"NOTE" indicates note for maintainers and it is not directly from the source of the concerned contents.

Some external materials are referenced here by links in several categories. Entries in same category are listed ordinally specified by documentation number (if any). Since only adopted revisions are applied, most superseded reversions are placed together.

Links may be noted with following tags:

  • "dropped" indicating abandoned in development
  • "see" pointing to revised revision
  • "see also" for related materials
  • "see other derivation" pointing to siblings
  • "see subsequent" pointing to subsequent new series
  • "since" with initial project build revision and time of applying

Basic rules

The Forwarding Compatibility Rule: All language features incompatible with published/normative future versions of the language specification shall not be used.

The Baseline Implementation Rule: Each feature being used shall have been implemented in general available version of at least 2 FOSS implementations.

General status

The default configuration, baseline, is specified here. The features explicitly introduced to clearify dependences on the language implementations are also listed in this and following sections.

Several C++0x features are used since 2011-05-03, build 206. These features are also in ISO C++11(ISO/IEC 14882:2011). Previously C++03 with TR1(ISO/IEC TR 19768:2007) was used.

Baseline

C++11 is now default to conform.

As per the forwarding compatibility rules, all C++03 features conflicted with future versions of C++ (e.g. export) are forbidden.

TR1 features are avoided and have been substituted by their C++11 counterparts.

Replacements

Several standard features and features in technical specifications beyond C++11 is not directly relied on, but YBase provides some replacements (possibly with some custom extensions). This is specified as conditionally below.

The considered and (possibly incompletely) reviewed technical specifications beyond C++11 are:

  • ISO/IEC TS 19568:2015 Programming Languages — C++ Extensions for Library Fundamentals

(See here for information about adoption in C++17.)

Exceptions

As complement of implementations, LibDefect in YBase may have implementation-specific contents intended only for internal use and guarded by conditional inclusion. The public headers shall be capable for direct use with any implementation meeting the requirements specified by the YSLib documentation (including following sections).

Evolution

For compatibility, the project may use different sets of rules in each parts. YBase is more stable and conservative to utilize new C++ features.

Longterm policy

  • ydef.h: For compatibility reasons, only a subset of C++11 would be mandated. The precise subset is unspecified and can vary between revisions.
  • YBase except LibDefect discussed above: Library features beyond C++11 would be used only available.
  • Other parts of the YSLib project: C++ features would be used aggressively (but still restrictd by the rules here, esp. the basic rules).

Core language compatibility features

Some core language feature have be fallback in C++03 (e.g. constexpr) or library (e.g. alignof), mostly workaround in ydef.h, as well as some optional extensions (e.g. __has_feature and __builtin_expect) wrapped as implementation details.

Library implementation patches

Due to limitations of specific environments, some standard library features might be not usable without alternative implementations. They may be enabled by using additional headers in the module YBase.LibDefect instead of the corresponding standard headers.

As patches, the code in YBase.LibDefect is highly implementation-specific. It has significant differences (which may cause undefined behavior without further guarantees) to the usual library and user code:

  • It can be directly intrusive to the global namespace, namespace std and other implementation-specific namespaces, which may be reserved by the standard.
  • As part of the standard library implementation, it may use names reserved by the standard.

The code has been carefully tuned to be compatible to supported environments, to keep out undefined behavior merely caused by this implementation.

Library compatibility features

To reduce impact on user code to adopt new language standards, several post-C++03 library features are implementated in namespace ystdex (with inlined namespace if the features have been in published standards) in module YBase.YStandardEx, either by using declarations from namespace std iff. provided by the standard library, or being implemented from scratch when the features are not available from the standard library (not the library implementation, i.e. implementation-specific interface are still forbidden).

They are designed to be drop-in replacements of corresponding specific version of std or std::experimental interface, with a few exceptions:

  • Except for some specialization of standard library templates, the enclosing namespace is not std so name lookup may behave differently to the standard library interface.
    • Use additional 'using ystdex::NAME;' to enable ADL(argument dependent lookup) for NAME.
    • Note [global.functions]/4 is still conforming similarly. Any ADL beyond namespace ystdex shall be specified by the interface documentation.
  • The overloaded operators may be implemented by ADL-only manner, i.e. declared as friend functions, rather than namespace scope entities.
    • Currently no entities are declared in this manner except for interface are ready for upcoming post-C++14 standard library features.
  • It is unspecified that whether the concerned types of replacement API is identical to the types in the standard.
    • It is important to know this to avoid type introspection based on wrong type identical assumptions, including:
      • Using static_assert or some other meta operations based on static type equivalence.
      • RTTI or exception handling based on dynamic type identity.

YBase user code may use ystdex instead of counterparts in these namespaces to simplify migration. For components to be replaced in namespace std in published standards, they are in correspoinding inline namespaces, e.g. interface first occurred in ISO C++14 is in inline namespace ystdex::cpp2014.

Components for upcoming standard (not published) are deliberately experimental as library compatibility features, so they are directly declared in namespace ystdex.

Components of library compatibility features shall not be deprecated in the current (newest formal) standard.

Extended library compatibility features

Some other interfaces in YBase.YStandardEx are designed as replacements of correspongding specific versions of std or std::experimental interface, as the compatibility features above, but with extra extensions, and with no limitation from the solution of LWG 2013 (that is, they may be with extra constexpr).

Components of extended library compatibility features shall be declared in namespace ystdex and may be declared in the same header of the compatibility features above.

Potential library compatibility features

Some other interfaces in YBase.YStandardEx are designed close to correspongding specific versions of std or std::experimental interface, to be an implemantation base of above compatibility library features or extended library compatibility features. They are not designed to be conforming to any version of the standard or technical specifications, but they may have features which can be directly mapped to the said specifications, with or without some resolutions of LWG issues applied. Though as implementation of above features, they are totally in details, they can also be used as public interfaces as other parts of YSLib.

Reviewed

The following editor report has been fully reviewed (b593[2015-04-23]), which means all the resolutions in the paper are categorized in the following clauses:

NOTE There might exist minor differences between editor's report and the paper in the list, e.g. N3059 (rev 5.2) in N3091 is (rev 5.1). For these cases, only the later revisions at the point of time are reviewed and probably would not be updated unless necessary.

To be done

Reviewing of following defect reports and resolutions are work in progress.

  • CWG 215: Template parameters are not allowed in nested-name-specifiers
  • CWG 218: Specification of Koenig lookup (see also CWG 113 and CWG 143)
  • CWG 397: Same address for string literals from default arguments in inline functions?
  • CWG 667: Trivial special member functions that cannot be implicitly defined
  • CWG 1135: Explicitly-defaulted non-public special member functions
    • CWG 1136: Explicitly-defaulted explicit constructors
    • CWG 1140: Incorrect redefinition of POD class
    • CWG 1145: Defaulting and triviality
    • CWG 1149: Trivial non-public copy operators in subobjects
    • CWG 1208: Explicit noexcept in defaulted definition

Reviewing of following editor reports are work in progress.

The following issues are being waiting to be resolved (and then be reviewed here) formally in public standards.

  • CWG 943: Is T() a temporary?
  • N3918 Core Issue 1299: Temporary objects vs temporary expressions
    • CWG 1299: “Temporary objects” vs “temporary expressions”
      • CWG 1651: Lifetime extension of temporary via reference to subobject
      • CWG 1893: Function-style cast with braced-init-lists and empty pack expansions
    • CWG 1300
  • CWG 1661: Preservation of infinite loops
  • CWG 1722: Should lambda to function pointer conversion function be noexcept?
  • LWG 2362: unique, associative emplace() should not move/copy the mapped_type constructor arguments when no insertion happens (see also LWG 2006)

No actions

There are nothing to do of coding and further documentations for some resolutions.

In baseline

These issues are resolved as NAD(not a defect) and thus have been rejected by WG21 in baseline:

  • CWG 37: When is uncaught_exception() true?
  • CWG 61: Address of static member function "&p->f"
  • CWG 109: Allowing ::template in using-declaration​s
  • CWG 130: Sequence points and new-expression​s
  • LWG 84: Ambiguity with string::insert()
  • EWG 91: [tiny] Core issue 622, Relational comparisons of arbitrary pointers

These issues were once confirmed but are in NAD status now due to newer feature changes which have been adopted by the standard and by this project, so there are nothing further to do:

  • CWG 395: Conversion operator template syntax

These resolutions are already adopted as TC1(Technical Corrigendum 1), i.e. in C++03, and still effective (probably revised) in later versions of the standard:

  • CWG 30: Valid uses of "::template"
  • CWG 84: Overloading and conversion loophole used by auto_ptr
  • CWG 137: static_cast of cv void*
  • CWG 178: More on value-initialization (see also CWG 543)
  • CWG 304: Value-initialization of a reference
  • LWG 61: Exception-handling policy for unformatted output
  • LWG 129: Need error indication from seekp() and seekg()
  • LWG 136: seekp, seekg setting wrong streams?
  • N1219: PROPOSED RESOLUTION TO LIBRARY ISSUE 60
    • LWG 60: What is a formatted input function?

These issues are resolved as NAD(not a defect) editorial and thus nothing to do for user code:

  • CWG 1384: reinterpret_cast in constant expressions
  • CWG 1415: Change "declararation or definition" to "declaration"
  • CWG 1520: Alias template specialization vs pack expansion (see also CWG 1558)
  • LWG 580: unused allocator members
  • LWG 2006: emplace broken for associative containers
    • N3178: emplace broken for associative containers

These post-C++03 draft resolutions are non-normative, purely editorial or conceptional, so no actions could be taken (revised b725[2016-09-04]):

  • CWG 113: Visibility of called function
  • CWG 119: Object lifetime and aggregate initialization
  • CWG 357: Definition of signature should include name
  • CWG 404: Unclear reference to construction with non-trivial constructor (NOTE superseded by "non-vacuous initialization" wording in working draft)
  • CWG 413: Definition of "empty class"
  • CWG 452: Wording nit on description of this, partially adopted
  • CWG 538: Definition and usage of structure, POD-struct, POD-union, and POD class
    • CWG 327: Use of "structure" without definition
  • CWG 582: Template conversion functions
  • CWG 594: Coordinating issues 119 and 404 with delegating constructors (see CWG 119 and CWG 404)
  • CWG 618: Casts in preprocessor conditional expressions
  • CWG 627: Values behaving as types
  • LWG 542: shared_ptr observers
  • LWG 610: Suggested non-normative note for C++0x (i.e. small function object optimization)
  • LWG 616: missing 'typename' in ctype_byname
  • LWG 628: Inconsistent definition of basic_regex constructor
  • LWG 640: 27.6.2.5.2 does not handle (unsigned) long long (i.e. for ostream::operator<<), outdated
  • LWG 972: The term "Assignable" undefined but still in use
  • LWG 2135
    • LWG 2240: Probable misuse of term "function scope" in [thread.condition]
  • N2775: Small library thread-safety revisions
  • N3026
    • CWG 999: “Implicit” or “implied” object argument/parameter?
  • P0134R0: Introducing a name for brace-or-equal-initializer&#8203;s for non-static data members

These post-C++03 draft resolutions would never be depended on because they are only intended useful for language implementations and there shall be no compatibility problems for conforming code (revised b593[2015-04-23]):

  • N2194: decltype for the C++0x Standard Library

Outdated

These resolutions are only about TR1 or features have been formally deprecated/removed from current ISO C++, so shall never be depended on:

  • LWG 527: tr1::bind has lost its Throws clause
  • LWG 588: requirements on zero sized tr1::arrays and other details (for std::array, resolved by LWG 776)

These resolutions are duplicate:

  • CWG 1300: T() for array types (duplicate of CWG 914)
  • CWG 1568: Temporary lifetime extension with intervening cast (duplicate of CWG 1376)
  • LWG 479: Container requirements and placement new (duplicate of LWG 580)
  • LWG 486: min/max CopyConstructible requirement is too strict (duplicate of LWG 281)

These resolution are superseded by later modification on the working paper:

These resolution are superseded and resolved by later issues before publication:

These papers are superseded and newer revisions have been reviewed, so no further actions would be taken:

  • N1890: Initialization and initializers (see subsequent N1919)
  • N1919: Initializer lists (revised as N2100)
  • N1932: Random Number Generation in C++0X: A Comprehensive Proposal (revised as N2032)
  • N1961: Wording for range-based for-loop (revised as N2196)
  • N1968: Lambda expressions and closures for C++ (revised as N2329: Lambda expressions and closures for C++ (Revision 1))
  • N2032: Random Number Generation in C++0X: A Comprehensive Proposal, version 2 (revised as N2079)
  • N2062: POD's Revisited (revised as N2102)
  • N2079: Random Number Generation in C++0X: A Comprehensive Proposal, version 3 (revised as N2111)
  • N2100: Initializer lists (Rev 2.) (revised as N2215)
  • N2102: POD's Revisited; Resolving Core Issue 568 (Revision 1) (revised as N2172)
  • N2151: Variadic Templates for the C++0x Standard Library (revised as N2192)
  • N2172: POD's Revisited; Resolving Core Issue 568 (Revision 2) (revised as N2230)
  • N2192: Variadic Templates for the C++0x Standard Library (Revision 1) (revised as N2242)
  • N2196: Wording for range-based for-loop (revision 1) (revised as N2243)
  • N2210: Defaulted and Deleted Functions (revised as N2326)
  • N2202: C99 Compatibility : __func__ and predeclared identifiers (revised as N2251)
  • N2215: Initializer lists (Rev. 3) (revised as N2385)
  • N2217: Placement Insert for Containers (revised as N2268)
  • N2230: POD's Revisited; Resolving Core Issue 568 (Revision 3) (revised as N2294)
  • N2236: Towards support for attributes in C++ (revised as N2379)
  • N2243: Wording for range-based for-loop (revision 2) (revised as N2394)
  • N2251: C99 Compatibility : __func__ and predeclared identifiers (revision 1) (revised as N2340)
  • N2268: Placement Insert for Containers (Revision 1) (revised as N2345)
  • N2294: POD's Revisited; Resolving Core Issue 568 (Revision 4) (revised as N2342)
  • N2326: Defaulted and Deleted Functions (revised as N2346)
  • N2329: Lambda expressions and closures for C++ (Revision 1) (revised as N2413)
  • N2345: Placement Insert for Containers (Revision 2) (revised as N2642)
  • N2379: Towards support for attributes in C++ (Revision 2) (revised as N2418)
  • N2385: Initializer lists WP wording (revised as N2531)
  • N2394: Wording for range-based for-loop (revision 3) (revised as N2778)
  • N2413: Lambda Expressions and Closures: Wording for Monomorphic Lambdas (revised as N2487)
  • N2418: Towards support for attributes in C++ (Revision 3) (revised as N2553)
  • N2477: Uniform initialization design choices (Revision 2) (revised as N2532)
  • N2487: Lambda Expressions and Closures: Wording for Monomorphic Lambdas (Revision 2) (revised as N2529)
  • N2529: Lambda Expressions and Closures: Wording for Monomorphic Lambdas (Revision 3) (revised as N2550)
  • N2531: Initializer lists WP wording (Revision 2) (see subsequent N2575)
  • N2532: Uniform initialization design choices (Revision 2) (see subsequent N2575)
  • N2550: Lambda Expressions and Closures: Wording for Monomorphic Lambdas (Revision 4) (revised as N2927)
  • N2553: Towards support for attributes in C++ (Revision 4) (revised as N2751; the unavailable revised revision N2663 is wrong on document list)
  • N2575: Initializer Lists — Alternative Mechanism and Rationale (revised as N2640)
  • N2635: Local and Unnamed Types as Template Arguments (revised as N2657)
  • N2640: Initializer Lists — Alternative Mechanism and Rationale (v. 2) (revised as N2672)
  • N2642: Proposed Wording for Placement Insert (revised as N2680)
  • N2751: Towards support for attributes in C++ (Revision 5) (revised as N2761)
  • N2778: Wording for range-based for-loop (revision 4) (revised as N2930)
  • N2820: Adding heterogeneous comparison lookup to associative containers (revised as N2882)
  • N2882: Adding heterogeneous comparison lookup to associative containers for TR2 (Rev 1) (revised as N3465)
  • N2904: Defining default copy and move (revised as N2953)
  • N2953: Defining Move Special Member Functions (revised as N2987)
  • N2987: Defining Move Special Member Functions (revised as N3044)
  • N3044: Defining Move Special Member Functions (revised as N3053)
  • N3149: From Throws: Nothing to noexcept (revised as N3195)
  • N3248: noexcept Prevents Library Validation (revised as N3279)
  • N3433: Clarifying Memory Allocation (revised by N3537)
  • N3465: Adding heterogeneous comparison lookup to associative containers for TR2 (Rev 2) (revised as N3657)
  • N3537: Clarifying Memory Allocation (revised by N3664)
  • N3597: Relaxing constraints on constexpr functions (revised as N3652(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html))
  • N3598: constexpr member functions and implicit const (revised as N3652(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html))
  • N3727: A proposal to add invoke function template (revised as N4169)
  • N3873: Improved insertion interface for unique-key maps (revised as N4006 and N4240)
  • N4006: An improved emplace() for unique-key maps (dropped; see other derivation of N3873)
  • N4017: Non-member size() and more (revised as N4155)
  • N4056: Minimal incomplete type support for standard containers (revised as N4371)
  • N4151: TriviallyCopyable reference_wrapper (revised as N4277)
  • N4155: Non-member size() and more (Revision 1) (revised as N4280)
  • N4228: Refining Expression Evaluation Order for Idiomatic C++ (see subsequent P0145R0)
  • N4240: Improved insertion interface for unique-key maps (revised as N4279)
  • N4334: Wording for bool_constant (revised as N4389)
  • N4371: Minimal incomplete type support for standard containers, revision 2 (revised as N4390)
  • N4390: Minimal incomplete type support for standard containers, revision 3 (revised as N4510)
  • P0145R0: Refining Expression Evaluation Order for Idiomatic C++ (Revision 1) (revised by P0145R1)
  • P0145R1: Refining Expression Evaluation Order for Idiomatic C++ (Revision 2) (revised by P0145R2)
  • P0145R2: Refining Expression Evaluation Order for Idiomatic C++ (revised by P0145R3)

These features are still under development but the approved versions are superseded (note that the superseded versions may still newer than currently adopted version), and not adopted here:

  • EWG 22: N4030, 3745, N3694 Feature-testing recommendations for C++, N3435 Standardized feature-test macros (for adopted version, see N4200)
    • N3435: Standardized feature-test macros
    • N3694: Feature-testing recommendations for C++
    • N3745: Feature-testing recommendations for C++
    • N4030: Feature-testing recommendations for C++
  • N3890: Container<Incomplete Type> (partially superseded by N4056)

Revoked

These features were once adopted by the working paper but later removed away, so no actions would be taken until introduced to the draft again:

  • LWG 1029: Specialized algorithms for memory management need to be concept-constrained templates
  • LWG 1001: Pointers, concepts and headers (see LWG 1178)
  • N2525: Allocator-specific Swap and Move Behavior (i.e. allocator_propagate_*)
  • N2620: Concepts for the C++0x Standard Library: Diagnostics library
  • N2736: Concepts for the C++0x Standard Library: Numerics (Revision 3)
  • N2755: Concepts for the C++0x Standard Library: Chapter 17 -Introduction (Revision 2)
  • N2758: Iterator Concepts for the C++0x Standard Library (Revision 5)
  • N2759: Concepts for the C++0x Standard Library: Algorithms (Revision 5)
  • N2768: Allocator Concepts, part 1 (revision 2)
  • N2770: Concepts for the C++0x Standard Library: Utilities (Revision 5)
  • N2773: Proposed Wording for Concepts (Revision 9)
  • N2774: Foundational Concepts for the C++0x Standard Library (Revision 5)
  • N2776: Concepts for the C++0x Standard Library: Containers (Revision 4)
  • N2777: Concepts for the C++0x Standard Library: Iterators (Revision 4)
  • N2779: Concepts for Clause 18: Part 2
  • N2780: Named Requirements for C++0X Concepts, version 2
  • N2786: Simplifying unique_copy (Revision 1)

There are actions taken by the committee to remove away some former working draft features which are never used here:

  • N2549: Excision of Clause 31 (i.e. <date_time>)

Non defects

These out-of-baseline issues are resolved as NAD(not a defect):

  • CWG 622: Relational comparisons of arbitrary pointers (see EWG 91)
  • CWG 1005: Qualified name resolution in member functions of class templates (see also CWG 1017; note CWG 515 is still effective)
  • LWG 466: basic_string ctor should prevent null pointer error
  • LWG 760: The emplace issue (see LWG 2164 which is still open)
  • LWG 763: Renaming emplace() overloads (N2680 renamed one of the overloads to emplace_hint; for related discussion see LWG 1302)
  • LWG 1202: integral_constant needs a spring clean
  • LWG 1302: different emplace semantics for sequence and associated containers
  • LWG 2311: Allocator requirements should be further minimized

Not applicable

Some proposals are not approved.

  • N3400: A proposal for eliminating the underscore madness that library writers have to suffer

Some proposals are not applicable yet and to be resolved in future. There also may be workaround provided by C++ implementation extensions or user code.

  • N2683: issue 454: problems and solutions
    • LWG 454: basic_filebuf::open should accept wchar_t names

Adopted changes

C++11 core language features and headers below now are being used.

Note: the "adopted" time notes listed in following entries are relative to working paper.

Imported TR1 Headers

TR1(see N1836) headers imported to C++11 are used:

  • <array> (since b218[2011-06-14])
  • <type_traits> (since b206[2011-05-03])
  • <tuple> (since b206[2011-05-03])
    • with LWG 1382: pair and tuple constructors should forward arguments
    • with LWG 1384: Function pack_arguments is poorly named (i.e. forward_as_tuple; since b206[2011-05-03])
    • with N2244: Wording for decay, make_pair and make_tuple
    • with N2299: Concatenating tuples, with modification (since b303[2012-04-23])
  • <unordered_map> (since b206[2011-05-03])
  • <unordered_set> (since b206[2011-05-03])

New headers

New non-TR1 headers from C++11 are used:

  • <atomic> (for all platforms from b590[2015-04-03]; for platforms supporting multithreading since b328[2011-07-25]; for platform MinGW32 since b299[2013-04-08])
  • <chrono> (since b291[2012-03-07])
  • <forward_list> (since b218[2011-06-14]; see N2543)
  • <typeindex> (since b468[2014-01-20])
  • <regex> (since b795[2017-06-11])
  • <system_error> (since b476[2014-02-16]; see N2241)

For all implementations supporting multithreading, these headers are also used:

  • <condition_variable> (since b328[2011-07-25]; for platform MinGW32 since b299[2013-04-08])
  • <future> (since b520[2014-07-23])
  • <mutex> (since b328[2011-07-25]; for platform MinGW32 since b299[2013-04-08])
  • <thread> (since b328[2011-07-25]; for platform MinGW32 since b299[2013-04-08])

Note: LWG 1360 specified single-threaded program should be able to use <atomic>, and resolved by N3256. However, the current YSLib doesn't require it for single-threaded programs.

Technical Specifications

TR1 features was once used, but now retired and corresponding ISO C++ features shall be used, since they are imported from TR1:

  • TR1 <type_traits> including metafunctions and std::tr1::aligned_storage (since b175[2010-12-23])
    • replaced by C++11 std::aligned_storage, see N2341 (since b206[2011-05-03])
  • TR1 <memory> std::tr1::shared_ptr (since b203[2011-04-22])

Some adopted modifications have already in the final draft of technical specifications:

  • N4480: Programming Languages — C++ Extensions for Library Fundamentals
    • with N4288: Strike string_view::clear from Library Fundamentals (adopted 2014-11)

Adopted features

The conformance of following clearer specification (and possible stronger restrictions to user code) beyond C++03 are concerned and took into account:

  • CWG 96: Syntactic disambiguation using the template keyword
  • LWG 201: Numeric limits terminology wrong
  • LWG 294: User defined macros and standard headers
  • LWG 416: definitions of XXX_MIN and XXX_MAX macros in climits, reworded slightly
  • LWG 422: explicit specializations of member functions of class templates, reworded slightly
  • LWG 456: Traditional C header files are overspecified
  • LWG 420: is std::FILE a complete type?

C++11 library features used indirectly (not required, but with design in mind that could make more interface usable, e.g. macro substitution or template instantiations):

  • N2761: Towards support for attributes in C++ (Revision 6)

Other C++11 core and library features used directly:

  • CWG 45: Access to nested classes (since b273[2012-01-01])
    • CWG 8: Access to template arguments used in a function return type and in the nested name specifier
    • CWG 10: Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
  • CWG 208: Rethrowing exceptions in nested handlers (since b461[2013-12-23])
  • CWG 222: Sequence points and lvalue-returning operators (since b297[2012-03-27])
    • with CWG 637: Sequencing rules and example disagree
  • CWG 226: Default template arguments for function templates (since b387[2013-03-11])
  • CWG 254: Exception types in clause 19 are constructed from std::string (since b643[2015-10-08]; i.e. const char* parameter in constructor of standard exception classes)
  • CWG 302: Value-initialization and generation of default constructor (since b206[2011-05-03])
  • CWG 339: Overload resolution in operand of sizeof in constant expression (since b591[2015-04-10])
  • CWG 382: Allow typename outside of templates (b421[2013-07-03])
  • CWG 542: Value initialization of arrays of POD-structs (since b206[2011-05-03])
  • LWG 49: Underspecification of ios_base::sync_with_stdio (since b599[2015-05-21])
  • LWG 611: Standard library templates and incomplete types (since b206[2011-05-03])
  • CWG 765: Local types in inline functions with external linkage (since b282[2012-02-04])
  • CWG 1104: Global-scope template arguments vs the <: digraph (since b493[2014-04-16])
  • LWG 49: Underspecification of ios_base::sync_with_stdio (since b565[2015-01-16])
  • LWG 91: Description of operator>> and getline() for string<> might cause endless loop (since b663[2015-12-18])
  • LWG 130: Return type of container::erase(iterator) differs for associative containers (since b216[2011-06-08])
  • LWG 254: Exception types in clause 19 are constructed from std::string (since b643[2015-10-08])
  • LWG 371: Stability of multiset and multimap member functions (since b216[2011-06-08])
  • LWG 376: basic_streambuf semantics (since b616[2015-07-21])
  • LWG 534: Missing basic_string members (i.e. basic_string pop_back, back and front; since b315[2012-06-08])
  • LWG 559: numeric_limits<const T>, reworded slightly (since b440[2013-08-29])
  • LWG 589: Requirements on iterators of member template functions of containers (since b216[2011-06-08])
  • LWG 596: 27.8.1.3 Table 112 omits "a+" and "a+b" modes (since b326[2012-07-19])
  • LWG 704: MoveAssignable requirement for container value type overly strict (since b206[2011-05-03])
  • LWG 762: std::unique_ptr requires complete type? (since b238[2011-09-07])
  • LWG 868: Default construction and value-initialization (since b206[2011-05-03])
  • LWG 771: Impossible throws clause in [string.conversions] (since b375[2013-01-22])
  • LWG 772: Impossible return clause in [string.conversions] (since b375[2013-01-22])
  • LWG 806: unique_ptr::reset effects incorrect, too permissive (since b206[2011-05-03])
  • LWG 809: std::swap should be overloaded for array types (since b620[2015-08-02])
  • LWG 817: bind needs to be moved (since b401[2013-05-02])
  • LWG 900: Stream move-assignment (tentatively since b620[2015-08-01]; since b727[2016-09-17])
  • LWG 911: I/O streams and move/swap semantic (tentatively since b620[2015-08-01]; since b727[2016-09-17])
  • LWG 922: [func.bind.place] Number of placeholders (since b437[2013-08-22])
  • LWG 929: Thread constructor (since b384[2013-03-01])
  • LWG 993: _Exit needs better specification (since b565[2015-01-16])
  • LWG 1019: Make integral_constant objects useable in integral-constant-expression&#8203;s (since b590[2015-04-10])
  • LWG 1040: Clarify possible sameness of associative container's iterator and const_iterator (since b496[2014-05-01])
  • LWG 1178: Header dependencies (since b338[2012-09-13])
    • LWG 343: Unspecified library header dependencies (see also N2259)
  • LWG 1192: basic_string missing definitions for cbegin / cend / crbegin / crend (since b546[2014-10-17])
  • LWG 1382: pair and tuple constructors should forward arguments (since b206[2011-05-03])
  • N1626: Proposed Resolution for Core Issue 39 (Rev. 1) (since b447[2013-09-25])
    • CWG 39: Conflicting ambiguity rules
  • N1653: Working draft changes for C99 preprocessor synchronization (since b257[2011-11-04]; used GCC extensions previously for variadic macros and empty macro arguments only)
  • N1720: Proposal to Add Static Assertions to the Core Language (Revision 3) (since b206[2011-05-03])
    • with CWG 676: static_assert-declaration&#8203;s and general requirements for declarations
  • N1757: Right Angle Brackets (Revision 1) (since b206[2011-05-03])
  • N1780: Comments on LWG issue 233: Insertion hints in associative containers (since b216[2011-06-08])
  • N1811: Adding the long long type to C++ (Revision 3) (since b206[2011-05-03])
  • N1822: A Proposal to add a max significant decimal digits value to the C++ Standard Library Numeric limits (since b260[2011-11-12]; i.e. numeric_limits::max_digits10)
    • without LWG 613: max_digits10 missing from numeric_limits
  • N1836: Draft Technical Report on C++ Library Extensions (Built-in type traits) (since b206[2011-05-03])
    • with LWG 1182: Unfortunate hash dependencies
    • with LWG 1255: declval should be added to the library (since b260[2011-11-14])
    • with LWG 1270: result_of should be moved to <type_traits> (since b245[2011-09-23])
  • cbegin/cend/crbegin/crend from N1913: A Proposal to Improve const_iterator Use (version 2) (since b206[2011-05-03])
  • N1858: Rvalue Reference Recommendations for Chapter 23, reworded (since b216[2011-06-08])
  • N1984: Deducing the type of variable from its initializer expression (revision 4) (since b206[2011-05-03]; i.e. auto-typed variables)
    • with CWG 615: Incorrect description of variables that can be initialized
  • N1986: Delegating Constructors (revision 3) (since b311[2011-05-25])
  • N1987: Adding "extern template" (version 2) (since b206[2011-05-03])
  • N2179: Language Support for Transporting Exceptions between Threads (since b538[2014-09-28]; i.e. exception_ptr and current_exception, etc)
    • with LWG 829: current_exception wording unclear about exception type
    • with LWG 1130: copy_exception name misleading (i.e. make_exception_ptr; since b550[2014-11-04])
    • with N3195: From Throws: Nothing to noexcept (version 2)
  • N2235: Generalized Constant Expressions—Revision 5 (since b246[2011-09-23]; i.e. constexpr)
  • N2238: Minimal Unicode support for the standard library (revision 3) (since b253[2011-10-18])
  • N2239: A finer-grained alternative to sequence points (revised) (since b297[2012-03-27]; notably order of aggregate initialization, see also CWG 1030)
  • N2240: Two missing traits: enable_if and conditional, added specification when B is false (since b206[2011-05-03])
  • N2241: Diagnostics Enhancements for C++0x (Rev. 1), reworded (since b476[2014-02-16]; i.e. <system_error>)
    • with LWG 805: posix_error::posix_errno concerns (since b550[2014-11-04]; i.e. errc)
  • N2242: Proposed Wording for Variadic Templates (Revision 2) (since b251[2011-10-08])
  • N2244: Wording for decay, make_pair and make_tuple (since b206[2011-05-03])
  • features from N2246: 2 of the least crazy ideas for the standard library in C++0x (i.e. next/prev/is_sorted_until/is_heap_until)
    • next/prev (since b375[2013-01-22])
  • N2249: New Character Types in C++, library part reworded (since b253[2011-10-18])
  • N2255: Minor Modifications to the type traits Wording Revision 2, reworded (since b206[2011-05-03])
  • N2258: Templates Aliases (since b433[2013-08-01])
  • N2259: Specify header dependency for <iostream> (since b338[2012-09-13]; see also LWG 343)
  • features(e.g. alignof) from N2341: Adding Alignment Support to the C++ Programming Language / Wording
    • std::aligned_storage used instead of std::tr1::aligned_storage since b206[2011-05-03]
    • other features except std::aligned_union used since b315[2012-06-08]
  • N2342: POD's Revisited; Resolving Core Issue 568 (Revision 5) (since b206[2011-05-03])
    • CWG 543: Value initialization and default constructors
    • CWG 568: Definition of POD is too strict
  • N2343: Decltype (revision 7) (since b206[2011-05-03])
  • N2346: Defaulted and Deleted Functions (since b207[2011-05-05])
  • N2347: Strongly Typed Enums (revision 3), with modification (since b261[2011-11-19])
  • N2348: Wording for std::numeric_limits<T>::lowest() (since b242[2011-09-16])
  • N2349: Constant Expressions in the Standard Library — Revision 2, with modification (since b260[2011-11-12])
  • N2350: Container insert/erase and iterator constness (Revision 1) (since b531[2014-08-31])
  • N2351: Improving shared_ptr for C++0x, Revision 2 (i.e. make_shared etc; since b529[2014-08-24])
  • N2431: A name for the null pointer: nullptr (revision 4) (since b206[2011-05-03]; compatible layer introduced since b204[2011-04-26])
  • N2437: Explicit Conversion Operator Draft Working Paper (revision 3) (since b260[2011-11-15])
  • N2439: Extending move semantics to *this (revised wording) (since b591[2015-04-11])
  • N2442: Raw and Unicode String Literals; Unified Proposal (Rev. 2)
    • unicode string literals used since b253[2011-10-18]
    • other features used since b434[2013-08-04]
  • N2530: Making It Easier to Use std::type_info as an Index in an Associative Container (since b468[2014-01-20]; i.e. type_info::hash_code)
  • N2535: Namespace Association ("inline namespace") (since b427[2013-07-11])
  • N2540: Inheriting Constructors (revision 5) (since b538[2014-09-24])
  • N2541: New Function Declarator Syntax Wording (since b207[2011-05-05])
  • N2543: STL singly linked lists (revision 3) (since b218[2011-06-04]; i.e. <forward_list>)
  • N2544: Unrestricted Unions (Revision 2) (since b569[2015-01-29])
  • N2546: Removal of auto as a storage-class specifier (since b206[2011-05-03])
  • N2559: Nesting Exception Objects (Revision 1) (since b477[2014-02-19])
    • with LWG 819: rethrow_if_nested
    • with LWG 1136: Incomplete specification of nested_exception::rethrow_nested()
  • N2634: Solving the SFINAE problem for expressions (since b591[2015-04-10])
    • CWG 339: Overload resolution in operand of sizeof in constant expression
  • N2657: Local and Unnamed Types as Template Arguments (since b206[2011-05-03])
    • CWG 488: Local types, overload resolution, and template argument deduction
    • with CWG 765 above
  • N2659: Thread-Local Storage (since b425[2013-07-08])
    • with CWG 810: Block-scope thread_local variables should be implicitly static (since b425[2013-07-08])
  • N2672: Initializer List proposed wording (since b297[2012-03-27])
    • CWG 1030: Evaluation order in initializer-lists used in aggregate initialization (since b297[2012-03-27]; see also N2239)
  • N2680: Proposed Wording for Placement Insert (Revision 1) (since b286[2012-02-19])
  • N2709: Packaging Tasks for Asynchronous Execution (since b520[2014-07-23]; i.e. packaged_task)
  • N2756: Non-static data member initializers (since b360[2013-04-29])
  • N2764: Forward declaration of enumerations (rev. 3) (since b658[2015-12-08])
  • N2844: Fixing a Safety Problem with Rvalue References: Proposed Wording (Revision 1) (since b206[2011-05-03])
    • CWG 1138: Rvalue-ness check for rvalue reference binding is wrong (since b206[2011-05-03])
  • N2927: New wording for C++0x Lambdas (rev. 2) (since b212[2011-05-27])
  • N2930: Range-Based For Loop Wording (Without Concepts) (since b316[2011-06-11])
  • features from N2982: Allocators post Removal of C++ Concepts (Rev 1)
    • std::addressof used since b288[2012-02-26]
    • std::allocator_traits used since b592[2015-04-19]
  • N3050: Allowing Move Constructors to Throw (Rev. 1) (since b319[2012-06-24]; i.e. noexcept and std::move_if_noexcept)
    • with LWG 1349: swap should not throw
    • with N3180: More on noexcept for the Strings Library (since b329[2012-08-05])
    • with N3279: Conservative use of noexcept in the Library (since b461[2013-12-23])
  • N3052: Converting Lambdas to Function Pointers (since b360[2012-12-07])
  • features except in <type_traits> from N3053: Defining Move Special Member Functions (since b230[2011-08-07])
    • with LWG 1309: Missing expressions for Move/CopyConstructible
      • LWG 1283: MoveConstructible and MoveAssignable need clarification of moved-from state
  • N3143: Proposed wording for US 90 (since b206[2011-05-03]; i.e. std::forward)
  • N3189: Observers for the three handler functions (since b550[2014-11-04])
  • N3272: Follow-up on override control (since b311[2011-05-25])
  • N4081: Working Draft, C++ Extensions for Library Fundamentals (see N4480)

Tentatively applied

All adopted changes are confirmed being included in the newest working paper and would not be removed in future unless they are not in the working paper or published standard any longer.

Some C++11 features are not requried to reduce compatibility impact on implementations, but can be utilized when available, i.e. used conditionally (by conditional inclusion or being transparent):

  • N2340: C99 Compatibility : __func__ and predeclared identifiers (revision 2) (since b638[2015-09-24])

The conformance of following clearer specification (and possible stronger restrictions to user code) or removal beyond C++11 are concerned and took into account:

  • CWG 1376: static_cast of temporary to rvalue reference
  • CWG 1493: Criteria for move-construction
  • CWG 1570: Address of subobject as non-type template argument
  • CWG 1596: Non-array objects as array[1]
  • CWG 1629: Can a closure class be a literal type?
  • CWG 1672: Layout compatibility with multiple empty bases
  • CWG 1885: Return value of a function is underspecified
  • N3436: std::result_of and SFINAE

The conformance of following clearer drafting specification (and possible stronger restrictions to user code) or removal beyond C++14 (with Ready state for proposed resolutions still not in the working paper when adopted, or open/drafting with the problems themselves) are concerned and took into account:

  • CWG 1430: Pack expansion into fixed alias template parameter list
  • CWG 1581: When are constexpr member functions defined?
  • LWG 2013: Do library implementers have the freedom to add constexpr? (see also here)
  • LWG 2072: Unclear wording about capacity of temporary buffers
  • LWG 2385: function::assign allocator argument doesn't make sense

Beyond C++11 core and library features used conditionally:

  • CWG 616: Definition of “indeterminate value” (since b663[2016-01-11]) (see also CWG 1213)
    • without CWG 129: Stability of uninitialized auto variables
    • without CWG 240: Uninitialized values and undefined behavior (see also CWG 129)
    • without CWG 312: “use” of invalid pointer value not defined (see also CWG 623)
    • without CWG 623: Use of pointers to deallocated storage (see also CWG 312)
  • CWG 1558: Unused arguments in alias template specializations (since b653[2015-11-25]; see also CWG 1430, CWG 1520 and CWG 1554)
  • LWG 2285: make_reverse_iterator (since b595[2015-05-01])
  • N3421: Making Operator Functors greater<> (since b679[2016-03-19]; see also N3657)
  • N3478: Core Issue 1512: Pointer comparison vs qualification conversions (since b562[2014-12-22])
    • CWG 73: Pointer equality
    • CWG 1512: Pointer comparison vs qualification conversions
  • N3493: Compile-time integer sequences (since b589[2015-04-03])
  • N3652: Relaxing constraints on constexpr functions/constexpr member functions and implicit const (adopted 2013-04; since b591[2015-04-15])
  • N3655: TransformationTraits Redux, v2 (since b595[2015-05-01])
  • N3656: make_unique (Revision 1) (since b617[2015-07-23])
  • N3657: Adding heterogeneous comparison lookup to associative containers (rev 4) (adopted 2013-04; rev 3 not in the list)
    • without is_transparent since b678[2016-03-17]
    • with is_transparent since b679[2016-03-19]
  • N3671: Making non-modifying sequence operations more robust: Revision 2 (since b627[2015-08-30])
  • N4169: A proposal to add invoke function template (Revision 1) (since b617[2015-07-23])
  • N4389: Wording for bool_constant, revision 1 (since b617[2015-07-23])

Following Feature Testing study group documents after EWG 22 are reviewed, with some of them applied or updated:

  • N4200: Feature-testing recommendations for C++ (since b591[2015-04-15]; i.e. __has_cpp_attribute, etc; see subsequent N4440)
  • N4440: Feature-testing recommendations for C++ (superseded)
  • N4535: Feature-testing preprocessor predicates for C++17 (i.e. __has_include and __has_cpp_attribute, see below)
    • __has_cpp_attribute adopted, see also N4200 above
    • Note some Clang++ extensions are also conditionally supported (considered for conditional inclusion) previously
      • __has_attribute since b431[2013-07-23]
      • __has_extension and __has_feature since b484[2013-03-09]
      • __has_builtin since b535[2014-09-14]
  • P0096R0: Feature-testing recommendations for C++ (superseded)
  • P0096R1: Feature-testing recommendations for C++ (since b679[2016-03-20])

Tentatively not applied

The following changes about standard library are not depended on, but were considered some replacements have been used as forcing the requirements for implementations:

  • N4002: Cleaning‐up noexcept in the Library

These post-C++14 library features are not depended on currently (revised b722[2016-08-23]) but direct replacement (to be used conditionally once the draft standard is approved) is provided in YBase:

  • N3911: TransformationTrait Alias void_t (replaced by ystdex::void_t, with workaround for CWG 1558; see also N3843 for motivation)
  • N4277: TriviallyCopyable reference_wrapper (Revision 1) (replaced by ystdex::lref)
  • N4280: Non-member size() and more (Revision 2) (adopted by WP 2014-11; replaced by size, empty and data in namespace ystdex, also ystdex::range_size with addtional interface for std::initializer_list)
  • N4436: Proposing Standard Library Support for the C++ Detection Idiom (partially replaced by is_detected, detected_t, detected_or, detected_or_t, is_detected_exact and is_detected_convertile in namespace ystdex)

These post-C++03 resolutions are not depended on currently (revised b746[2016-12-01]) but confirmed still being compatible (however, some library resolutions may have been applied to similar other interface of YBase):

  • CWG 446: Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
    • CWG 86: Lifetime of temporaries in query expressions
  • CWG 462: Lifetime of temporaries bound to comma expressions
  • CWG 468: Allow ::template outside of templates
  • CWG 475: When is std::uncaught_exception() true? (take 2)
  • CWG 515: Non-dependent references to base class members (see also GCC PR 21008)
  • CWG 569: Spurious semicolons at namespace scope should be allowed
  • CWG 573: Conversions between function pointers and void* (see also CWG 195/CWG 1120)
  • CWG 760: this inside a nested class of a non-static member function
  • CWG 1120: reinterpret_cast and void* (depends on CWG 573)
  • CWG 1164: Partial ordering of f(T&) and f(T&&)
  • CWG 1213: Array subscripting and xvalues (see also CWG 616)
  • CWG 1227: Mixing immediate and non-immediate contexts in deduction failure
  • CWG 1301: Value initialization of union
    • CWG 1324: Value initialization and defaulted constructors
    • CWG 1368: Value initialization and defaulted constructors (part 2)
  • CWG 1402: Move functions too often deleted
    • CWG 1491: Move construction and rvalue reference members
  • CWG 1412: Problems in specifying pointer conversions
  • CWG 1579: Return by converting move constructor
  • CWG 1591: Deducing array bound and element type from initializer list
  • CWG 1693: Superfluous semicolons in class definitions (depends on CWG 569)
  • CWG 1875: Reordering declarations in class scope
  • CWG 1952: Constant expressions and library undefined behavior
  • LWG 281: std::min() and max() requirements overly restrictive
  • LWG 283: std::replace() requirement incorrect/insufficient
  • LWG 387: std::complex over-encapsulated
  • LWG 402: wrong new expression in [some_]allocator::construct
  • LWG 497: meaning of numeric_limits::traps for floating point types
  • LWG 531: array forms of unformatted input functions (i.e. for istream::get)
  • LWG 543: valarray slice default constructor
  • LWG 551: <ccomplex>
  • LWG 566: array forms of unformatted input function undefined for zero-element arrays (i.e. for istream::get)
  • LWG 576: find_first_of is overconstrained
  • LWG 578: purpose of hint to allocator::allocate()
  • LWG 586: string inserter not a formatted function
  • LWG 593: __STDC_CONSTANT_MACROS
  • LWG 619: Longjmp wording problem
  • LWG 643: Impossible "as if" clauses
  • LWG 646: const incorrect match_result members
  • LWG 659: istreambuf_iterator should have an operator->()
  • LWG 776: Undescribed assign function of std::array (i.e. array::fill)
  • LWG 779: Resolution of #283 incomplete
  • LWG 787: complexity of binary_search
  • LWG 807: tuple construction should not fail unless its element's construction fails
  • LWG 844: complex pow return type is ambiguous
  • LWG 848: Missing std::hash specializations for std::bitset/std::vector<bool>
  • LWG 850: Should shrink_to_fit apply to std::deque? (i.e. deque::shrink_to_fit)
  • LWG 852: unordered containers begin(n) mistakenly const
  • LWG 900: Stream move-assignment
  • LWG 1071: is_bind_expression should derive from integral_constant<bool>
  • LWG 1402: nullptr constructors for smart pointers should be constexpr
  • LWG 2005: unordered_map::insert(T&&) protection should apply to map too
    • with LWG 2571: §[map.modifiers]/2 imposes nonsensical requirement on insert(InputIterator, InputIterator)
  • LWG 2104: unique_lock move-assignment should not be noexcept
  • LWG 2112: User-defined classes that cannot be derived from (i.e. is_final)
  • LWG 2135: Unclear requirement for exceptions thrown in condition_variable::wait()
  • LWG 2247: Type traits and std::nullptr_t (i.e. is_null_pointer)
  • LWG 2442: call_once() shouldn't DECAY_COPY()
  • LWG 2466: allocator_traits::max_size() default behavior is incorrect
  • LWG 2577: {shared,unique}_lock should use std::addressof
  • N1981: Uniform Use of std::string Revision 1
  • N1990: Proposed Text for minmax (N1840) (i.e. minmax and minmax_element in <algorithm>)
  • N1991: Proposed Text for defaultfloat (N1842) (i.e. defaultfloat in <ios>)
  • N2007: Proposed Library Additions for Code Conversion
  • N2111: Random Number Generation in C++0X: A Comprehensive Proposal, version 4
    • with LWG 609: missing static const
  • N2253: Extending sizeof to apply to non-static data members without an object (revision 1)
  • N2292: Standard Library Applications for Deleted Functions
  • N2308: Adding allocator support to std::function for C++0x, with modification
  • N2321: Enhancing the time_get facet for POSIX® compatibility, Revision 2
  • N2353: A Specification for vector<bool>
  • N2547: Allow atomics use in signal handlers
  • N2554: The Scoped Allocator Model (Rev 2)
  • N2760: Input/Output Library Thread Safety
  • N2765: User-defined Literals (aka. Extensible Literals (revision 5))
  • N2782: C++ Data-Dependency Ordering: Function Annotation (i.e. [[carries_dependency]])
  • N3026
    • CWG 408: sizeof applied to unknown-bound array static data member of template
    • CWG 490: Name lookup in friend declarations
    • CWG 722: Can nullptr be passed to an ellipsis?
    • CWG 734: Are unique addresses required for namespace-scope variables?
    • CWG 935: Missing overloads for character types for user-defined literals
    • CWG 1000: Mistaking member typedefs for constructors
  • N3059: Proposal to simplify pair (rev 5.2) (i.e. piecewise_construct_t, etc.)
    • LWG 1321: scoped_allocator_adaptor construct and destroy don't use allocator_traits
  • N3282: Resolution for core issues 1207 and [1017](](http://wg21.cmeerw.net/cwg/issue1017)
  • N3843: A SFINAE-Friendly std::common_type
  • N4279: Improved insertion interface for unique-key maps (Revision 2.3) (adopted 2014-11)
  • N4446: The missing INVOKE related trait (i.e. is_callable)
  • N4510: Minimal incomplete type support for standard containers, revision 4 (adopted 2015-05; however, similar requirements for associative containers (not proposed yet) are required, see here (zh-CN))

These already adopted (by the standard or the working paper) post-C++11 resolutions (which may need no modification on a previous conforming C++ implementation) are not depended on currently (revised b752[2016-12-20]) but confirmed still being compatible, and also would not be relied on in future based on the current status for code quality reasons:

  • N3664: Clarifying Memory Allocation (adopted 2013-04)
  • P0145R3: Refining Expression Evaluation Order for Idiomatic C++ (adopted 2016-06)

List of reported issues

There are some issues related reported, or originally found and forwarded by author of this project. Some of them might block the project in some sense. To review them conveniently, they are collected and listed here (revised b725[2016-09-04]).

Specifications

Some issues are related to the to language or enviornment specifications.

The entries may duplicate with above.

ISO/IEC 14882 (ISO/IEC JTC1 SC22/WG21 issue list)

Implementations of standards or specifications

Some issues are related to the to implementations of language or enviornment specifications.

GNU C++ (Bugzilla)

  • PR 53872: [C++11] ADL bug in std::thread (RESOLVED FIXED 4.7.2)
  • PR 53873: [C++11] strange error message for template overloading (RESOLVED DUPLICATE of bug 53862)
    • PR 53862[4.6/4.7 regression] [C++11] sorry, unimplemented: use of 'type_pack_expansion' in template (RESOLVED FIXED 4.7.1)
  • PR 54216: Missing diagnostic for ill-formed anonymous enum declarations (RESOLVED FIXED 4.9.0)
  • PR 55053: std::is_explicitly_convertible should be removed (RESOLVED WORKSFORME 4.8.0)
  • PR 56699: [4.8/4.9 regression] Failed for sizeof (non-static member) in lambda expression (RESOLVED FIXED mainline/4.8.1)
  • PR 57183: [C++11] auto and -Wunused-variable (RESOLVED FIXED 4.8.1)
  • PR 57444: [4.8/4.9 Regression] ICE in instantiate_type for invalid use of member with using-declaration (RESOLVED DUPLICATE of bug 58457)
    • PR 58457: [4.8/4.9 Regression] ICE when placement new operator is used with using keyword and custom constructor (RESOLVED FIXED 4.8.2/4.9.0)
  • PR 58395: Undefined behavior vs. exception (RESOLVED WONTFIX)
  • PR 59682: Invalid syntax accepted: new-placement without expression-list (RESOLVED FIXED 6.0)
  • PR 59931: Wrong wording of diagnostic about imaginary "member function type"
  • PR 60709: [C++11]ICE when using a braced-init-list as function argument to initialize a reference to array (RESOLVED FIXED 4.8.3)
  • PR 61019: ICE: incomplete type of class template as pseudo-destructor-name (RESOLVED FIXED 6.0)
  • PR 63400: [C++11]precision of std::chrono::high_resolution_clock (UNCONFIRMED)
  • PR 65343: unexpected exception thrown during destruction of static object in debug mode
    • Since some version of Windows 10, the crash dialog would not show, made it less annoying.
  • PR 65748: [C++11][C++14]Invalid copy elision on operand of throw-exception (RESOLVED DUPLICATE of bug 57533)
    • PR 57533: When throwing local variable, it's being move-constructed even if not going out of scope. (NEW)
    • This misfeature is carefully avoided in YSLib source.
  • PR 65890: [C++03]sizeof(qualified-id) accepted when the operand denotes a non-static member (RESOLVED INVALID)
    • This does not effect YSLib since C++11 is the baseline.
  • PR 67238: [C++11][C++14]cc1plus crash for nested decltype expression in parameter pack in trailing return type when '-g' enabled (RESOLVED FIXED 6.0)
    • This was worked arounded in YSLib source, before 6.0 is actually depended on.
  • PR 67795: Wrong code generated for conditional expression with cast (NEW)
    • This still block some code.
  • PR 70480: Reduce RTTI code bloat for specified types (UNCONFIRMED)
    • For DS platform, YSLib uses ystdex::type_id instead typeid to worked around.
  • PR 71444: Error constants for MinGW-w64 (UNCONFIRMED)
    • This was worked around in YSLib source.

LLVM/Clang (Bugzilla)

  • PR 25306: __attribute__((returns_nonnull)) does not work for std::add_pointer_t<T> (NEW)
  • PR 27504: Inherited constructor with dependent base class introduced by a typedef-name may not work (NEW)
  • PR 27443: [CWG 734] Nonconforming aliasing of block scope objects (RESOLVED DUPLICATE of bug 18538)
    • PR 18538: non-conforming optimization -fmerge-all-constants is enabled by default

Microsoft Visual C++ (Microsoft Connect)

  • issue 1641428: Wrong Win32 error to errno mapping (ACTIVE)
    • YSLib code does not rely on Universal source, instead implements the functionality spearatedly, so it has no effect.
  • issue 2913382: Parameter parsing bug (ACTIVE)

Other tools

As complement, some issues are related to other tools used by the project, which may loosely concern with issues listed above.

DrMemory

Resolved implementation issues

Some issues were tagged BLOCKED status previously. Issues knwon resolved and confirmed to work would be put in this chapter.

Updated