From Jason Turner

[over.match.ref]

C++20 → C++23 2.8 KB 38 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpmn357bhn/{from.md → to.md} +16 -19
tmp/tmpmn357bhn/{from.md → to.md} RENAMED
@@ -2,30 +2,27 @@
2
 
3
  Under the conditions specified in  [[dcl.init.ref]], a reference can be
4
  bound directly to the result of applying a conversion function to an
5
  initializer expression. Overload resolution is used to select the
6
  conversion function to be invoked. Assuming that “reference to *cv1*
7
- `T`” is the type of the reference being initialized, and “cv `S`” is the
8
- type of the initializer expression, with `S` a class type, the candidate
9
  functions are selected as follows:
10
 
11
- - The conversion functions of `S` and its base classes are considered.
12
- Those non-explicit conversion functions that are not hidden within `S`
13
- and yield type “lvalue reference to *cv2* `T2`” (when initializing an
14
- lvalue reference or an rvalue reference to function) or “*cv2* `T2`”
15
- or “rvalue reference to *cv2* `T2`” (when initializing an rvalue
16
- reference or an lvalue reference to function), where “*cv1* `T`” is
17
- reference-compatible [[dcl.init.ref]] with “*cv2* `T2`”, are candidate
18
- functions. For direct-initialization, those explicit conversion
19
- functions that are not hidden within `S` and yield type “lvalue
20
- reference to *cv2* `T2`” (when initializing an lvalue reference or an
21
- rvalue reference to function) or “rvalue reference to *cv2* `T2`”
22
- (when initializing an rvalue reference or an lvalue reference to
23
- function), where `T2` is the same type as `T` or can be converted to
24
- type `T` with a qualification conversion [[conv.qual]], are also
25
- candidate functions.
26
 
27
  The argument list has one argument, which is the initializer expression.
28
 
29
- [*Note 1*: This argument will be compared against the implicit object
30
- parameter of the conversion functions. — *end note*]
31
 
 
2
 
3
  Under the conditions specified in  [[dcl.init.ref]], a reference can be
4
  bound directly to the result of applying a conversion function to an
5
  initializer expression. Overload resolution is used to select the
6
  conversion function to be invoked. Assuming that “reference to *cv1*
7
+ `T`” is the type of the reference being initialized, the candidate
 
8
  functions are selected as follows:
9
 
10
+ - Let R be a set of types including
11
+ - “lvalue reference to *cv2* `T2`” (when initializing an lvalue
12
+ reference or an rvalue reference to function) and
13
+ - “*cv2* `T2`” and “rvalue reference to *cv2* `T2`” (when initializing
14
+ an rvalue reference or an lvalue reference to function)
15
+
16
+ for any `T2`. The permissible types for non-explicit conversion
17
+ functions are the members of R where “*cv1* `T`” is
18
+ reference-compatible [[dcl.init.ref]] with “*cv2* `T2`”. For
19
+ direct-initialization, the permissible types for explicit conversion
20
+ functions are the members of R where `T2` can be converted to type `T`
21
+ with a (possibly trivial) qualification conversion [[conv.qual]];
22
+ otherwise there are none.
 
 
23
 
24
  The argument list has one argument, which is the initializer expression.
25
 
26
+ [*Note 1*: This argument will be compared against the object parameter
27
+ of the conversion functions. — *end note*]
28