Special overload for pointer types

Question

Consider the following snippet:

template <class T>
struct remove_pointer
{
};

template <class T>
struct remove_pointer<T*>
{
    typedef T type;
};

template <typename T>
T
clone(const T& v)
{
    return v;
}


template <typename T, typename U = typename remove_pointer<T>::type>
T
clone(const U& v)
{
    return new U(v);
}


int main() 
{
    auto foo = clone<double>(42.0);
    return 0;
}

This code generates compilation errors:

 In function 'int main()':
30:34: error: call of overloaded 'clone(double)' is ambiguous
30:34: note: candidates are:
14:1: note: T clone(const T&) [with T = double]
22:1: note: T clone(const U&) [with T = double; U = double]

Why is the compiler deriving T=double, U=double in line 22? I thought it only should pass if T is a pointer type.

default template is only used when not provided or deduced. it is deduced here. — Jarod42, Jan 21 '20 at 16:21
Understood! Can can I make the specialised overload only pass if T is a pointer? — user3612643, Jan 21 '20 at 16:23
you want to be able to have `clone(42.0)`. but what for `double* p = /*..*/; clone(p)`? — Jarod42, Jan 21 '20 at 16:28
what are you trying to achieve? If `clone` gets a `T*` it should return a `T` ? — 463035818_is_not_an_ai, Jan 21 '20 at 16:28
@formerlyknownas_463035818 For the code "as written" it would be the other way around (the second `clone` takes the non-pointer type and returns the pointer type, both in signature and body). — Max Langhof, Jan 21 '20 at 16:29
@MaxLanghof well, I have problems to take the code literally, because I am not sure if thats what OP initially aimed for — 463035818_is_not_an_ai, Jan 21 '20 at 16:30
The code is a very reduced snippet of a library for binding c++ code to Dart FFI. I know the code looks weird standalone because I reduced it the core issues. — user3612643, Jan 21 '20 at 18:31

eerorika · Answer 1 · 2020-01-21T16:30:28.020

Why is the compiler deriving T=double, U=double in line 22? I thought it only should pass if T is a pointer type.

Because template arguments are deduced based on passed non-template arguments. You passed a double literal into an argument of type const U&, so U was deduced to be double. The default of the template argument is not used if the argument is deduced.

And the problem is that both the single template argument, as well as the two template argument overloads can be called with the same argument list, so the compiler doesn't know which overload you intended to call.

score 2 · Accepted Answer · answered Jan 21 '20 at 16:59

Compiler deduced U=double and didn't use your default argument at all. I think that you can try to have two different overloads for your clone function based on this answer.

Your example might look like this:

#include <iostream>
#include <type_traits>

template <typename T>
T
clone(const T& v, typename std::enable_if<!std::is_pointer<T>::value >::type* = 0)
{
    std::cout << "non ptr clone" << std::endl;
    return v;
}

template <typename T>
T
clone(const T v, typename std::enable_if<std::is_pointer<T>::value >::type* = 0)
{
    std::cout << "ptr clone" << std::endl;
    using noptrT = typename std::remove_reference<decltype(*v)>::type;
    return new noptrT(*v);
}

int main()
{
    auto foo = clone<double>(42.0);
    std::cout << foo << std::endl;
    double* ptr = new double(69.69);
    auto bar = clone<double*>(ptr);
    std::cout << *bar << std::endl;
    delete ptr;
    delete bar;
    return 0;
}

Note that this solution also allows you to pass a function pointer

void fun() {}
...
clone<void(*)()>(fun);

which will result in compilation error (new cannot be applied to function type).

Max Langhof · Answer 3 · 2020-01-21T16:43:15.153

clone<double>(42.0);

could either mean

"instantiate the first clone with the explicit template argument double", or
"instantiate the second clone with the first argument explicitly given as double and the second one deduced from 42.0 being passed in place of const U& v". The default value you provide is ignored, U is deduced from matching double to const U&.

The compiler can't decide which one you meant, so you get an error. Maybe you intended to use SFINAE to specialize the function template. But specializing function templates is strongly discouraged (http://www.gotw.ca/publications/mill17.htm).

One way to express what you want would be if constexpr: https://godbolt.org/z/_YGXGc

But the semantics of this function are still quite weird. Sometimes the function returns a heap-allocated pointer and sometimes it returns a value. The user has to pass the target type (in both cases or just one?). This will be really confusing at the call site.

Special overload for pointer types

3 Answers3