Annex C (informative) Compatibility [diff]

C.5 C++ and ISO C++ 2017 [diff.cpp17]

This subclause lists the differences between C++ and ISO C++ 2017 (ISO/IEC 14882:2017, Programming Languages — C++), by the chapters of this document.

C.5.1 [lex]: lexical conventions [diff.cpp17.lex]

Affected subclause: [lex.key]
Change: New keywords.

Rationale: Required for new features.
The requires keyword is added to introduce constraints through a requires-clause or a requires-expression.
The concept keyword is added to enable the definition of concepts ([temp.concept]).

Effect on original feature: Valid ISO C++ 2017 code using concept or requires as an identifier is not valid in this International Standard.
Affected subclause: [lex.operators]
Change: New operator <=>.

Rationale: Necessary for new functionality.

Effect on original feature: Valid C++ 2017 code that contains a <= token immediately followed by a > token may be ill-formed or have different semantics in this International Standard:
namespace N {
  struct X {};
  bool operator<=(X, X);
  template<bool(X, X)> struct Y {};
  Y<operator<=> y;              // ill-formed; previously well-formed
}

C.5.2 [expr]: expressions [diff.cpp17.expr]

Affected subclause: [expr.prim.lambda.capture]
Change: Implicit lambda capture may capture additional entities.

Rationale: Rule simplification, necessary to resolve interactions with constexpr if.

Effect on original feature: Lambdas with a capture-default may capture local entities that were not captured in C++ 2017 if those entities are only referenced in contexts that do not result in an odr-use.

C.5.3 [dcl.dcl]: declarations [diff.cpp17.dcl.dcl]

Affected subclause: [dcl.init.aggr]
Change: A class that has user-declared constructors is never an aggregate.

Rationale: Remove potentially error-prone aggregate initialization which may apply notwithstanding the declared constructors of a class.

Effect on original feature: Valid C++ 2017 code that aggregate-initializes a type with a user-declared constructor may be ill-formed or have different semantics in this International Standard.
struct A {              // not an aggregate; previously an aggregate
  A() = delete;
};

struct B {              // not an aggregate; previously an aggregate
  B() = default;
  int i = 0;
};

struct C {              // not an aggregate; previously an aggregate
  C(C&&) = default;
  int a, b;
};

A a{};                  // ill-formed; previously well-formed
B b = {1};              // ill-formed; previously well-formed
auto* c = new C{2, 3};  // ill-formed; previously well-formed

struct Y;

struct X {
  operator Y();
};

struct Y {              // not an aggregate; previously an aggregate
  Y(const Y&) = default;
  X x;
};

Y y{X{}};               // copy constructor call; previously aggregate-initialization

C.5.4 [class]: classes [diff.cpp17.class]

Affected subclauses: [class.ctor], [class.conv.fct]
Change: The class name can no longer be used parenthesized immediately after an explicit decl-specifier in a constructor declaration.
The conversion-function-id can no longer be used parenthesized immediately after an explicit decl-specifier in a conversion function declaration.

Rationale: Necessary for new functionality.

Effect on original feature: Valid C++ 2017 code may fail to compile in this International Standard.
For example:
struct S {
  explicit (S)(const S&);       // ill-formed; previously well-formed
  explicit (operator int)();    // ill-formed; previously well-formed
  explicit(true) (S)(int);      // OK
};
Affected subclauses: [class.ctor], [class.dtor]
Change: A simple-template-id is no longer valid as the declarator-id of a constructor or destructor.

Rationale: Remove potentially error-prone option for redundancy.

Effect on original feature: Valid C++ 2017 code may fail to compile in this International Standard.
For example:
template<class T>
struct A {
  A<T>();          // error: simple-template-id not allowed for constructor
  A(int);          // OK, injected-class-name used
  ~A<T>();         // error: simple-template-id not allowed for destructor
};

C.5.5 [temp]: templates [diff.cpp17.temp]

Affected subclause: [temp.names]
Change: An unqualified-id that is followed by a < and for which name lookup finds nothing or finds a function will be treated as a template-name in order to potentially cause argument dependent lookup to be performed.

Rationale: It was problematic to call a function template with an explicit template argument list via argument dependent lookup because of the need to have a template with the same name visible via normal lookup.

Effect on original feature: Previously valid code that uses a function name as the left operand of a < operator would become ill-formed.
struct A {};
bool operator<(void (*fp)(), A);
void f() {}
int main() {
  A a;
  f < a;    // ill-formed; previously well-formed
  (f) < a;  // still well formed
}

C.5.6 [except]: exception handling [diff.cpp17.except]

Affected subclause: [except.spec]
Change: Remove throw() exception specification.

Rationale: Removal of obsolete feature that has been replaced by noexcept.

Effect on original feature: A valid C++ 2017 function declaration, member function declaration, function pointer declaration, or function reference declaration that uses throw() for its exception specification will be rejected as ill-formed in this International Standard.
It should simply be replaced with noexcept for no change of meaning since C++ 2017.
[Note
:
There is no way to write a function declaration that is non-throwing in this International Standard and is also non-throwing in C++ 2003 except by using the preprocessor to generate a different token sequence in each case.
end note
]

C.5.7 [library]: library introduction [diff.cpp17.library]

Affected subclause: [headers]
Change: New headers.

Rationale: New functionality.

Effect on original feature: The following C++ headers are new: <bit>, <compare>, <concepts>, <contract>, <span>, <syncstream>, and <version>.
Valid C++ 2017 code that #includes headers with these names may be invalid in this International Standard.
Affected subclause: [headers]
Change: Remove vacuous C++ header files.

Rationale: The empty headers implied a false requirement to achieve C compatibility with the C++ headers.

Effect on original feature: A valid C++ 2017 program that #includes any of the following headers may fail to compile: <ccomplex>, <ciso646>, <cstdalign>, <cstdbool>, and <ctgmath>.
To retain the same behavior:
  • a #include of <ccomplex> can be replaced by a #include of <complex> ([complex.syn]),
  • a #include of <ctgmath> can be replaced by a #include of <cmath> ([cmath.syn]) and a #include of <complex>, and
  • a #include of <ciso646>, <cstdalign>, or <cstdbool> can simply be removed.

C.5.8 [containers]: containers library [diff.cpp17.containers]

Affected subclauses: [forwardlist], [list]
Change: Return types of remove, remove_­if, and unique changed from void to container::size_­type.

Rationale: Improve efficiency and convenience of finding number of removed elements.

Effect on original feature: Code that depends on the return types might have different semantics in this International Standard.
Translation units compiled against this version of C++ may be incompatible with translation units compiled against C++ 2017, either failing to link or having undefined behavior.

C.5.9 [depr]: compatibility features [diff.cpp17.depr]

Change: Remove uncaught_­exception.

Rationale: The function did not have a clear specification when multiple exceptions were active, and has been superseded by uncaught_­exceptions.

Effect on original feature: A valid C++ 2017 program that calls std::uncaught_­exception may fail to compile.
It might be revised to use std::uncaught_­exceptions instead, for clear and portable semantics.
Change: Remove support for adaptable function API.

Rationale: The deprecated support relied on a limited convention that could not be extended to support the general case or new language features.
It has been superseded by direct language support with decltype, and by the std::bind and std::not_­fn function templates.

Effect on original feature: A valid C++ 2017 program that relies on the presence of result_­type, argument_­type, first_­argument_­type, or second_­argument_­type in a standard library class may fail to compile.
A valid C++ 2017 program that calls not1 or not2, or uses the class templates unary_­negate or binary_­negate, may fail to compile.
Change: Remove redundant members from std::allocator.

Rationale: std::allocator was overspecified, encouraging direct usage in user containers rather than relying on std::allocator_­traits, leading to poor containers.

Effect on original feature: A valid C++ 2017 program that directly makes use of the pointer, const_­pointer, reference, const_­reference, rebind, address, construct, destroy, or max_­size members of std::allocator, or that directly calls allocate with an additional hint argument, may fail to compile.
Change: Remove raw_­storage_­iterator.

Rationale: The iterator encouraged use of algorithms that might throw exceptions, but did not return the number of elements successfully constructed that might need to be destroyed in order to avoid leaks.

Effect on original feature: A valid C++ 2017 program that uses this iterator class may fail to compile.
Change: Remove temporary buffers API.

Rationale: The temporary buffer facility was intended to provide an efficient optimization for small memory requests, but there is little evidence this was achieved in practice, while requiring the user to provide their own exception-safe wrappers to guard use of the facility in many cases.

Effect on original feature: A valid C++ 2017 program that calls get_­temporary_­buffer or return_­temporary_­buffer may fail to compile.
Change: Remove shared_­ptr::unique.

Rationale: The result of a call to this member function is not reliable in the presence of multiple threads and weak pointers.
The member function use_­count is similarly unreliable, but has a clearer contract in such cases, and remains available for well defined use in single-threaded cases.

Effect on original feature: A valid C++ 2017 program that calls unique on a shared_­ptr object may fail to compile.
Affected subclause: [depr.meta.types]
Change: Remove deprecated type traits.

Rationale: The traits had unreliable or awkward interfaces.
The is_­literal_­type trait provided no way to detect which subset of constructors and member functions of a type were declared constexpr.
The result_­of trait had a surprising syntax that could not report the result of a regular function type.
It has been superseded by the invoke_­result trait.

Effect on original feature: A valid C++ 2017 program that relies on the is_­literal_­type or result_­of type traits, on the is_­literal_­type_­v variable template, or on the result_­of_­t alias template may fail to compile.