是否可以不实例化template类而显式实例化template类的template成员？

Question

我想显式实例化template成员，但不实例化template类。但是我得到了编译器错误，所以这是可能的吗？下面是我的代码：

//mytemplate.h
template <class T>
class mytemplate
{
 public:
  mytemplate(T* tt)
  {
     mT = tt;
  }
  template<class B>
  void print(const B& bb); 
  T* mT;
};

//in mytemplate.cpp
#include "mytemplate.h"
template<typename T>
template<typename B>
void mytemplate<T>:: print(const B& bb)
{
   B b = bb;
}

template<typename T> void  mytemplate<T>::print<float>(const float&) const;
template<typename T> void    mytemplate<T>::print<int>(const int&) const;

// main.cpp
int main()
{
  int d =0;
  mytemplate<int> k(&d);
  k.print<float>(4.0);
}

Answer 1

对于模板，它总是有助于将问题分解为尽可能小的构建块。可以根据对模板自由函数的调用来编写mytemplate::print。

这样，您就可以实现成员函数的部分专门化效果。

这里的一个主要问题是“print()方法应该做什么？”以下是mytemplate<T>向自由函数提供打印策略的示例。当然，没有理由策略不能是通过其他(可能是专用的)模板自由函数构造的其他类。

// Policy is a concept which supports 2 methods:
// print_prefix() and print_postfix()
//
template<class Policy, class B>
void print_with_policy(const Policy& policy, const B& value) const
{
  policy.print_prefix();
  cout << value;
  policy.print_postifx();
}

template<class T>
struct mytemplate
{
  // implement in terms of a free function
  template<class B> void print(const B& value) {
    print_with_policy(*this, value);
  }

  // policy concept implementation
  void print_prefix() const {
    cout << "prefix-";
  }

  void print_postfix() const {
    cout << "-postfix";
  }
};

扩展该示例以使用具有字符串专门化的单独策略类：

template<typename B>
struct default_policy {
    default_policy(const B& value) : _value(value) {}
    void operator()() const {
        cout << "(" << _value << ")";
    }
private:
    const B& _value;
};

template<typename B>
struct quoted_policy {
    quoted_policy(const B& value) : _value(value) {}
    void operator()() const {
        cout << '"' << _value << '"';
    }
private:
    const B& _value;
};

template<class B>
default_policy<B> make_policy(const B& value) {
    return default_policy<B>(value);
}

// overload for B being a string
quoted_policy<std::string> make_policy(const std::string& value) {
    return quoted_policy<std::string>(value);
}

template<class T>
struct mytemplate
{
    // implement in terms of a free function
    template<class B> void print(const B& value) {
        make_policy(value)();
        cout << endl;
    }

};

int main()
{
    struct foo{};
    mytemplate<foo> fooplate;
    fooplate.print(int(8));
    fooplate.print(std::string { "a string" });
    fooplate.print("not a string");


    return 0;
}

输出：

(8)
"a string"
(not a string)