What does void (U :: *) (void) mean?

Question

I looked at the implementation of the is_class template in Boost and came across some syntax that I cannot easily decrypt.

  template <class U> static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); template <class U> static ::boost::type_traits::no_type is_class_tester(...); 

How to interpret void(U::*)(void) above? I am familiar with C, so it looks somewhat similar to void(*)(void) , but I don’t understand how U:: changes the pointer. Can anyone help?

thanks

Answer 1

* indicates a pointer, because you can access its contents by writing *p . U::* points to a member of class U You can access its contents by writing u.*p or pu->*p (where U is an instance of U ).

So, in your example, void (U::*)(void) is a pointer to a member of U , which is a function that takes no arguments and does not return a value.

Example:

 class C { void foo() {} }; typedef void (C::*c_func_ptr)(void); c_func_ptr myPointer = &C::foo; 

Answer 2

Start with U, then turn inside out.

The declared type is a pointer to a member function from class U that takes invalid arguments and returns void.

Answer 3

You are right, this is similar to a function pointer. Rather, it is a pointer to a member function, where the member has class U

A type difference is required because member functions have an implicit this pointer, since they cannot be called without an instance. Getting rid of the template can make this a little easier:

 struct foo { void bar(void); }; 

void(*)(void) will not work, since this is not a way to tell an instance of a class. Rather, we need:

 void (foo::*)(void) 

Indicating that this function pointer requires an instance of foo .

---

What are you standing for? You use them like this:

 typedef void (foo::*func_ptr)(void); foo f; foo* fp = &f; func_ptr func = &foo::bar; (f.*func)(); (fp->*func)(); 

Answer 4

This is a pointer to a member function of class U. It is very similar to

invalid (*) (invalid)

but it points to a member function of class U.

Answer 5

I was about to ask the same question, but it has already been asked. Unfortunately, none of the existing answers answered the question. Not for me, at least. I had to figure it out. I wanted to ask the same question as the OP, plus some. My question is: WTF is is_class_tester (void (U::*)(void)) stuff, and how does this construct work in the SFINAE context (replacement error is not an error)?

With some simplification, Boost uses the construct as follows:

 template <typename U> char is_class_tester (void (U::*)(void)); template <typename U> TypeBiggerThanChar is_class_tester (...); template <typename T> struct IsClass { static const bool value = sizeof (is_class_tester<T>(0)) == 1; }; 

Some observations:

• These functional patterns are not really functional patterns. These are just cutting-edge ads for a couple of overloaded function templates. Function templates themselves are never defined. Seeing that this is so, and understanding how it works without the need to create patterns ever defined is one of the key elements in understanding this design.
• The answers that talked about how to use this first function template missed the boat. You cannot use this function template because its definition does not exist.
• Note that thanks to this argument, the first of the two function templates makes sense only when the type T is a class. Fundamental types and pointers do not have member functions. The first declaration is invalid syntax for nonclassical types.
• Contrast this with the second of the overloaded function templates, which is a valid syntax for all template parameters, and the function (if it existed) will accept any arguments superimposed on it thanks to its variadic argument .... (Other than that: it vaguely reminds me of favorite single-line C program that can solve any problem in the world, given properly formatted user input.)
• While function template declarations cannot be used as functions, declarations can be used in simple compile-time queries, such as a return type request. An actual definition is not required for this kind of query. Only a prototype is required.
• This is exactly what the IsClass class template IsClass to determine the compile time constant IsClass<SomeType>::value .

So how IsClass<SomeType>::value get its value and how does it do it at compile time? The compiler should either make sense of sizeof (is_class_tester<T>(0)) , or abandon the attempt. We need to look at two cases, based on whether the type is SomeType or not a class.

Case 1: SomeType is a class.
Here, both template declarations are valid syntax, so the compiler has two viable candidates to choose from. The compiler can and should have the first function template, because the selection rules dictate that the variational function receives the lowest priority in the selection. This selected function returns char. Since sizeof (char) is guaranteed to be 1, IsClass<SomeType>::value will be true if SomeType is a class.

Case 2: SomeType not a class.
This is where SFINAE is called. Declaring the first function is invalid syntax. The compiler cannot just abandon it because of SFINAE. He should continue to look for an alternative, and the second declaration of the function template matches the bill. The only viable function returns TypeBiggerThanChar , the definition is gone, but hopefully obvious. All we want is sizeof () this thing. This is more than char, so IsClass<SomeType>::value will be false if SomeType not a class.