Annex C (informative) Compatibility [diff]

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

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

Affected subclauses: [lex.pptoken], [module.unit], [module.import], [cpp.pre], [cpp.module], and [cpp.import]

Change: New identifiers with special meaning.

Rationale: Required for new features.

Effect on original feature: Logical lines beginning with module or import may be interpreted differently in this International Standard.

[ Example

class module {};
module m1;          // was variable declaration; now module-declaration
module *m2;         // variable declaration

class import {};
import j1;          // was variable declaration; now import-declaration
::import j2;        // variable declaration

— end example

]

Affected subclause: [lex.header]

Change: header-name tokens are formed in more contexts.

Rationale: Required for new features.

Effect on original feature: When the identifier import is followed by a < character, a header-name token may be formed.

[ Example

template<typename> class import {};
import<int> f();                // ill-formed; previously well-formed
::import<int> g();              // OK

— end example

]

Affected subclause: [lex.key]

Change: New keywords.

Rationale: Required for new features.

(3.1)
The char8_t keyword is added to differentiate the types of ordinary and UTF-8 literals ([lex.string]).
(3.2)
The concept keyword is added to enable the definition of concepts ([temp.concept]).
(3.3)
The consteval keyword is added to declare immediate functions ([dcl.constexpr]).
(3.4)
The constinit keyword is added to prevent unintended dynamic initialization ([dcl.constinit]).
(3.5)
The co_await, co_yield, and co_return keywords are added to enable the definition of coroutines ([dcl.fct.def.coroutine]).
(3.6)
The requires keyword is added to introduce constraints through a requires-clause or a requires-expression .

Effect on original feature: Valid C++ 2017 code using char8_t, concept, consteval, constinit, co_await, co_yield, co_return, 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
}

Affected subclause: [lex.literal]

Change: Type of UTF-8 string and character literals.

Rationale: Required for new features.

The changed types enable function overloading, template specialization, and type deduction to distinguish ordinary and UTF-8 string and character literals.

Effect on original feature: Valid C++ 2017 code that depends on UTF-8 string literals having type “array of const char” and UTF-8 character literals having type “char” is not valid in this International Standard.

const auto *u8s = u8"text";     // u8s previously deduced as const char*; now deduced as const char8_t*
const char *ps = u8s;           // ill-formed; previously well-formed

auto u8c = u8'c';               // u8c previously deduced as char; now deduced as char8_t
char *pc = &u8c;                // ill-formed; previously well-formed

std::string s = u8"text";       // ill-formed; previously well-formed

void f(const char *s);
f(u8"text");                    // ill-formed; previously well-formed

template<typename> struct ct;
template<> struct ct<char> {
  using type = char;
};
ct<decltype(u8'c')>::type x;    // ill-formed; previously well-formed.