Что-то не могу сообразить с синтаксисом:

Так работает :

struct a
{
    template<typename T>
    void f(T* p);
};

template<>
void a::f<char const>(char const* p)
{
}

А так нет :

template<typename A>
struct a
{
    template<typename T>
    void f(T* p);
};

template<typename A>
template<>
void a<A>::f<char const>(char const* p)
{
}

Подскажите как правильно сделать.

Спасибо.

Здравствуйте, _nn_, Вы писали:

__>Что-то не могу сообразить с синтаксисом:

А так не подходит?

template<typename A, typename T>
struct a
{
    void f(T* p);
};

template<typename A, typename T>
void a<A, T>::f(T* p)
{
}

a<int, char const> A;
A.f("aaa");

Здравствуйте, _nn_, Вы писали:

_>А так нет :

__>template<typename A>
__>struct a
__>{
__>    template<typename T>
__>    void f(T* p);
__>};

__>template<typename A>
__>template<>
__>void a<A>::f<char const>(char const* p)
__>{
__>}

так нельзя так по стандарту (14.7.3 / 18)
а почему бы не использовать простую перегрузку

template<typename A>
struct a
{
    template<typename T>
    void f(T* p);

    void f(char const*);

};

template<typename A>
template<typename T>
void a<A>::f(T* p)
{
}

template<typename A>
void a<A>::f(char const* p)
{
}

Здравствуйте, _nn_, Вы писали:

Зачем тебе такие страсти потребовались?!
В конце концов, можно же обойтись перегрузкой вместо специализации.

А если очень хочется, чтобы параметр шаблона функции был свободным (задаваемым через <>), а не выводимым из фактических аргументов, то на:

template<class T> struct t2t {};

template<class A>
struct a
{
  template<class F> int foo()
  { return foo_imp(t2t<F>()); }

  // перегрузка. F - связанный параметр
  template<class F> int foo_imp(t2t<F> _);
  int foo_imp(t2t<const char*> _);
};

template<class A>
template<class F>
int foo_imp(t2t<F> _) { ..... }

template<class A>
int foo_imp(t2t<const char*> _) { ..... }

Здравствуйте, korzhik, Вы писали:

K>Здравствуйте, _nn_, Вы писали:

_>>А так нет :
K>

__>>template<typename A>
__>>struct a
__>>{
__>>    template<typename T>
__>>    void f(T* p);
__>>};

__>>template<typename A>
__>>template<>
__>>void a<A>::f<char const>(char const* p)
__>>{
__>>}
K>

K>так нельзя так по стандарту (14.7.3 / 18)
Я так и подозревал...
K>а почему бы не использовать простую перегрузку
Искал более общий путь.
Т.е. чтобы можно было бы объявить в классе, а потом перегружать не изменяя объявление класса.