4

I just started on C++ so sorry if this is a newbie-ish question. I searched all over the web and didn't find anything about this. In fact I wasn't even sure how to formulate my search...

I saw this code somewhere:

template <class T> struct SomeStruct { SomeStruct() {} };

And later, this:

int main() { SomeStruct<void (Foo::*)(int test)> mStruct; }

The above compiles just fine.

So if I understood it correctly, "void (Foo::*)(int test)" is a function pointer that points to some function in Foo taking a int as argument and returning void.

How can that be a legal argument for the "class T" parameter?

Any help would be appreciated.

Improve this question

2 Answers 2

Reset to default
8

void (Foo::*)(int test) is a type of pointer to member function. A variable of such type can be used to point to member function of class Foo (that returns void and takes a single int argument).

class T is a misnomer there - arbitrary type can be used as a template parameter (the type doesn't have to be declared as class), regardless if the template is declared with template<class T> or template<typename T>.

For this reason I don't use the first form, only the latter.

In context of template parameter list of template declaration, typename and class can be used interchangeably, except you must use class in template template parameters (like template<template<typename, typename> class> before C++1z.

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

1 Comment

Well, sometimes you have no choice but to use the first form, but point taken.
5

It's a function pointer type. Perfectly legitimate.

The argument doesn't have to be an actual class; the use of class there is misleading, and is equivalent to the clearer typename.

If you want to really be freaked out, look up non-type template arguments, because you can in fact pass an actual function pointer (with a little modification). :)

Improve this answer

7 Comments

In my example, class T (or typename T) is a Type template parameter right? As per this (en.cppreference.com/w/cpp/language/template_parameters), the function pointer should be categorized as a non-type template argument. Then it states "A template parameter of the form class Foo is not an unnamed non-type template parameter of type Foo, even if otherwise class Foo is an elaborated type specifier and class Foo x; declares x to be of type Foo." I'm pretty freaked out now...
@WildonZimmer That reference is a bit confusing, but as far as I can tell, the list of possible things type can be under the "non-type" heading is simply meant to indicate limitations on what can be considered a "non-type" parameter--not to indicate that these items are invalid as template arguments for "type template parameters."
@WildonZimmer In other words, whether something is considered a "type" or "non-type" parameter is determined by the form of the template declaration, not by what's actually used to instantiate the template.
I think it would be worth editing your question to clarify that the CppReference document is the source (or at least one primary source) of your confusion. Otherwise, people sort of have to guess at why you're confused, so they're assuming that it's the word class that's throwing you off.
@KyleStrand In fact, I went searching for answer on the CppReference after reading Lightness Races in Orbit's answer, not the other way around. My example is a simplified version of some real code that I encountered. The fact that CppReference refers to class Foo just as I did is pure coincidence. :) But I think I got what you're saying.
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.