From Jason Turner

[over.built]

C++11 → C++14 3.1 KB 28 lines
Current Draft | LaTeX Source
Archived: C++11 | C++14
Markdown: C++11 | C++14
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpz5z877ku/{from.md → to.md} +12 -9
tmp/tmpz5z877ku/{from.md → to.md} RENAMED
@@ -88,11 +88,11 @@ T operator-(T);
88
 
89
  For every promoted integral type *T*, there exist candidate operator
90
  functions of the form
91
 
92
  ``` cpp
93
- T operator\sim(T);
94
  ```
95
 
96
  For every quintuple (*C1*, *C2*, *T*, *CV1*, *CV2*), where *C2* is a
97
  class type, *C1* is the same type as C2 or is a derived class of C2, *T*
98
  is an object type or a function type, and *CV1* and *CV2* are
@@ -101,11 +101,13 @@ form
101
 
102
  ``` cpp
103
  CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
104
  ```
105
 
106
- where *CV12* is the union of *CV1* and *CV2*.
 
 
107
 
108
  For every pair of promoted arithmetic types *L* and *R*, there exist
109
  candidate operator functions of the form
110
 
111
  ``` cpp
@@ -140,24 +142,24 @@ candidate operator functions of the form
140
 
141
  ``` cpp
142
  std::ptrdiff_t operator-(T, T);
143
  ```
144
 
145
- For every *T*, where *T* is an enumeration type, a pointer type, or
146
- `std::nullptr_t`, there exist candidate operator functions of the form
147
 
148
  ``` cpp
149
  bool operator<(T, T);
150
  bool operator>(T, T);
151
  bool operator<=(T, T);
152
  bool operator>=(T, T);
153
  bool operator==(T, T);
154
  bool operator!=(T, T);
155
  ```
156
 
157
- For every pointer to member type *T* there exist candidate operator
158
- functions of the form
159
 
160
  ``` cpp
161
  bool operator==(T, T);
162
  bool operator!=(T, T);
163
  ```
@@ -294,10 +296,11 @@ T operator?:(bool, T, T);
294
  [expr]: expr.md#expr
295
  [expr.ass]: expr.md#expr.ass
296
  [expr.call]: expr.md#expr.call
297
  [expr.cast]: expr.md#expr.cast
298
  [expr.cond]: expr.md#expr.cond
 
299
  [expr.prim]: expr.md#expr.prim
300
  [expr.static.cast]: expr.md#expr.static.cast
301
  [expr.sub]: expr.md#expr.sub
302
  [expr.type.conv]: expr.md#expr.type.conv
303
  [expr.unary.op]: expr.md#expr.unary.op
@@ -356,13 +359,13 @@ T operator?:(bool, T, T);
356
  ignored.
357
 
358
  [^2]: The process of argument deduction fully determines the parameter
359
  types of the function template specializations, i.e., the parameters
360
  of function template specializations contain no template parameter
361
- types. Therefore the function template specializations can be
362
- treated as normal (non-template) functions for the remainder of
363
- overload resolution.
364
 
365
  [^3]: Note that cv-qualifiers on the type of objects are significant in
366
  overload resolution for both glvalue and class prvalue objects.
367
 
368
  [^4]: An implied object argument must be contrived to correspond to the
 
88
 
89
  For every promoted integral type *T*, there exist candidate operator
90
  functions of the form
91
 
92
  ``` cpp
93
+ T operator~(T);
94
  ```
95
 
96
  For every quintuple (*C1*, *C2*, *T*, *CV1*, *CV2*), where *C2* is a
97
  class type, *C1* is the same type as C2 or is a derived class of C2, *T*
98
  is an object type or a function type, and *CV1* and *CV2* are
 
101
 
102
  ``` cpp
103
  CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
104
  ```
105
 
106
+ where *CV12* is the union of *CV1* and *CV2*. The return type is shown
107
+ for exposition only; see  [[expr.mptr.oper]] for the determination of
108
+ the operator’s result type.
109
 
110
  For every pair of promoted arithmetic types *L* and *R*, there exist
111
  candidate operator functions of the form
112
 
113
  ``` cpp
 
142
 
143
  ``` cpp
144
  std::ptrdiff_t operator-(T, T);
145
  ```
146
 
147
+ For every *T*, where *T* is an enumeration type or a pointer type, there
148
+ exist candidate operator functions of the form
149
 
150
  ``` cpp
151
  bool operator<(T, T);
152
  bool operator>(T, T);
153
  bool operator<=(T, T);
154
  bool operator>=(T, T);
155
  bool operator==(T, T);
156
  bool operator!=(T, T);
157
  ```
158
 
159
+ For every pointer to member type *T* or type `std::nullptr_t` there
160
+ exist candidate operator functions of the form
161
 
162
  ``` cpp
163
  bool operator==(T, T);
164
  bool operator!=(T, T);
165
  ```
 
296
  [expr]: expr.md#expr
297
  [expr.ass]: expr.md#expr.ass
298
  [expr.call]: expr.md#expr.call
299
  [expr.cast]: expr.md#expr.cast
300
  [expr.cond]: expr.md#expr.cond
301
+ [expr.mptr.oper]: expr.md#expr.mptr.oper
302
  [expr.prim]: expr.md#expr.prim
303
  [expr.static.cast]: expr.md#expr.static.cast
304
  [expr.sub]: expr.md#expr.sub
305
  [expr.type.conv]: expr.md#expr.type.conv
306
  [expr.unary.op]: expr.md#expr.unary.op
 
359
  ignored.
360
 
361
  [^2]: The process of argument deduction fully determines the parameter
362
  types of the function template specializations, i.e., the parameters
363
  of function template specializations contain no template parameter
364
+ types. Therefore, except where specified otherwise, function
365
+ template specializations and non-template functions ([[dcl.fct]])
366
+ are treated equivalently for the remainder of overload resolution.
367
 
368
  [^3]: Note that cv-qualifiers on the type of objects are significant in
369
  overload resolution for both glvalue and class prvalue objects.
370
 
371
  [^4]: An implied object argument must be contrived to correspond to the