c++ - 是否可以为类成员模板特化(和类模板成员特化)设置不同的访问修饰符？

Question

1. 是否可以为类成员模板特化设置不同的访问修饰符？代码示例(不编译):

   class SimpleClass
   {   
   public:
       template <typename T>
       void Method();
       template <>
       void Method<char>();
   protected:
       template <>
       void Method<int>();
   protected:
       template <>
       void Method<float>();
   };
   

   • 子问题:是否可以为类的模板构造函数特化设置不同的访问修饰符？代码示例(不编译):

     class SimpleClass
     {
     public:
         template <typename T>
     SimpleClass(T);
         template <>
         SimpleClass<char>(char);
     protected:
         template <>
         SimpleClass<int>(int);
     private:
         template <>
         SimpleClass<float>(float);
     };
     

2. 是否可以为类模板成员特化设置不同的访问修饰符？代码示例(不编译):

   template <typename T>
   class ClassTemplate
   {   
   public:
       void Method();
       template <>
       void Method<char>();
   protected:
       template <>
       void Method<int>();
   protected:
       template <>
       void Method<float>();
   };
   

   • 子问题:是否可以为类模板的构造函数特化设置不同的访问修饰符？代码示例(不编译):

     template <typename T>
     class ClassTemplate
     {
     public:
         ClassTemplate(T);
         template <>
         ClassTemplate<char>(char);
     protected:
         template <>
         ClassTemplate<int>(int);
     private:
         template <>
         ClassTemplate<float>(float);
     };
     

更具体地说:在 1) 我正在为此类 C++11 代码寻找 C++03 解决方法:

class SimpleClass
{
public:
    template <typename T>
    SimpleClass(T);

    template <typename T>
    void Method();
};

template <>
SimpleClass::SimpleClass<char>(char);
template <>
SimpleClass::SimpleClass<int>(int) = delete;

template <>
void SimpleClass::Method<char>();
template <>
void SimpleClass::Method<int>() = delete;

在 2) 我正在为以下 C++11 代码寻找 C++03 解决方法:

template <typename T>
class ClassTemplate
{
public:
    ClassTemplate(T);

    void Method();
};

template <>
ClassTemplate<char>::ClassTemplate(char);
template <>
ClassTemplate<int>::ClassTemplate(int) = delete;

template <>
void ClassTemplate<char>::Method();
template <>
void ClassTemplate<int>::Method() = delete;

Answer 1

我们可以用 SFINAE 做到这一点，但不幸的是我们需要 is_same 和 enable_if。 幸运的是，它们都不需要任何 C++11 语言!所以我们可以根据自己的需要引入他们的实现:

template <typename A, typename B>
struct is_same {
  static const bool value = false;
};

template<typename A>
struct is_same <A, A> {
  static const bool value = true;
};

template<bool B, class T = void>
struct enable_if {};

template<class T>
struct enable_if<true, T> { typedef T type; };

接下来，我们使用 enable_if 将它们组合到您不想要的“SFINAE 删除”方法。模板构造函数/方法需要一个噱头。我们需要第一个参数是参数推导的类型。我们添加第二个虚拟参数，其唯一目的是在类型不是您支持的情况下删除该方法。如果需要，您可以为更多类型添加重载。对于 Method() 我们可以再次应用虚拟参数，并且 T 将被显式给出，因此不需要任何推导:

class SimpleClassConstructor {
public:
  template <typename T>
  SimpleClassConstructor(T value, 
                         typename enable_if<is_same<T, char>::value, T>::type enabler = 0) {
  }
  template <typename T>
  void Method(typename enable_if<is_same<T, char>::value, T>::type enabler = 0) {
  }
};

对于模板类，~~我们可以使用完全相同的方法，但是我们可以直接使用enable_if的结果，因为我们不需要参数推导。~~满足具体删除方法，我们可以将 enable_if 方法移动到模板参数中。这将使 SFINAE 软删除该方法(而不是在 enable_if 失败时禁用整个类):

template <typename T>
class SimpleClassTemplate {
public:
  template <typename Enable = enable_if<is_same<T, char>::value, T>::type>
  SimpleClassTemplate(T value) {

  }
};

要进行测试，请尝试以下操作:

int main() {
  char a = 0;
  SimpleClassTemplate<char> A1(a); // OK
  SimpleClassConstructor A2(a); // OK

  A2.Method<char>(); // OK
  A2.Method<int>(); // compilation error!

  int b = 0;
  SimpleClassTemplate<int> B1(b); // compilaton error!
  SimpleClassConstructor B2(b); // compilation error!
}