Скрытие функций-членов в шаблонном классе - PullRequest
Новая
       5

Скрытие функций-членов в шаблонном классе

7 голосов
/ 20 апреля 2011

Можно ли скрыть некоторые функции-члены в шаблонном классе?Давайте представим, что у нас есть что-то вроде: 

template <class T>
class Increment
{
public:
    void init(T initValue)
    {
         mValue = initValue;
    }  

    T increment()
    {
        ++mValue;
    }

    T increment(T delta)
    {
        mValue += delta;
    }
private:
    T mValue;
};

Цель состоит в том, чтобы использовать этот класс таким образом, чтобы в некоторых случаях мы видели только функцию increment (), а в некоторых других - только приращение (T) функция-член.Чтобы сделать это, я могу подумать о чем-то с SFINAE: 

class MultipleIncrement
{
    typedef int MultipleIncrement_t;
};

class SingleIncrement
{
    typedef int SingleIncrement_t;
};

template <class T, class Q>
class Increment
{
public:
    void init(T initValue)
    {
        mValue = initValue;
    }

    T increment(typename Q::SingleIncrement_t = 0)
    {
        ++mValue;
    }

    T increment(T delta, typename Q::MultipleIncrement_t = 0)
    {
        mValue += delta;
    }
private:
    T mValue;
}

, а затем использовать мой шаблон, например, например: 

Increment<long, MultipleIncrement>

Однако компилятор не позволяет мне делать это,Есть ли другой способ, которым это возможно?Будет ли это работать, если функция-член на самом деле является конструктором?

Ответы [ 3 ]

3 голосов
/ 20 апреля 2011

В этом случае я бы предпочел использовать специализацию шаблонов. Поможет ли вам что-то подобное? 

struct SingleIncrement;
struct MultipleIncrement;

template <
    class T, 
    class Policy = SingleIncrement // default template param
>
class Increment
{
    T mValue;
public:
    Increment(T initValue)
    :   mValue(initValue)
    {}

    T increment()
    {
        ++mValue;
    }
};

// template specialization for MultipleIncrement
template <class T>
class Increment<T,MultipleIncrement>
{
    T mValue;
public:
    Increment(T initValue)
    :   mValue(initValue)
    {}

    T increment(T delta)
    {
        mValue += delta;
    }
};
1 голос
/ 09 декабря 2016

Вот MWE того, как этого можно достичь: 

#include <iostream>

using namespace std;

struct multi;
struct single;

template<class T, class Q>
struct dummy {
  dummy(T value) : m_value(value) { }

  // using enable_if_t in template argument
  template<class _Q = Q, enable_if_t<is_same<_Q, single>::value && is_same<_Q, Q>::value, int> = 1>
  T increment() { return ++m_value; }

  // using enable_if_t in method return type
  template<class _Q = Q>
  enable_if_t<is_same<_Q, multi>::value && is_same<_Q, Q>::value, T>
  //enable_if_t<is_same<_Q, multi>::value, T> // (*)
  increment(T delta) { return (m_value += delta); }

  T m_value;
};

int main() {
  dummy<double, multi> m(47.10);
  //cout << m.increment() << endl; // error as expected
  cout << m.increment(.01) << endl;

  dummy<int, single> s(41);
  cout << s.increment() << endl;
  cout << s.increment<single>() << endl;
  //cout << s.increment(1) << endl; // error as expected
  //cout << s.increment<multi>(1) << endl; // not an error when using (*)
}

выход

Использование c++ (Debian 6.2.1-5) 6.2.1 20161124 дает: 

47.11
42
43

Разработка

Нам нужно шаблонизировать методы, чтобы заставить SFINAE работать вообще. Мы не можем использовать что-то вроде 

std::enable_if_t<std::is_same<_Q, multiple_increment>::value, T> increment() ...

потому что происходит сбой при создании шаблона dummy<T, single_increment> вместо сбоя при замене параметров шаблона метода.

Кроме того, мы хотим, чтобы пользователь мог использовать методы без фактического предоставления параметра шаблона метода. Поэтому мы устанавливаем параметр шаблона метода _Q по умолчанию Q.

Наконец, чтобы действительно вызвать ошибку компилятора при использовании нежелательного метода, даже при предоставлении параметра шаблона метода, мы только enable_if_t используем метод, только если параметр шаблона метода _Q действительно того же типа, что и соответствующий параметр шаблона класса Q.

1 голос
/ 20 апреля 2011

Шаблонная специализация хороша.Наследование звучит лучше.Рассматривали ли вы шаблоны на унаследованном базовом классе?(Или это теперь считается поддельным человеком?) 

#define SHOW(X)  cout << # X " = " << (X) << endl

template <class T>
class A
{
public:
  void foo(T t) {SHOW(t); }
};

template <class T, class BASE>
class B : public BASE
{
public:
  void bar(T t) {SHOW(t); }
};

int
main()
{
  B<int,A<int> > b;
  b.foo(1);
  b.bar(2);
}
...