Variadic templates with 'const' parameter overloading

Question

Reduced sample code:

#include <iostream>

template<typename T>
void func(T &x)
{
    std::cout << "non-const " << x << std::endl;
}

template<typename T>
void func(const T &x)
{
    std::cout << "const " << x << std::endl;
}

template<typename ...ARGS>
void proxy(ARGS ...args)
{
    func(args...);
}

int main()
{
    int i = 3;

    func(i);
    func(5);
    func("blah");

    proxy(i);
    proxy(5);
    proxy("blah");
}

Expected output:

non-const 3
const 5
const blah
non-const 3
const 5
const blah

Actual output:

non-const 3
const 5
const blah
non-const 3
non-const 5
non-const blah

So somehow the const qualifier of the function parameter gets lost when put through the variadic template. Why? How can I prevent this?

PS: tested with GCC 4.5.1 and SUSE 11.4

It has nothing to do with variadic templates. Your function template proxy's parameters are non-references, so the const of the function arguments is ignored when deducing the template arguments. — Cosyn, Apr 20 '12 at 13:31

score 20 · Accepted Answer · edited Apr 20 '12 at 13:27

20

You just stumble upon the forwarding problem. This issue is solved using perfect forwarding.

Basically, you need to take your parameters by rvalue-reference, and rely on std::forward to correctly forward them while keeping their nature:

template<typename ...Args>
void proxy(Args&& ...args)  
{
    func(std::forward<Args>(args)...);
}

edited Apr 20 '12 at 13:27

R. Martinho Fernandes

228,013
71
433
510

answered Apr 20 '12 at 12:30

Luc Touraille

79,925
15
92
137

Don't you need `std::forward`? – juanchopanza Apr 20 '12 at 12:35
@juanchopanza No. That would pass all the type arguments to `std::forward`, but `std::forward` has only one type argument. – R. Martinho Fernandes Apr 20 '12 at 12:59
@R.MartinhoFernandes Right, forward also takes only one parameter, so I guess we need `func(std::forward(args)...);` or something like that? the sample in the answer doesn't compile on my gcc4.7 snapshot. – juanchopanza Apr 20 '12 at 13:26
@juanchopanza Yeah, you're right. I tried to fix it and forgot about `args`. Ooops. – R. Martinho Fernandes Apr 20 '12 at 13:28
@R.MartinhoFernandes Thanks for the correction! I had tried the code I gave initially, but it worked only by accident: the sample code in the question uses a single argument :). – Luc Touraille Apr 20 '12 at 15:42

score 6 · Answer 2 · answered Apr 20 '12 at 13:21

As Luc already mentioned this is a problem of forwarding and the answer to how to prevent it is to use perfect forwarding. But I will try to address the other questions at the end:

So somehow the const qualifier of the function parameter gets lost when put through the variadic template. Why?

This has everything to do with type inference. Ignore that you are using variadic templates and consider the simplest one argument template:

template <typename T>
void one_arg_proxy( T arg ) {
   func( arg );
}

At the place of call you have one_arg_proxy( 5 ), that is, the argument is an int rvalue. Type inference kicks in to figure out what the type T should be, and the rules dictate that T is int, so the call gets translated to one_arg_proxy<int>(5) and the instantiation of the template that gets compiled is:

template <>
void one_arg_proxy<int>( int arg ) {
   func( arg );
}

Now the call to func takes an lvalue argument, and thus the version of func taking a non-const reference is a better match (no conversions required) than the one taking a const&, yielding the result that you are getting. The issue here is that func does not get called with the argument to proxy, but rather with the internal copy that proxy made of it.

Variadic templates with 'const' parameter overloading

2 Answers2