功能模板参数的类型推导

Question

I have some questions concerning function templates.

My plan was to build a wrapper which derives from a user-defined class and not only exports the public functions of that class but also its constructors. So I decided I would use multiple constructor templates (which I presume work exactly the same as function templates) with 1 to n parameters to satisfy most constructors needs.

These would than simply call the constructor and do something else afterwards, like this:

template <class T>
class Wrapper : public T
{
    public:
        template <class U>
        Wrapper(U &u) : T(u) { doSomething(); }

        template <class U, class V>
        Wrapper(U &u, V &v) : T(u,v) { doSomething(); }

        ...
};

My intent is to register the instance within the Wrapper-Ctor somewhere else and, from that point on, it can receive calls to virtual functions defined in T.

I had to use the reference operator in the code above, in order to guarantee that my Wrapper-Ctor does not have any side-effects on the parameters that were passed (copy-construction).

To my surprise this always worked, except for temporaries, which is the reason why I am confused about the types that are inferred by the compiler in this situation. To simplify the situation I tried to do something similiar via a template function:

template <class T>
void foo(T &t)
{
    int x = ""; // intentional error
}

Calling the function like this:

std::string a; 
std::string &b = a;
foo(b);

To my surprise the compiler denotes [T = std::string] in its error message. I would have expected for this to be [T = std::string&], which would have caused passing a reference-to-reference, which is invalid.

So, why does the compiler deduce a value-type in this situation? Is it even possible to create a Wrapper-Ctor that does what I want, does not have any side-effects on the parameters and also accepts temporaries?

Thanks alot!

Answer 1

It looks like the C++ spec explicitly states that this is the intended behavior. Specifically, if you have a template function that takes in a parameter P that depends on a template type argument, if P is a reference, then the underlying type of the reference, rather than the reference type, is used to determine what type should be used for P (see §14.8.2.1/2). Moreover, this same section says that const and volatile qualifiers are ignored during this step, so the const ness can be inferred automatically.

Answer 2

在C ++ 03中，如果没有为const和non-const参数的每个组合手动进行重载，就不可能提供这样的东西。

Answer 3

No expression ever has reference type. Therefor, when argument deduction deduces against the argument expression type, it cannot make a distinction between a and b because the arguments a and b both have the same type.

Refer to [expr]p5 in the spec

If an expression initially has the type "reference to T" (8.3.2, 8.5.3), the type is adjusted to T prior to any further analysis.

Answer 4

Somewhat late, but since I don't think this was answered completely...

For template parameter deduction, see the previous answers.

For your problem with temporaries, make the parameters const references (as in Wrapper(const U&)).

The thing is, temporaries are rvalues. The standard states that non-const references can only be bound to lvalues. Therefore, a standards compliant compiler won't let you pass temporaries(rvalues) as arguments to non-const reference parameters. (This doesn't have anything to do with templates in particular, it's a general rule).

This is to the best of my knowledge, so take it with a bit of scepticism.