[over.oper] - C++11 → C++14

Files changed (1) hide show

tmp/tmp5da3iwut/{from.md → to.md} +30 -19

tmp/tmp5da3iwut/{from.md → to.md} RENAMED Viewed

@@ -49,11 +49,11 @@ The allocation and deallocation functions, `operator` `new`, `operator`
 completely in  [[basic.stc.dynamic]]. The attributes and restrictions
 found in the rest of this subclause do not apply to them unless
 explicitly stated in  [[basic.stc.dynamic]].
 An operator function shall either be a non-static member function or be
-a non-member function and have at least one parameter whose type is a
 class, a reference to a class, an enumeration, or a reference to an
 enumeration. It is not possible to change the precedence, grouping, or
 number of operands of operators. The meaning of the operators `=`,
 (unary) `&`, and `,` (comma), predefined for each type, can be changed
 for specific class and enumeration types by defining operator functions
@@ -207,19 +207,19 @@ is selected as the best match function by the overload resolution
 mechanism ([[over.match]]).
 ### Increment and decrement <a id="over.inc">[[over.inc]]</a>
 The user-defined function called `operator++` implements the prefix and
-postfix `++` operator. If this function is a member function with no
-parameters, or a non-member function with one parameter of class or
-enumeration type, it defines the prefix increment operator `++` for
-objects of that type. If the function is a member function with one
-parameter (which shall be of type `int`) or a non-member function with
-two parameters (the second of which shall be of type `int`), it defines
-the postfix increment operator `++` for objects of that type. When the
-postfix increment is called as a result of using the `++` operator, the
-`int` argument will have value zero.[^13]
 ``` cpp
 struct X {
   X&   operator++();            // prefix ++a
   X    operator++(int);         // postfix a++
@@ -247,16 +247,21 @@ analogously.
 ### User-defined literals <a id="over.literal">[[over.literal]]</a>
 ``` bnf
 literal-operator-id:
-    'operator' '""' identifier
 ```
-The *identifier* in a *literal-operator-id* is called a *literal suffix
-identifier*. some literal suffix identifiers are reserved for future
-standardization; see  [[usrlit.suffix]].
 A declaration whose *declarator-id* is a *literal-operator-id* shall be
 a declaration of a namespace-scope function or function template (it
 could be a friend function ([[class.friend]])), an explicit
 instantiation or specialization of a function template, or a
@@ -279,10 +284,13 @@ const char*, std::size_t
 const wchar_t*, std::size_t
 const char16_t*, std::size_t
 const char32_t*, std::size_t
 ```
 A *raw literal operator* is a literal operator with a single parameter
 whose type is `const char*`.
 The declaration of a literal operator template shall have an empty
 *parameter-declaration-clause* and its *template-parameter-list* shall
@@ -302,14 +310,17 @@ overload resolution rules. Also, they can be declared `inline` or
 called explicitly, their addresses can be taken, etc.
 ``` cpp
 void operator "" _km(long double);                  // OK
 string operator "" _i18n(const char*, std::size_t); // OK
-template <char...> int operator "" \u03C0(); // OK: UCN for lowercase pi
-float operator ""E(const char*); // error: ""E (with no intervening space)
- // is a single token
-float operator " " B(const char*);                  // error: non-adjacent quotes
 string operator "" 5X(const char*, std::size_t);    // error: invalid literal suffix identifier
 double operator "" _miles(double);                  // error: invalid parameter-declaration-clause
-template <char...> int operator "" j(const char*); // error: invalid parameter-declaration-clause
 ```

 completely in  [[basic.stc.dynamic]]. The attributes and restrictions
 found in the rest of this subclause do not apply to them unless
 explicitly stated in  [[basic.stc.dynamic]].
 An operator function shall either be a non-static member function or be
+a non-member function that has at least one parameter whose type is a
 class, a reference to a class, an enumeration, or a reference to an
 enumeration. It is not possible to change the precedence, grouping, or
 number of operands of operators. The meaning of the operators `=`,
 (unary) `&`, and `,` (comma), predefined for each type, can be changed
 for specific class and enumeration types by defining operator functions
 mechanism ([[over.match]]).
 ### Increment and decrement <a id="over.inc">[[over.inc]]</a>
 The user-defined function called `operator++` implements the prefix and
+postfix `++` operator. If this function is a non-static member function
+with no parameters, or a non-member function with one parameter, it
+defines the prefix increment operator `++` for objects of that type. If
+the function is a non-static member function with one parameter (which
+shall be of type `int`) or a non-member function with two parameters
+(the second of which shall be of type `int`), it defines the postfix
+increment operator `++` for objects of that type. When the postfix
+increment is called as a result of using the `++` operator, the `int`
+argument will have value zero.[^13]
 ``` cpp
 struct X {
   X&   operator++();            // prefix ++a
   X    operator++(int);         // postfix a++
 ### User-defined literals <a id="over.literal">[[over.literal]]</a>
 ``` bnf
 literal-operator-id:
+    'operator' string-literal identifier
+    'operator' user-defined-string-literal
 ```
+The *string-literal* or *user-defined-string-literal* in a
+*literal-operator-id* shall have no *encoding-prefix* and shall contain
+no characters other than the implicit terminating `'\0'`. The
+*ud-suffix* of the *user-defined-string-literal* or the *identifier* in
+a *literal-operator-id* is called a *literal suffix identifier*. some
+literal suffix identifiers are reserved for future standardization; see
+[[usrlit.suffix]].
 A declaration whose *declarator-id* is a *literal-operator-id* shall be
 a declaration of a namespace-scope function or function template (it
 could be a friend function ([[class.friend]])), an explicit
 instantiation or specialization of a function template, or a
 const wchar_t*, std::size_t
 const char16_t*, std::size_t
 const char32_t*, std::size_t
 ```
+If a parameter has a default argument ([[dcl.fct.default]]), the
+program is ill-formed.
 A *raw literal operator* is a literal operator with a single parameter
 whose type is `const char*`.
 The declaration of a literal operator template shall have an empty
 *parameter-declaration-clause* and its *template-parameter-list* shall
 called explicitly, their addresses can be taken, etc.
 ``` cpp
 void operator "" _km(long double);                  // OK
 string operator "" _i18n(const char*, std::size_t); // OK
+template <char...> double operator "" _\u03C0(); // OK: UCN for lowercase pi
+float operator ""_e(const char*); // OK
+float operator ""E(const char*);                    // error: reserved literal suffix~([usrlit.suffix], [lex.ext])
+double operator""_Bq(long double);                  // OK: does not use the reserved name _Bq~([global.names])
+double operator"" _Bq(long double);                 // uses the reserved name _Bq~([global.names])
+float operator " " B(const char*);                  // error: non-empty string-literal
 string operator "" 5X(const char*, std::size_t);    // error: invalid literal suffix identifier
 double operator "" _miles(double);                  // error: invalid parameter-declaration-clause
+template <char...> int operator "" _j(const char*); // error: invalid parameter-declaration-clause
+extern "C" void operator "" _m(long double);        // error: C language linkage
 ```

Diff to HTML by rtfpessoa