Select function based on if template is pointer/reference or none

Question

I would like to provide different implementations of a function dependant on if it is a pointer, a reference or a regular type. This is my code so far:

template<class T,
         class = typename std::enable_if_t<std::is_reference<T>::value>>
void f(T && in)
{}

// This causes redefinition error 
template<class T,
    class = typename std::enable_if_t<std::is_pointer<T>::value>>
void f(T && in)
{}

template<class T,
    class = typename std::enable_if_t<!std::is_reference<T>::value>,
    class = typename std::enable_if_t<!std::is_pointer<T>::value>>
void f(T && in)
{}

The middle function causes:

12:13: error: redefinition of 'template void f(T&&)'

7:13: note: 'template void f(T&&)' previously declared here

Funnily only the first and last function together compile.

Any ideas how to fix it or simplify this code.

Default template parameters are not part of template signature. So of these 3 templates first two have the same signature, while third one takes 3 template parameters. — user7860670
– user7860670, Commented Nov 28, 2018 at 16:18
Why not just have the overloads void f(T*), void f(T&), and void f(T)? — NathanOliver
– NathanOliver, Commented Nov 28, 2018 at 16:19
@NathanOliver: How do I do void f(T&&) as not forwarding reference? I mean I could do the whole process reverse but not sure if it makes things easier. — Andreas Pasternak
– Andreas Pasternak, Commented Nov 28, 2018 at 16:23

Pete Becker · Accepted Answer · 2018-11-28 16:24:54Z

10

The usual way is to provide appropriate overloads:

#include <iostream>

template <class T> void f(T&&) {
    std::cout << "T&&\n";
}

template <class T> void f(T*) {
    std::cout << "T*\n";
}

template <class T> void f(T&) {
    std::cout << "T&\n";
}

int main() {
    int i;
    f(std::move(i));
    f(&i);
    f(i);
}

This produces the following output:

[temp]$ clang++ -std=c++11 test.cpp
[temp]$ ./a.out
T&&
T*
T&
[temp]$

answered Nov 28, 2018 at 16:24

Pete Becker

77.2k8 gold badges82 silver badges171 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Andreas Pasternak Over a year ago

How do I deal with const references and pointers? Do I not need an additional overload for those then aswell?

Pete Becker Over a year ago

@AndreasPasternak -- you need overloads for whichever types you want to distinguish. This answer addresses the types you mentioned in your question and in your code.

David G · Accepted Answer · 2018-11-28 18:25:32Z

5

Template default argument values are not part of the signature, so you need to further disambiguate the overloads by - as an example - adding an extra dummy template parameter:

template<class T,
         class = typename std::enable_if_t<std::is_reference<T>::value>>
void f(T && in)
{}

// This causes redefinition error 
template<class T,
    class = typename std::enable_if_t<std::is_pointer<T>::value>, class = void>
void f(T && in)
{}

edited Nov 28, 2018 at 18:25

David G

97.6k41 gold badges173 silver badges258 bronze badges

answered Nov 28, 2018 at 16:18

Vittorio Romeo

94.1k37 gold badges276 silver badges451 bronze badges

1 Comment

Andreas Pasternak Over a year ago

Great, this compiles. I'll accept if it also works as intended. Thank you so far!

Collectives™ on Stack Overflow

Select function based on if template is pointer/reference or none

2 Answers 2

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related