C++ template <R(*)(T)> meaning - c++

Question

What does the following template do in C++?
template <class R, class T>
struct my_type<R(*)(T)> { typedef T type; };
Specifically, what does the * stand for in this context?

Answer 1

In this context it makes the template specialization refer to a pointer to a function, which is declared to accept a single argument of type T, and return a value of type R. The specialization extracts the argument type and makes it available as a typedef.
Example (demo):
#include <iostream>
#include <type_traits>
int foo(float);
template <typename T>
struct my_type;
template <class R, class T>
struct my_type<R(*)(T)> { typedef T type; };
int main() {
std::cout
<< std::is_same<
float,
typename my_type<decltype(&foo)>::type
>::value
<< "\n";
return 0;
}
This outputs 1 because float and typename my_type<decltype(&foo)>::type both refer to the same type -- decltype(&foo) is the type int (*)(float), which matches the specialization R(*)(T).

Answer 2

Great answer above by cdhowie, but I feel it's more explaining what template specialization does, and not so much answers the specific question: what does the * stand for in R(*)(T).
For that, we need to take a look at how we specify types in C++'s type system. Don't be offended if you already know most or all this, but I think I can best explain it if I just start with the basics. If not you, perhaps someone else can learn from this (I myself was pretty confused by C(++)'s type system, coming from Pascal :)). If you just want the answer, it's the last sentence of this post.
Say we want to declare a variable named foo that is of type int.
int foo;
Well, that's easy enough. Now, let's change that to be an array of 3 ints:
int foo[3];
It's important to realize what we've done here. You might be tempted to think that array specifiers simply go last, but that's not the case. Because, to declare an array of something, we need to add brackets right after the identifier that names our variable, or foo in this case. This becomes clear when you want to extend this declaration to be an array of 2 × int[3]:
int foo[2][3];
So, by substituting foo with foo[2] in the declaration int foo[3], we get to int foo[2][3]. And that's why foo is an array of 2 × [array of 3 × int]. This becomes more apparent when we add parentheses (which we are in fact allowed to do):
int foo; // [int]
int (foo[3]); // array of 3×[int]
int ((foo[2])[3]); // array of 2×[array of 3×[int]]
C++ uses a similar system for pointers. To declare a pointer to something, prefix the identifier with a *.
int foo; // [int]
int (*foo); // pointer to [int] (same as: int *foo)
int (*(*foo)); // pointer to [pointer to [int]] (same as: int **foo)
So, we've substituted foo with (*foo) on every next line.
This is where things get interesting. We need to prefix the identifier with a * for a pointer, and postfix it with [] for an array, but then, what does int *foo[3] mean? As it turns out, int *foo[3] is parsed as int *(foo[3]). So, it is an array of 3 × [pointer to int]. To get a pointer to [array of 3 × int], we need to do: int (*foo)[3]
int *(foo[3]); // array of 3×[pointer to [int]] (same as: int *foo[3])
int (*foo)[3]; // pointer to [array of 3×[int]]
Now, to answer your question, we need to look at function declarations. This is actually similar to arrays. To declare a function, add parentheses and a list of arguments right after the identifier:
int foo; // [int]
int (foo()); // function returning [int] (same as: int foo())
Now we can also apply above rules:
int foo; // [int]
int (foo()); // function returning [int] (same as: int foo())
int ((*foo)()); // pointer to [function returning [int]] (same as: int (*foo)())
int ((*(foo[2]))()); // array of 2×[pointer to [function returning [int]]] (same as: int (*foo[2])())
To name a type without the identifier, simply erase the identifier. So the type of the third foo in above example is simply int(*)(). Note that the parentheses here are mandatory. If it were int*(), it would be a function returning [pointer to [int]].
Tip: to figure out the type of something, use a bottom-up approach, starting at the identifier (or where the identifier would be), working outward, using the following annotations: * stands for "pointer to...", [] for "array of..." and (x) for "function taking (x) and returning...". As a rule of thumb: if there are no parentheses, the right hand side goes before the left hand side.
Now we can answers your question: the * in R(*)(T) stands for: a pointer to a function that takes a T as argument and returns an R.