Is it possible to make a template function friend to a Template Specialization Class?

I have a template specialization class and I need to declare a function template as a friend to this class. I have already created the following code which compiles and works well on the MSVC compiler but it doesn't work on the code-warrior compiler. To make it work on the codewarrior compiler I have to uncomment the explicit declarations in the template specialization class.

Is this a problem with the codewarrior compiler or some problem with the code?

Reduced code size to give context:

//template class
template<class R>
class Alice
{
    public:
            Alice() {}

    private:
        R review;

    template< class F>
    friend void Watch(F, Movie::Wonderland< Alice<R> >&, int);

};

//template specialization class
template<>
class Alice<void>
{
    public:
            Alice() {}

    private:
        int review;

    template<class F>
    friend void Watch(F, Movie::Wonderland< Alice< void > >&, int);

    /*
    //explicit declaration
    //need to uncomment this to compile on codewarrior 
    //as the function template above doesn't work.
    friend void Watch<void (*)()>(void (*)(), Movie::Wonderland<Alice<void> > &, int);
    */
};

Full code:

#define ONCE 1
#define NULL
namespace Movie{
template<class C>
class Wonderland
{
    public:
        Wonderland():who(NULL){}
        Wonderland(C* she):who(she){}
        void Attach(C *she)
        {who = she;}
        C* operator->()
        {return who;}
    private:
        C* who;
};
}
//fwd declarations
template<class R> class Alice;
void Watch(Movie::Wonderland< Alice<void> >& theatre, int price);
template<class F> void Watch(F func, Movie::Wonderland< Alice<void> >& theatre, int price);
template<class P, class F> void Watch(F func, P food, Movie::Wonderland< Alice<void> >& theatre, int price);
struct popcorn;

template<class R>
class Alice
{
    public:
            Alice() {}

    private:
        R review;

    friend void Watch(Movie::Wonderland< Alice<R> >&, int);

    template< class F>
    friend void Watch(F, Movie::Wonderland< Alice<R> >&, int);

    template<class P, class F>
    friend void Watch(F, P, Movie::Wonderland< Alice<R> >&, int);
};

template<>
class Alice<void>
{
    public:
            Alice() {}

    private:
        int review;

    friend void Watch(Movie::Wonderland< Alice< void > >&, int);

    template<class F>
    friend void Watch(F, Movie::Wonderland< Alice< void > >&, int);

    template<class P, class F>
    friend void Watch(F, P, Movie::Wonderland< Alice< void > >&, int);

    /*
    //explicit declarations
    friend void Watch(Movie::Wonderland<Alice<void> > &, int);
    friend void Watch<void (*)()>(void (*)(), Movie::Wonderland<Alice<void> > &, int);
    friend void Watch<void (*)(), void (*)()>(void (*)(), void (*)(), Movie::Wonderland<Alice<void> > &, int);
    friend void Watch<popcorn, void (*)()>(void (*)(开发者_如何学运维), popcorn, Movie::Wonderland<Alice<void> > &, int);
    */
};

//template<class R>
void Watch(Movie::Wonderland< Alice<void> >& theatre, int price) 
{
    theatre.Attach(new Alice<void>);
    int review = theatre->review;
    return;
}

template<class F>
void Watch(F func, Movie::Wonderland< Alice<void> >& theatre, int price) 
{
    theatre.Attach(new Alice<void>);
    int review = theatre->review;
    return;
}

template<class P, class F>
void Watch(F func, P food, Movie::Wonderland< Alice< void > >& theatre, int price)
{
    theatre.Attach(new Alice<void>);
    int review = theatre->review;
    return;
}

void goWatch(void)
{
    return;
}

void eatPopcorn(void)
{
    return;
}

struct popcorn
{

};

int main()
{
    struct popcorn sweetPopcorn;
    Movie::Wonderland< Alice<void> > theatre;
    Watch(goWatch, theatre, ONCE);
    Watch(goWatch, eatPopcorn, theatre, ONCE);
    Watch(theatre, ONCE);
    Watch(goWatch, sweetPopcorn, theatre, ONCE);
}

---

I have reviewed your code, and tested it against two compilers: g++-4.2 and clang++. I do not see any problems regarding your friend declarations.