C++ 部分专业化成员函数实现

我目前正在重构一些代码，这些代码使用两个模板参数显式地专门化类模板的成员函数

template <class S, class T>
class Foo
{
  void bar();
};

template <class S, class T>
void Foo<S, T>::bar()
{ /* Generic stuff */ }

template <>
void Foo<SomeType, SomeType>::bar()
{ /* Some special function */ }

模板
福班
{
空心钢筋（）；
};
模板
void Foo:：bar（）
{/*通用材料*/}
模板
void Foo:：bar（）
{/*某些特殊函数*/}

现在我添加了更多的模板参数，因此该类现在如下所示：

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo
{
  void bar();
};

template <class S, class EXTRA0, class T, class EXTRA1>
class FooBase
{
    void bar();
};

template <class S, class EXTRA0, class T, class EXTRA1>
void FooBase<S, EXTRA0, T, EXTRA1>::bar()
{ /* Generic stuff */ }

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo
    : public FooBase <S, EXTRA0, T, EXTRA1>
{ };

template <class EXTRA0, class EXTRA1>
class Foo<int, EXTRA0, int, EXTRA1>
    : public FooBase <int, EXTRA0, int, EXTRA1>
{
    void bar ();
};

template <class EXTRA0, class EXTRA1>
void Foo<int, EXTRA0, int, EXTRA1>::bar()
{ /* Some special function */ }

模板
福班
{
空心钢筋（）；
};

这两个额外的参数只是将typedef添加到我的类中，所以运行时功能实际上没有改变。有什么方法可以保持（现在是部分）bar的专业化实现吗？我似乎弄不明白它的语法，我有一种预感，这可能是不可能的

编辑：我正在寻找以下内容：

template <class EXTRA0, class EXTRA1>
void foo<SomeType, EXTRA0, Sometype, EXTRA1>::bar()
{
   /* specialized implementation */
}

模板
void foo:：bar（）
{
/*专门实施*/
}

---

这似乎无法编译。

您是正确的，这是不可能的

您可以做的是在新的

Foo

中创建一个helper成员类模板，并将专用函数作为非模板成员函数放在其中。专门化helper类而不是函数

---

另一种选择是将专门化转换为非模板重载。

我认为您想要的不是那么容易实现的。像这样的东西怎么样：

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo
{
  void bar();
};

template <class S, class EXTRA0, class T, class EXTRA1>
class FooBase
{
    void bar();
};

template <class S, class EXTRA0, class T, class EXTRA1>
void FooBase<S, EXTRA0, T, EXTRA1>::bar()
{ /* Generic stuff */ }

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo
    : public FooBase <S, EXTRA0, T, EXTRA1>
{ };

template <class EXTRA0, class EXTRA1>
class Foo<int, EXTRA0, int, EXTRA1>
    : public FooBase <int, EXTRA0, int, EXTRA1>
{
    void bar ();
};

template <class EXTRA0, class EXTRA1>
void Foo<int, EXTRA0, int, EXTRA1>::bar()
{ /* Some special function */ }

模板
类食品库
{
空心钢筋（）；
};
模板
void FooBase:：bar（）
{/*通用材料*/}
模板
福班
：公共食品基地
{ };
模板
福班
：公共食品基地
{
空心钢筋（）；
};
模板
void Foo:：bar（）
{/*某些特殊函数*/}

您可以创建基类，在基类中可以定义除bar（）之外的所有成员，然后创建派生类（一个用于通用，一个用于某种类型）：

模板
类食品库
{
//所有其他成员
};
模板
Foo类：公共FooBase
{
公众：
空条（）
{
}
};
结构SomeType{}；
模板
Foo类：公共FooBase
{
公众：
空条（）
{
}
};
int main（）
{
富b；
b、 bar（）；
}

您可以通过使用specialize函子而不是函数来实现这一点：

#include <iostream>

typedef int SomeType;

template <class A, class B>
class BarFunctor {
public:
    void operator()() {
        std::cout << "generic" << std::endl;
    }
};

template <>
class BarFunctor<SomeType, SomeType> {
public:
    void operator()() {
        std::cout << "special" << std::endl;
    }
};

template <class S, class T, class EXTRA0, class EXTRA1>
class Foo {
public:
    void helloWorld() {
        std::cout << "hello world !" << std::endl;
    }

    void bar() {
        return _bar();
    }

private:
    BarFunctor<S, T> _bar;
};

int main() {

    Foo<char, char, char, char> gen;
    Foo<SomeType, SomeType, char, char> spe;
    gen.helloWorld();
    spe.helloWorld();
    gen.bar();
    spe.bar();
    return 0;
}

#包括
typedef int SomeType；
模板
类巴函子{
公众：
void运算符（）（）{
std:：cout AFAIK，你记得对：你不能部分地专门化函数，只能是类型。@Simone它正在工作，至少在g++。@Ashot在我的4.5.0版本中它没有编译，请看@Itjax是什么阻止你向专门化类添加参数？@Ashot我没有专门化类，只有专门化类的一个成员。我不能似乎要使其适应新的模板参数列表。