Блог

Примечание: следующий код незаконен, но соответствующий компилятор не обязан отклонять его (а некоторые этого не делают).

В библиотеке, с которой я работаю, у меня есть объявление функции шаблона для Foo и определение функции шаблона для Bar в foobar.h :

 template<class C> int Foo();

template<class C> int Bar() {
  return Something(  Foo<C>()  );
}
  

Предполагается, что другой код сможет использовать это следующим образом:

 #include "foobar.h"

int main() {
  Bar<MyClass>();
  return 0;
}

// Ideally, the usage (above) and the definition (below)
// would/could be in different translation units. 

template<> int Foo<MyClass>() { return 5; }
  

Вопрос: Есть ли способ сделать эту работу также легальной?

Проблема в том (если я правильно понимаю), что, несмотря на компиляцию, это технически незаконно: это нарушает ODR, потому что как явная специализация, так и использование Bar<MyClass> считаются определениями, несмотря на то, что в случае использования нет тела для работы.

Причины, по которым я хочу использовать этот шаблон для параметризации Foo , заключаются в том, что в соответствии с руководством по стилю, которому я обязан следовать, единственный способ гарантировать, что что-либо лексически включено перед определением Bar , — это включить его с помощью foobar.h . Но (по причине, я полагаю, мне не нужно объяснять) это не для начала.

Есть ли способ сделать эту работу также легальной?

Да, объявите специализацию перед ее использованием. Простое изменение порядка специализации и main в вашем файле сделало бы это в приведенном вами примере. Однако в приведенном примере вам все равно придется убедиться, что ни один другой TU не использовал специализацию без ее объявления.

Как правило, эти специализации должны быть объявлены в заголовке.

В пределах того, что, как представляется, находится в пределах вашего примера (т. Е. Без радикальных изменений), другого способа заставить это работать нет.

Это незаконно, поскольку невозможно специализировать функции шаблона.

Вы могли бы сделать что-то вроде этого :

 template< typename T >
struct foo
{
  static int doSomething() {return 0;}
};
template< >
struct foo<int>
{
  static int doSomething() {return 5;}
};
  

Это компилирует ссылки и запускается как с VS2008, так и с gcc 4.5.2:

 template<class C> int Foo();

int Something(int i ){ return i; }

template<class C> int Bar() {
    return Something(  Foo<C>()  );
}

class MyClass{};
class FooClass{};

// Update:
// Declaration of a specialisation.
template<> int Foo<MyClass>();

int Zoo(){
    return Something(  Foo<MyClass>()  );
}

#include <iostream>

int main() {
    std::cout << Bar<MyClass>() << std::endl;
    std::cout << Zoo() << std::endl;
    std::cout << Bar<FooClass>() << std::endl;
    return 0;
}

// Definitions of specialisations.
template<> int Foo<MyClass>() { return 5; }
template<> int Foo<FooClass>() { return 6; }
  

Результат таков:

 5
5
6
  

Причина, по которой это работает, заключается в том, что, несмотря на то, что функция шаблона только объявлена, у нее есть два необходимых определения, доступных компоновщику. Foo
Во время компиляции, когда компилятор видит определение main , он может создавать специализации Bar , но не может создавать специализации Foo . В этом случае он просто создает вызовы функций Foo<MyClass>() и Foo<FooClass>() .
Позже компилятор находит специализации, Foo которые он компилирует, оставляет в объектном файле, но больше ничего не делает с ними в данный момент. Когда компоновщик запускается, он находит все, что ему нужно.
Обновить:
Итак, я не знаю, почему это незаконно, но по какой-то причине это, похоже, компилируется и запускается.