Re: Specializing Perfect Forwarding Templates?

On 3/15/2011 10:22 PM, Scott Meyers wrote:


Couple issues here. T can never cause reference "decay". If T is an
lvalue reference then you have the strange parameter type "T&*&&". If T
is an rvalue reference then you have the strange parameter type
"T&&*&&". To implement a perfect forwarding function you need to be
relying on the fact that & && is & and && && is && so that when T is an
lvalue reference, the parameter to the function is, and visa-versa.

Second issue is that std::forward works similarly. It's simply a
template function that takes a T&& and returns T.

Since the parameter for your function is always going to be an rvalue
reference you can expect that lvalue references can't be passed into it
without calling std::move.

You can do what you're trying to do with a dispatching pattern:

#include <iostream>
#include <type_traits>

template < bool Match >
struct function_impl
{
   template < typename T >
   static void apply(T&& t)
   {
     std::cout << "Generic version called.\n";
   }
};

template < >
struct function_impl<true>
{
   template < typename T >
   static void apply(T&& t)
   {
     std::cout << "Specific version called.\n";
   }
};

template < typename T >
void f(T&& t)
{
   function_impl< std::is_pointer< typename
std::remove_reference<T>::type >::value >::apply(std::forward<T>(t));
}

int * get_ptr() { return nullptr; }
int get_value() { return 0; }

int main()
{
   int val = get_value();
   int * ptr = get_ptr();

   f(val);
   f(ptr);
   f(get_value());
   f(get_ptr());
}

Specific needs may of course mean a more complicated construct.

--
http://crazycpp.wordpress.com