在 C++ 中专门化函数时调用该函数的非专门化版本？

Question

假设我有一个模板化类：

template <typename T>
class foo {
  void do_someting(T obj) {
    // do something generic...
  }
};

并且我想专门化 do_something，但在其中我想调用“正常”do_something 函数：

template<>
void foo<MyObj>::do_something(MyObj obj) {
  // do something specific...
  // and ALSO do something generic!
}

有没有办法在我的专门函数中引用 do_something 的正常版本？或者我只需要复制代码？

（我知道我可以以这样的方式重构 foo，这样我就不会遇到这个确切的问题，但碰巧我无法真正修改“真正的”foo，因为它是大量共享的代码。）

Answer 1

不。您的专业化是 MyObj 类型参数存在的唯一定义。但是，考虑以这种方式修改 foo 模板，这对于模板的当前用户来说是透明的：

template<typename T>
class foo {
  void prelude(T &obj){ // choose a better name
    /* do nothing */
  }
  void do_something(T obj){
    prelude(obj);
    // do something generic...
  }
};

然后为 prelude 定义一个专门化：

template<>
void foo<MyObj>::prelude(MyObj &obj){
  // do something specific
}

这在结构上有点类似于 私人虚拟会员的主要用例。 （有点。不是真的。但这正是我回答这个问题的灵感来源。）

Answer 2

您还可以考虑不是 MyObj 的类型，但隐式转换为它，但最好的方法是重构并可能提取常见的通用内容。

#include <iostream>
#include <boost/ref.hpp>
typedef int MyObj;


template <typename T>
struct foo {
  void do_something(T obj) {
    // do something generic...
    std::cout << "generic " << obj << '\n';
  }
};

template<>
void foo<MyObj>::do_something(MyObj obj) {
  // do something specific...
  std::cout << "special " << obj << '\n';
  // and ALSO do something generic!
  foo<boost::reference_wrapper<MyObj> >().do_something(boost::ref(obj));
}

int main()
{
    foo<int> f;
    f.do_something(10);
}

Answer 3

是的，这实际上非常简单。您只需让函数的主要通用版本作为“实现”通用函数的传递，该函数不会部分专门化，然后您可以从专门化版本调用它根据需要的初始功能。

template <typename T>
class foo 
{
  void do_something(T obj) 
  {
     do_something_impl(obj);
  }

  void do_something_impl(T obj)
  {
    // do something generic...
  }
};

现在专业化可以毫无问题地调用通用版本：

template<>
void foo<MyObj>::do_something(MyObj obj) 
{
  // do something specific...
  do_something_impl(obj); //The generic part
}

我认为这比 Steve M. 的答案更接近你的初衷，这也是我在面对这个问题时所做的。