Можно ли установить разные модификаторы доступа к специализациям шаблона члена класса (и к специализациям членов шаблона класса)?

После некоторого обсуждения, вот полный отчет обо всех случаях, включая различные спецификаторы доступа, с использованием подхода моего предыдущего ответа.

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: как мы можем явно указать аргумент шаблона для конструктора по умолчанию (поскольку его нельзя вывести)?

• Снова взглянув на код, я думаю, что ClassTemplate мало чем отличается (или совсем не отличается) от SimpleClass. ClassTemplate1 не может иметь аргумент шаблона по умолчанию, потому что это было бы неоднозначно.

Мы можем сделать это с помощью 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!
}

Для конструктора или метода по умолчанию без входных параметров я думаю, что ответа на специализацию шаблона в определении класса достаточно. Он использует только 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) { ... }
    // ...
};

Попробуйте использовать «Специализацию шаблона»:

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>'

}