Surprise in template parameter substitution?

Question

N3690, § 14.8.2 paragraph 3 has this pretty mind blowing example:

template <class Z> void h(Z, Z*);
// #5: function type is h(int, const int*)
h<const int>(1,0);

Question: why is it not h(const int, const int*)?

From what know, Z = const int, so every occurence of Z in the template declaration can be read as const int, or am I missing something? Why pointer is different? I remember that when parameter has T& or T* it preserves cv-qualifiers of T, but I don't see any possibility to apply it here.

I don't think there is such a thing as `const` parameters for a function signature. Any parameter not passed by reference will be copied; the `const`ness of the supplied argument is irrelevant there. `const` only applies to the definition, which is an implementation detail. — KABoissonneault, May 15 '17 at 13:17

score 11 · Accepted Answer · edited May 23 '17 at 12:26

11

You need to see [dcl.fct]/5 for the reason why:

A single name can be used for several different functions in a single scope; this is function overloading (Clause 13). All declarations for a function shall agree exactly in both the return type and the parameter-type-list. The type of a function is determined using the following rules. The type of each parameter (including function parameter packs) is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type “array of T” or “function returning T” is adjusted to be “pointer to T” or “pointer to function returning T,” respectively. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type. The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function’s parameter-type-list. [ Note: This transformation does not affect the types of the parameters. For example, int()(const int p, decltype(p)) and int()(int, const int) are identical types. —end note ]

And in const type* the const is not a top level const qualifier.

edited May 23 '17 at 12:26

Community

1
1

answered May 15 '17 at 13:20

NathanOliver

171,901
28
288
402

Isn't this identical to the @StoryTeller's answer? The content looks the same, but paragraph numbers differ. – Incomputable May 15 '17 at 13:22
@Incomputable Looks like we both posted the same answer. I did not see theirs when I posted this(page had not refreshed). – NathanOliver May 15 '17 at 13:23
1

@Incomputable - It's because Nathan quoted a published standard and I a future standard draft. The paragraphs move some times. – StoryTeller - Unslander Monica May 15 '17 at 13:23
@NathanOliver I have it at `8.3.5/5` – Pavel P May 15 '17 at 13:35
@NathanOliver, accepting yours since it looks like your answer references C++14 standard. – Incomputable May 15 '17 at 13:38
@Incomputable OK. Don't feel like you have too though. You can StoryTeller's answer if you want to as the language is the same. – NathanOliver May 15 '17 at 13:45
2

Please use [dcl.fct]. Section numbers change all the time but section headings tend not to. For instance, in the latest draft, this is 11.3.5 now. – Barry May 15 '17 at 14:01
@Barry Updated. – NathanOliver May 15 '17 at 14:02
Hmm, which revision are you quoting? I have this at /5 in N3337 and N4140. – T.C. May 15 '17 at 16:08
1

@T.C. N3797 and that was a typo on my part. I copied paragraph 5 but 4 was on the top of my screen so when I looked for the number I saw 4 and used that. Answer has been updated. – NathanOliver May 15 '17 at 16:10

StoryTeller - Unslander Monica · Answer 2 · 2017-05-15T14:13:48.637

The reason is another standard paragraph:

[dcl.fct/5]

A single name can be used for several different functions in a single scope; this is function overloading. All declarations for a function shall agree exactly in both the return type and the parameter-type-list. The type of a function is determined using the following rules. The type of each parameter (including function parameter packs) is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type “array of T” or of function type T is adjusted to be “pointer to T”. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type. The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function's parameter-type-list. [ Note: This transformation does not affect the types of the parameters. For example, int()(const int p, decltype(p)) and int()(int, const int) are identical types. — end note ]

The rationalization for this is that to the caller it makes no difference if the parameter is cv-qualified; the steps to call the function as well as the conversion sequences for overload resolution are identical. So retaining const can in fact lead to ambiguity.

The cv-qualifier is in fact an implementation detail of the function, and has meaning only at the site of the functions definition (you won't be able to modify the parameter inside the function body).

score 2 · Answer 3 · edited May 23 '17 at 12:34

Because in general you need to remove cv-qualifiers from basic non-POD types.

In C++11 from § 8.3.5 Functions (p. 181):

5

A single name can be used for several different functions in a single scope; this is function overloading (Clause 13). All declarations for a function shall agree exactly in both the return type and the parametertype-list. The type of a function is determined using the following rules. The type of each parameter (including function parameter packs) is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type “array of T” or “function returning T” is adjusted to be “pointer to T” or “pointer to function returning T,” respectively. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type. The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function’s parameter-type-list. [ Note: This transformation does not affect the types of the parameters. For example, int()(const int p, decltype(p)) and int()(int, const int) are identical types. —end note ]

There was a similar question for cv-qualifiers with basic non-POD types.

Surprise in template parameter substitution?

3 Answers3

Linked