C++ C++；部分方法专门化

模板类方法是否有部分专门化

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

模板
C类
{
void foo（）；
}

像这样专门化它是行不通的：

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

模板void C:：foo（）{}；

---

有什么帮助吗？

因为类是模板，所以需要专门化：

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

模板
C类
{
void foo（）{…}
}

如果我没记错的话，您不能对函数进行部分模板专门化。不确定它是否包含在C++0X中

更新：

---

（等待确认）如注释中所述，在C++0X中可以对函数进行部分模板专门化。

如果您已经有专门化类，则可以在专门化类中对

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; };
};

模板
C类
{
公众：
void foo（）{cout我认为那里有误解

有两种模板：


模板类
模板方法

在您的示例中，您有一个模板类，它当然包含一些方法

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

模板
C类
{
void foo（）{…}//专用代码
};

示例中的问题相对简单：您定义了专门化C的方法foo，但是这个专门化从未被预先声明过

这里的问题是您必须完全专门化您的C类（从而复制大量数据）


继承（组合？）：在基类中完成所有的普通工作，然后让C类继承并根据需要进行专门化
Friend：不要让'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()); }
};

//1-继承
模板
C类数据库
{
//一切不需要专门化的东西
};
模板
C类：公共CBase
根据你的需要，考虑使用另一个继承。
//或者更好的是，作文
{
void foo（）；//泛型
};
模板
C类：公共CBase
{
void foo（）；//专门化
};
//2-朋友
//注意签名的变化：
//-现在您需要传递要更改的属性
//-最后一个参数有助于区分过载
//因为函数没有专门化
模板void foo（Arg1&，Arg2&，常量B&）；
模板void foo（Arg1&，Arg2&，const CObject&）；
模板
C类
{
朋友模板foo；
};
//3-授权
//与第（2）款中的foo签名相同
模板空栏（Arg1&，Arg2&，常量B&）；
模板空栏（Arg1&，Arg2&，const CObject&）；
模板
C类
{
void foo（）{bar（member1，member2，B（））；}
};

希望它能澄清并帮助您！
不，在C++0x中没有要添加的部分函数模板专门化

如上所述，关于函数模板，基本上做了两件事：


默认模板参数可用
引入了可变模板

以前，应该使用“处理”部分函数模板专门化。
我已经是专门的类，但我确实需要专门化方法：）这个限制在C++上被解除了。0x@yngvedh，您是否有该“更新”的参考资料：注意？我还没听说过。好吧，他们只是提升了默认参数-也就是说，你可以在函数模板中有默认参数。@libt，没有参考。我只是假设这位教授知道他在说什么，因为我不是C++0X方面的专家。知道的人能证实这一点吗？我会适当地更新。第二个是正确的，第一个是正确的g-不能将显式专门化放在类范围内-即使将模板的专门化放在名称空间范围内-如果专门化一个模板，那么它的所有封闭模板也必须专门化：（因此必须坚持第二种方法。因此这不起作用，例如：
template void C:：foo（）{}，因为成员函数模板是专门的，外部的模板还没有。您可以做其他的方式，虽然<代码>模板模板：空：（）（{} /Cord>），但我怀疑这不是他想要做的。-似乎不是C++ 03标准兼容，但它在Visual C++ 2008中工作。它看起来像C++ 0x扩展。（14.6.5.3类模板专业化成员）。修复了答案，第二个选项仍在那里供参考。好的，c++0x草案中
14.6.5.3/2
中的示例是部分专门化。对于部分专门化，这些限制不存在。这些限制可以放在类范围中-已经在c++03中。但是在您的情况下，您显式专门化了函数模板。如果它们没有这样做在他们的例子中，这也是非法的：
template struct A{template struct B{}；template struct B{}；
。在要求取消这一限制时有一个问题报告（当然我也很欢迎），在其他答案中有两种方式：
// 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()); }
};