Inlining-Template-Spezialisierung

Wenn ich einen Header foo.h habe, den ich in mein gesamtes Projekt einfüge, scheint er gut zu funktionieren, wenn er nur Folgendes enthält:

template<typename T>
void foo(const T param) {
    cout << param << endl;
}

Aber ich erhalte One-Definition-Rule-Fehler (ODR), wenn ich foo.h eine Spezialisierung hinzufüge:

template<>
void foo(const bool param) {
    cout << param << endl;
}

Offensichtlich kann ich das lösen, indem ich inline‘ing die Spezialisierung. Meine Frage ist, warum muss ich das? Wenn die Vorlage ODR nicht verletzt, warum eine Spezialisierung?

Eine explizite Spezialisierung ist nicht implizit inline. Es muss explizit inline gemacht werden.

[temp.expl.spec]/12

Eine explizite Spezialisierung einer Funktions- oder Variablenvorlage ist nur dann inline, wenn sie mit dem Inline-Bezeichner deklariert oder als gelöscht definiert ist, und unabhängig davon, ob ihre Funktions- oder Variablenvorlage inline ist. [ Example:

template<class T> void f(T) { /* ... */ }
template<class T> inline T g(T) { /* ... */ }

template<> inline void f<>(int) { /* ... */ }   // OK: inline
template<> int g<>(int) { /* ... */ }           // OK: not inline

 — end example ]

Also musst du es tun, weil die Norm sagt, dass du es tun musst.

Der Grund, warum Vorlagen von ODR ausgenommen sind, ist einfach, dass es keine andere Wahl gibt.

Eine Vorlage ist aus der Sicht des Compilers kein “greifbares Endprodukt”. Die Implementierung von Vorlagen muss mitgeführt werden, damit sie bei Verwendung zu kompilierbarem Code erweitert werden können. Folglich muss es in einer Header-Datei liegen, und doppelte Definitionen von verschiedenen Kompilierungseinheiten sind konsequent und unvermeidbar. Da dies unvermeidbar ist, geht die Norm einen Kompromiss ein, um sie von ODR auszunehmen.

Eine Funktion ist ein Endprodukt, das leicht in Zielcode kompiliert werden kann, daher hassen es Compiler, potenziell widersprüchliche Definitionen zu sehen, selbst wenn es durchaus möglich ist, die Codes zu vergleichen und fortzufahren, wenn die Codes identisch sind. Die Compiler entscheiden jedoch, dass sie viel zu faul sind, um eine solche zusätzliche Überprüfung durchzuführen, und daher verbietet der Standard mehrere Definitionen.

Nun, ein explizit/vollständig Spezialisierung einer Template-Funktion ist de facto eine Funktion, keine Vorlage – da alle fehlenden Teile ausgefüllt wurden und es nicht mehr nötig ist, die Definition der spezialisierten Funktion mit sich herumzutragen. Im Gegensatz dazu ist A teilweise Spezialisierung ist de facto eine Vorlage, da deren Implementierung noch während der Kompilierung herumgetragen werden muss. Daher genießen partielle Template-Spezialisierungen die von Templates geerbte Ausnahme, während explizite/vollständige Spezialisierungen dies nicht tun.