Специализирующая функция-член для не шаблонного класса в C ++ - PullRequest
Новая
       21

Специализирующая функция-член для не шаблонного класса в C ++

2 голосов
/ 20 мая 2011

Я пытаюсь специализировать функцию-член шаблона не шаблонного класса, используя шаблонизированный параметр: 

#include <array>
class C
{
public:
  template<class Container>
  void Foo( Container& )
  {
    // ...
  }
};

template<class T, std::size_t N>
template<>
void C::Foo< std::tr1::array<T,N> >( std::tr1::array<T,N>& )
{
  // special
}

Я получаю сообщение об ошибке "незаконное использование явных аргументов шаблона" с этим.Какой правильный синтаксис, чтобы сделать это действительным?

Обновление :

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

class C
{
public:
  template<class Iter>
  void Foo( Iter )
  {
    std::cout << "Normal\n";
  }

  template<class T, std::size_t N>
  void Foo( typename std::tr1::array<T,N>::iterator )
  {
    std::cout << "Special\n";
  }
};

int main()
{
  C c;
  std::tr1::array<int,10> a1;
  c.Foo( a1.begin() ); // Doesn't print "Special"!
}

Но специальный Foo не вызывается.Как я могу это сделать?

Ответы [ 2 ]

2 голосов
/ 20 мая 2011

Только функция-член является шаблонной, что означает, что вы должны использовать только один template<...>. Но это также не решит проблему, так как вы не можете частично специализировать функцию.

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

struct test {
   template <typename Container>
   void f( Container& ) { ... }

   template <typename T, int N>
   void f( std::array<T,N>& ) { ... }
};

Обратите внимание, что разница в том, что это две отдельные функции шаблона (а не специализация).

РЕДАКТИРОВАТЬ : после обновления

Обновление вопроса полностью меняет проблему. Проблема, которую вы видите, состоит в том, что аргумент второй версии является зависимым именем, и как таковой он не выводим. Учитывая вызов функции, компилятор не может определить, какой тип T и интегральная константа N должны соответствовать этому конкретному экземпляру. Рассмотрим другой пример: 

template <typename T>
struct inner_int {
   typedef int type;
};
template <typename T>
void foo( typename inner_int<T>::type ) {
}
int main() {
   foo( inner_int<double>::type() );
}

Когда компилятор обрабатывает вызов в main, он создает шаблон и извлекает тип, из которого он создает временный, а затем пытается решить, что делать с foo, но в то время он знает только что он вызывается со значением int r ... исходный inner<double>::type пропал, теперь он просто foo( int() ), и компилятор должен попытаться создать экземпляр inner_int со всеми возможными типами, чтобы определить, является ли какой-либо из они подходят, и в худшем случае, как указано выше, многие подойдут.

1 голос
/ 21 мая 2011

Специализация шаблона частичной функции недопустима. Из стандарта C ++ 03, §14 / 2:

A шаблон-объявление может появляться только как область видимости пространства имен или декларация области видимости класса. В объявлении шаблона функции идентификатор объявления должен представлять собой имя шаблона (т. Е. Не идентификатор шаблона ) . [ Примечание: в объявлении шаблона класса, если имя класса template-id , объявление объявляет частичную специализацию шаблона класса.]

Вместо этого вы захотите просто перегрузить свою функцию: 

class C
{
public:
    template<typename Container>
    void Foo(Container&)
    {
        // ...
    }

    template<typename T, std::size_t N>
    void Foo(std::tr1::array<T, N>&)
    {
        // special
    }
};

РЕДАКТИРОВАТЬ (в ответ на редактирование ОП):

Если вы ищете обходной путь только для этого конкретного сценария, поскольку std(::tr1)::array<T,N>::iterator - это просто T*, ваша «специальная» перегрузка может быть: 

template<typename T>
void Foo(T*&)
{
    // special
}
...