3

我目前正在重构一些代码，明确专门化具有两个模板参数的类模板的成员函数。

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 */ }

现在我添加了更多模板参数，所以类现在看起来像这样：

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

这两个额外的参数只是将 typedef 添加到我的类中，因此运行时功能并没有真正改变。有什么办法可以保留（现在部分）专门的 bar 实现？我似乎无法弄清楚它的语法，我有一种预感，这可能是不可能的。

编辑：我正在寻找类似的东西：

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

这似乎没有编译..

4

4 回答 4

3

你是对的，这是不可能的。

您可以做的是在 new 中创建一个辅助成员类模板Foo，并将专用函数作为非模板成员函数放置在其中。专门化辅助类而不是函数。

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

于 2011-02-07T11:00:05.350 回答
1

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

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 */ }
于 2011-02-07T11:12:45.207 回答
1

您可以创建 Base class ，您可以在其中定义除 bar() 之外的所有成员，然后创建派生类（一个用于通用，一个用于 SomeType）：

template <class S, class T>
class FooBase
{
       // All other members 
};

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo:public FooBase<S,T>
{
public:
      void bar()
      {

      }
};

struct SomeType {};

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

    }
};

int main()
{
    Foo<SomeType,int,SomeType,int> b;
    b.bar();
}
于 2011-02-07T11:16:26.597 回答
1

您可以通过使用专门的仿函数而不是函数来实现：

#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;
}
于 2011-02-07T11:17:05.797 回答