Специализация частичных методов C ++

Если у вас уже есть специализированный класс, вы можете дать другую реализацию foo в специализированном классе:

template<typename A, typename B>
class C
{
public:
    void foo() { cout << "default" << endl; };
};

template<typename A>
class C<A, CObject>
{
public:
  void foo() { cout << "CObject" << endl; };
};

Чтобы специализировать функцию-член в Visual C ++ 2008, вы также можете сделать ее шаблоном:

template<typename A, typename B>
class C
{
  template<typename T>
  void foo();

  template<>
  void foo<CObject>();
};

Похоже, что приведенное выше решение будет доступно только в будущем стандарте C ++ (согласно проекту n2914 14.6.5.3/2).

Думаю, тут недоразумение.

Есть два вида шаблонов:

• классы шаблонов
• методы шаблона

В вашем примере у вас есть класс шаблона, который, конечно, содержит некоторые методы. В этом случае вам придется специализироваться на классе.

template <class A>
class C<A,CObject>
{
  void foo() { ... } // specialized code
};

Проблема в вашем примере относительно проста: вы определяете метод foo для специализации C, но эта специализация никогда не была объявлена ​​ заранее.

Проблема здесь в том, что вам нужно полностью специализировать свой класс C (и, таким образом, копировать много данных). Есть несколько обходных путей.

• Наследование (композиция?): Выполняйте всю обычную работу в базовом классе, затем наследуйте и специализируйте класс C по мере необходимости.
• Друг: вместо того, чтобы метод 'foo' был членом C, определите его как бесплатные функции друзей и специализируйте только этот метод
• Делегирование: пусть ваш метод 'foo' вызывает другой метод 'bar', который является бесплатной функцией, и соответствующим образом специализируется на 'bar'

Что в коде дает:

// 1- Inheritance
template <class A, class B>
class CBase
{
  // Everything that does not require specialization
};

template <class A, class B>
class C: public CBase<A,B>
         // depending on your need, consider using another inheritance
         // or even better, composition
{
  void foo(); // generic
};

template <class A>
class C<A,CObject> : public CBase<A,CObject>
{
  void foo(); // specialized
};

// 2- Friend
// note the change in signature:
// - now you need to pass the attributes to be changed
// - the last parameter helps differentiating the overload
//   as there is no specialization for functions
template <class A, class B> void foo(Arg1&, Arg2&, const B&);
template <class A> void foo(Arg1&, Arg2&, const CObject&);

template <class A, class B>
class C
{
  friend template <class, class> foo;
};

// 3- Delegation
// same signature as foo in (2)
template <class A, class B> void bar(Arg1&, Arg2&, const B&);
template <class A> void bar(Arg1&, Arg2&, const CObject&);

template <class A, class B>
class C
{
  void foo() { bar(member1, member2, B()); }
};

Надеюсь, это прояснит и поможет!

Нет, частичная специализация шаблона функции в C ++ 0x не подлежит добавлению.

Как правильно сказано выше, в отношении шаблонов функций в основном было сделано 2 вещи:

• стали доступными аргументы шаблона по умолчанию;
• были введены вариативные шаблоны.

Как и раньше, следует использовать обходные пути для «имитации» частичной специализации шаблонов функций.

Поскольку класс является шаблоном, вам необходимо специализироваться на этом:

template <class A>
class C<A, CObject> 
{
   void foo() { ... }
}

Если я правильно помню, вы не можете сделать частичную специализацию шаблонов для функций. Не уверен, включен ли он в C ++ 0X

Обновление: (Ожидает подтверждения) Как отмечалось в комментариях, в C ++ 0X возможна частичная шаблонная специализация функций.