Why doesn't is_class<T> work in this code segment? - c++

Question

Trying to use is_class in the following segment (stripped down from a larger one), but it doesn't seem to work. What's wrong?
#include <type_traits>
template<typename U, typename = void>
struct xxxU_Impl
{
static void xxxU_push (const U& value);
};
template<typename U> void xxxU_push (const U& value) { xxxU_Impl<U>::xxxU_push (value); }
template<typename U>
struct xxxU_Impl<U *, typename std::enable_if<std::is_class<U>::value>::type>
{
static void xxxU_push (const U *& value) { }
};
class Foo
{
public:
int mFoo;
};
int main () {
Foo * pFoo = new Foo;
xxxU_push<Foo *>(pFoo);
}
This is with gcc v4.7.2 on cygwin with gcc -std=c++11 test.cpp command line.
The output is:
test.cpp: In instantiation of 'void xxxU_push(const U&) [with U = Foo*]':
test.cpp:26:23: required from here
test.cpp:9:63: error: no matching function for call to 'xxxU_Impl<Foo*, void>::xxxU_push(Foo* const&)'
test.cpp:9:63: note: candidate is:
test.cpp:14:17: note: static void xxxU_Impl<U*, typename std::enable_if<std::is_class<_Tp>::value>::type>::xxxU_push(const U*&) [with U = Foo]
test.cpp:14:17: note: no known conversion for argument 1 from 'Foo* const' to 'const Foo*&'
**
Update
:**
Here's the modified code with annotations which IMHO show that the types are now identical. Still, I'm getting a compile error.
#include <type_traits>
template<typename U, typename = void>
struct xxxU_Impl
{
static void xxxU_push (const U & value); // U=Foo*: const Foo* & value ==
// Foo const * & value
};
template<typename U> void xxxU_push (const U & value) // U=Foo*: const Foo* & value ==
// Foo const * & value
{ xxxU_Impl<U>::xxxU_push (value); }
template<typename U>
struct xxxU_Impl<U *, typename std::enable_if<std::is_class<U>::value>::type>
{
static void xxxU_push (U const * & value) { } // U=Foo: Foo const * & value
};
class Foo
{
public:
int mFoo;
};
int main () {
Foo* pFoo = new Foo;
xxxU_push<Foo*>(pFoo);
}
What's wrong?
Thx,
D
PS A similar scheme with is_enum works w/o a hitch.

Answer 1

The std::is_class<> trait is working fine, and the compiler is pretty much telling you what the problem is:
test.cpp:14:17: note: no known conversion for argument 1 from Foo* const to const Foo*&
You are invoking your function template this way:
xxxU_push<Foo *>(pFoo);
Which means that U will be Foo*. Now the function signature:
template<typename U>
void xxxU_push (const U& value)
Is equivalent to this:
template<typename U>
void xxxU_push (U const& value)
And after replacing Foo* for U you get this:
void xxxU_push (Foo* const& value)
Therefore, value is a constant reference to a pointer to a Foo. Inside the function, you instantiate your class template this way:
xxxU_Impl<U>::xxxU_push (value);
Which is, when substituting Foo* for U again:
xxxU_Impl<Foo*>::xxxU_push (value);
Now your class template specialization is defined this way:
template<typename U>
struct xxxU_Impl<U *, typename std::enable_if<std::is_class<U>::value>::type>
{
static void xxxU_push (const U *& value) { }
};
If you are instantiating it with Foo* as a template argument, U will be deduced to be Foo, which is a class type. Therefore, your class template gets instantiated without failures (not sure this is what you want, but this is definitely what happens), and in particular the xxxU_push() function gets instantiated this way:
static void xxxU_push (const Foo *& value) { }
Which is equivalent to this:
static void xxxU_push (Foo const*& value) { }
Can you see the difference? On the calling site you have a constant reference to a non-constant pointer, here you have a non-constant reference to a constant pointer! These two types are different, and the compiler complains that it cannot convert the argument.
You could fix your error, for instance, by changing the signature of xxxU_push() as follows:
static void xxxU_push (U * const& value) { }
// ^^^^^^^^^^
After this change, you can see the whole thing compiling here.
UPDATE:
As a follow-up from the comments, it turns out you necessarily want the static member function xxxU_push() to accept a pointer to const:
static void xxxU_push (Foo const*& value) { }
In this case, you will have to make a decision: you cannot pass a Foo* to a function which accepts a non-constant reference to a const pointer. You can, however, drop the reference:
static void xxxU_push (Foo const* value) { }
This is a first possibility to make your program compile. The second possibility is to change the call site so that it provides a pointer to const:
int main () {
Foo * pFoo = new Foo;
Foo const* pConstFoo = pFoo;
xxxU_Impl<Foo*>::xxxU_push(pConstFoo);
// ^^^^^^^^^
}