Recursive template?

Rephrased Question

I found that my original question wasn't clear enough and the repliers misunderstood my problem. So let me try to clarify:

Let's say I have two classes:

struct C { void(*m_func)(C*); };
struct D { std::function<void(D*)> m_func; };

Now I want to make a generic version of the two, so I do something like this:

template<typename Func>
struct G
{
Func m_func;
};

But now I don't know 开发者_开发技巧how to instantiate this class:

G<void(*)(G*)> c;  //error
G<std::function<void(G*)>> d;  //error

G<void(*)( G<void(*)(G<???>*)> *)> c;  //???
G<std::function<void( G<std::function<void(G<???>*)>> *)>> d;  //???

Original Question:

Hi,

I have a template class that can take a function pointer or a std::function object as its parameter. All is fine until that function uses a pointer of the template class in its signature:

#include <functional>

template<typename Func>
class C
{
public:
    C() {}
    Func m_func;
};

void foo()
{
    C<void(*)(C*)> c;
    C<std::function<int(C*)>> d;
}

Relevant compiler errors:

error C2955: 'C' : use of class template requires template argument list
error C3203: 'function' : unspecialized class template can't be used as a template argument for template parameter 'Func', expected a real type
error C2955: 'std::tr1::function' : use of class template requires template argument list

How do it solve this problem?

---

You can't name the recursive template outside itself, but you can name it inside, as the parameter list is optional in a self-reference.

The problem then becomes one of telling the template how to pass itself to "something."

template< typename T >
struct fptr_taking_type {      // this template is essentially a function
    typedef void (*type)( T ); // from types to types, the result being
};                             // the typedef

template< typename T >
struct stdfn_taking_type {
    typedef function< void (*)( T ) > type;
};

template< template< typename > class F >
struct G {
    typename F< G * >::type m_func; // this declares the member variable
};

...

G< fptr_taking_type > q;

---

C is a class template, not a class. You can't have an object of type C or a pointer to a C; you can only have objects of instantiations of C, like C<int> or C<float>.

---

In this line:

   C<void(*)(C *)> c;

The bolded C (emphasis added) does not specify template parameters. You should specify what type of C* this function pointer takes, by specifying a type in <> brackets.

---

Does this help?

void foo1(){}

template<typename Func> 
class C 
{ 
public: 
    C(Func f) : m_func(f) {} 
    Func m_func;
    C<Func> *mp;                 // it is a pointer,
}; 

void foo() 
{ 
    C<void (*)(void)> c (foo);
} 

int main(){
    C<void (*)(void)> c(foo);
}

---

You cannot have a recursive template.