Question

是否可以为类成员模板特化设置不同的访问修饰符？代码示例（不编译）：

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);
};

是否可以为类模板成员专精设置不同的访问修饰符？代码示例（不编译）：

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!
}

Answer 2

对于没有输入参数的默认构造函数或方法，我认为Template specialization within class definition的答案就足够了。它仅使用std::enable_if和std::is_same，它们很容易定义。

对于单参数构造函数或方法，我认为你可以应用相同的方法，这在这里更容易，因为已经有（推导的）模板参数，所以你不需要虚拟的

template <bool C, typename T = void>
using only_if = typename std::enable_if <C, T>::type;

template <typename A, typename B>
using eq = typename std::is_same <A, B>::type;

class SimpleClass {
public:
    template <typename T, only_if <!eq <T, int>{}, int> = 0>
    SimpleClass(T) { ... }

    template <typename T, only_if <!eq <T, int>{}, int> = 0>
    void Method(T) { ... }
    // ...
};

Answer 3

经过一些讨论，这里是所有案例的完整说明，包括使用previous answer方法的不同访问说明符。

template <bool C, typename T = void>
using only_if = typename std::enable_if <C, T>::type;

template <typename A, typename B>
using eq = typename std::is_same <A, B>::type;

class SimpleClass1
{
public:
    template <typename T, only_if <!eq <T, int>{} && !eq <T, float>{}, int> = 0>
    SimpleClass1() { }
protected:
    template <typename T, only_if <eq <T, int>{}, int> = 0>
    SimpleClass1() { }
protected:
    template <typename T, only_if <eq <T, float>{}, int> = 0>
    SimpleClass1() { }
};

class SimpleClass2
{
public:
    template <typename T, only_if <!eq <T, int>{} && !eq <T, float>{}, int> = 0>
    SimpleClass2(T) { }
protected:
    template <typename T, only_if <eq <T, int>{}, int> = 0>
    SimpleClass2(T) { }
private:
    template <typename T, only_if <eq <T, float>{}, int> = 0>
    SimpleClass2(T) { }
};

template <typename T>
class ClassTemplate1
{
public:
    template <typename U, only_if <!eq <U, int>{} && !eq <U, float>{}, int> = 0>
    void Method() { }
protected:
    template <typename U, only_if <eq <U, int>{}, int> = 0>
    void Method() { }
protected:
    template <typename U, only_if <eq <U, float>{}, int> = 0>
    void Method() { }
};

template <typename T>
class ClassTemplate2
{
public:
    template <typename U, only_if <!eq <U, int>{} && !eq <U, float>{}, int> = 0>
    void Method(U) { }
protected:
    template <typename U, only_if <eq <U, int>{}, int> = 0>
    void Method(U) { }
protected:
    template <typename U, only_if <eq <U, float>{}, int> = 0>
    void Method(U) { }
};

我不知道这些有用的地方:-)无论如何：

我一直小心地使所有构造函数/方法重载互斥，以避免使用不同的访问说明符的问题和问题，这可能很棘手。这使得更难以概括为更多类型。模板别名有助于通用/默认情况（这是所有其他情况的补充）。
但是，这与您在问题中描述的内容并不完全相同。这些方法强制执行严格的类型相等，因此不允许隐式转换。您可以尝试使用std::is_convertible，但之后您会打开歧义的大门。
整个代码都是这样编译的，但我没有尝试实际使用这些类，所以我不知道会发生什么。
我真的不知道如何使用SimpleClass1：我们怎么可能为默认构造函数明确指定模板参数（因为它不能推导出来）？
< / LI>
再次查看代码，我认为ClassTemplate与SimpleClass的差别不大（或根本没有）。 ClassTemplate1不能有默认的模板参数，因为这可能是不明确的。

Answer 4

尝试使用“模板专业化”：

template <typename T>
struct S {
    void foo();
    void bar();
};

template <>
struct S<int> {
    void foo();
};



int main()
{
    S<char> sc;
    sc.foo();
    sc.bar();

    S<int> si;
    si.foo();
    si.bar(); // compile error: 'bar' : is not a member of 'S<int>'

}

是否可以为类成员模板特化（以及类模板成员）设置不同的访问修饰符？

4 个答案: