Шаблон специализации отдельных членов? - PullRequest
Новая
       6

Шаблон специализации отдельных членов?

24 голосов
/ 01 октября 2009

Можно ли специализировать отдельных членов шаблонного класса? Что-то вроде: 

template <typename T,bool B>
struct X
{
    void Specialized();
};

template <typename T>
void X<T,true>::Specialized()
{
    ...
}

template <typename T>
void X<T,false>::Specialized()
{
    ...
}

Конечно, этот код недействителен.

Ответы [ 2 ]

27 голосов
/ 01 октября 2009

Вы можете только специализировать его явно, предоставив все аргументы шаблона. Частичная специализация для функций-членов шаблонов классов не допускается. 

template <typename T,bool B>
struct X
{
    void Specialized();
};

// works
template <>
void X<int,true>::Specialized()
{
    ...
}

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

// "maps" a bool value to a struct type
template<bool B> struct i2t { };

template <typename T,bool B>
struct X
{
    void Specialized() { SpecializedImpl(i2t<B>()); }

private:
    void SpecializedImpl(i2t<true>) { 
      // ...
    }

    void SpecializedImpl(i2t<false>) { 
      // ...
    }
};

Обратите внимание, что, передавая перегруженные функции и помещая параметры шаблона в параметр функции, вы можете произвольно «специализировать» свои функции, а также при необходимости шаблонизировать их. Другой распространенный метод - это использование шаблона класса, определенного отдельно 

template<typename T, bool B>
struct SpecializedImpl;

template<typename T>
struct SpecializedImpl<T, true> {
  static void call() { 
    // ...
  }
};

template<typename T>
struct SpecializedImpl<T, false> {
  static void call() { 
    // ...
  }
};

template <typename T,bool B>
struct X
{
    void Specialized() { SpecializedImpl<T, B>::call(); }
};

Я считаю, что обычно требуется больше кода, и я считаю, что перегрузка функции легче обрабатывается, в то время как другие предпочитают откладывать шаблон класса. В конце концов, это вопрос вкуса. В этом случае вы могли бы поместить этот другой шаблон внутрь X также как вложенный шаблон - в других случаях, когда вы явно специализируете, а не только частично, вы не сможете этого сделать, потому что вы можете разместить явные специализации только в пространстве имен сфера, а не в класс.

Вы также можете создать такой шаблон SpecializedImpl только для перегрузки функций (он затем работает аналогично нашему i2t ранее), как показано в следующем варианте, который оставляет также первую переменную параметра (так что вы можете вызвать это с другими типами - не только с параметрами шаблона текущего экземпляра) 

template <typename T,bool B>
struct X
{
private:
    // maps a type and non-type parameter to a struct type
    template<typename T, bool B>
    struct SpecializedImpl { };

public:
    void Specialized() { Specialized(SpecializedImpl<T, B>()); }

private:
    template<typename U>
    void Specialized(SpecializedImpl<U, true>) {
      // ...
    }

    template<typename U>
    void Specialized(SpecializedImpl<U, false>) {
      // ...
    }
};

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

3 голосов
/ 01 октября 2009

Это то, что я придумал, не так уж и плохо :) 1001 * 

//The generic template is by default 'flag == false'
template <class Type, bool flag>
struct something
{
    void doSomething()
    {
        std::cout << "something. flag == false";
    }
};

template <class Type>
struct something<Type, true> : public something<Type, false>
{
    void doSomething() // override original dosomething!
    {
        std::cout << "something. flag == true";
    }
};

int main()
{
    something<int, false> falseSomething;
    something<int, true> trueSomething;

    falseSomething.doSomething();
    trueSomething.doSomething();
}
...