模板声明与模板定义的匹配程度如何？如果“他们的模板名称[…]引用相同的模板和[…]”(14.4 [temp.type] p1),我在标准中发现了一些关于模板ID的文本引用相同的函数,但是我找不到模板名称的定义或模板名称引用同一模板时.我不确定我是否在正确的轨道上,因为我还没有很好地破译语法,无法判断模板ID是模板的定义/声明的一部分,还是只是模板的使用.

例如,以下程序工作正常.

#include <iostream>

template<typename T>
T foo(T t);

int main() {
    foo(1);
}

template<typename T>
T foo(T t)
{ std::cout << "A\n"; return 0; }

如果我改变模板定义中使用模板参数的方式,名称显然不再引用相同的模板,并且链接失败.

#include <iostream>

template<typename T>
T foo(T t);

int main() {
    foo(1);
}

template<typename T>
int foo(T t) { std::cout << "A\n"; return 0; }

// or

template<typename T>
struct identity {
    typedef T type;
};

template<typename T>
typename identity<T>::type
foo(T t) { std::cout << "A\n"; return 0; }

接下来,如果我将模板定义移动到另一个翻译单元,为了实现C(MSVC 11 beta),无论我怎么说这些类型,程序都能正常工作.

//main.cpp

template<typename T>
T foo(T t);

int main() {
    foo(1);
}

//definition.cpp
#include <iostream>

template<typename T>
struct identity {
    typedef T type;
};

template<typename T>
typename identity<T>::type
foo(T t) { std::cout << "A\n"; return 0; }

template int foo<int>(int);

要么

//definition.cpp
#include <iostream>

template<typename T>
int foo(T t) { std::cout << "A\n"; return 0; }

template int foo<int>(int);

或者即使定义根本不是模板：

//definition.cpp
#include <iostream>

int foo(T t) { std::cout << "A\n"; return 0; }

显然链接是成功的,因为签名/受损名称是相同的,无论实例化创建符号的模板如何.我认为这种未定义的行为是因为我违反了：

§ 14.1 [temp] p6

A function template,member function of a class template,or static
data member of a class template shall be defined in every translation
unit in which it is implicitly instantiated (14.7.1) unless the
corresponding specialization is explicitly instantiated (14.7.2) in
some translation unit; no diagnostic is required.

但后来说我试图通过在第二个翻译单元中放置模板的定义来满足这些要求,并在两个位置之一处包含一个显式实例化：

#include <iostream>

template<typename T>
T foo(T t) { std::cout << "A\n"; return 0; }

// Location 1    

template<typename T>
int foo(int t) { std::cout << "B\n"; return 0; }

// Location 2

有关消除显式实例化所指的模板歧义的规则是什么？将它放在位置1会导致正确的模板被实例化,并且该定义将在最终程序中使用,而将它放在位置2则实例化另一个模板,并导致我认为在上面的14.1 p6下未定义的行为.

另一方面,无论如何,两个模板定义的隐式实例化都会选择第一个模板,因此在这些情况下,消除模板歧义的规则似乎不同：

#include <iostream>

template<typename T>
T foo(T t) { std::cout << "A\n"; return 0; }

template<typename T>
int foo(int t) { std::cout << "B\n"; return 0; }

int main() {
    foo(1); // prints "A"
}

这出现的原因与this question有关,其中提问者发现了一个单一的前方声明

template<typename T>
T CastScriptVarConst(const ScriptVar_t& s);

不能作为多个模板定义的声明：

template<typename T>
typename std::enable_if<GetType<T>::value < SVT_BASEOBJ,T>::type
CastScriptVarConst(const ScriptVar_t& s) {
    return (T) s;
}

template<typename T>
typename std::enable_if<!(GetType<T>::value < SVT_BASEOBJ)
                        && std::is_base_of<CustomVar,T>::value,T>::type
CastScriptVarConst(const ScriptVar_t& s) {
    return *s.as<T>();
}

我想更好地理解模板定义和声明之间的关系.

template<class T> T foo(T t);

template<int A,int B>
void f(array<A + B>);
template<int T1,int T2>
void f(array<T1 + T2>);
template<int A,int B>
void f(array< mpl::plus< mpl::int<A>,mpl::int<B> >::value >);

template<typename T>
T foo(T t);

template<typename T>
typename identity<T>::type foo(T t);

/* Template definition. */
template<typename T>
T foo(T t)
{ ... }

/* Specialization,OK in itself. */
template< >
int foo(int t)
{ ... }

/* Explicit instantiation,OK in itself. */
template< >
int foo(int t);

template<typename T>
T f(T f)
{ ... }

template< >
int f(int);

void g(void)
{ f(3); }

template<typename T>
T f(T f)
{ ... }

template f(int);

void g(void)
{ f(3); }

template<typename T>
T f(T f)
{ ... }

void g(void)
{ f(3); } // Implicitly specializes int f(int)

template< >
int f(int) // Too late for an explicit specialization
{ ... }

template<typename T>
T foo(T t) { ... }

template<typename T>
int foo(int t) { ... }

f<int>(3); // ambiguous
f<string>(3); // can only be the second one