definizione multipla della specializzazione del modello quando si utilizzano oggetti diversi

Quando utilizzo un modello specializzato in diversi file oggetto, ricevo un errore di "definizione multipla" durante il collegamento. L'unica soluzione che ho trovato consiste nell'usare la funzione "inline", ma sembra solo una soluzione alternativa. Come risolverlo senza utilizzare la parola chiave "inline"? Se non è possibile, perché?

Ecco il codice di esempio:

paulo@aeris:~/teste/cpp/redef$ cat hello.h 
#ifndef TEMPLATE_H
#define TEMPLATE_H

#include <iostream>

template <class T>
class Hello
{
public:
    void print_hello(T var);
};

template <class T>
void Hello<T>::print_hello(T var)
{
    std::cout << "Hello generic function " << var << "\n";
}

template <> //inline
void Hello<int>::print_hello(int var)
{
    std::cout << "Hello specialized function " << var << "\n";
}

#endif

paulo@aeris:~/teste/cpp/redef$ cat other.h 
#include <iostream>

void other_func();

paulo@aeris:~/teste/cpp/redef$ cat other.c 
#include "other.h"

#include "hello.h"

void other_func()
{
    Hello<char> hc;
    Hello<int> hi;

    hc.print_hello('a');
    hi.print_hello(1);
}

paulo@aeris:~/teste/cpp/redef$ cat main.c 
#include "hello.h"

#include "other.h"

int main()
{
    Hello<char> hc;
    Hello<int> hi;

    hc.print_hello('a');
    hi.print_hello(1);

    other_func();

    return 0;
}

paulo@aeris:~/teste/cpp/redef$ cat Makefile
all:
    g++ -c other.c -o other.o -Wall -Wextra
    g++ main.c other.o -o main -Wall -Wextra

Finalmente:

paulo@aeris:~/teste/cpp/redef$ make
g++ -c other.c -o other.o -Wall -Wextra
g++ main.c other.o -o main -Wall -Wextra
other.o: In function `Hello<int>::print_hello(int)':
other.c:(.text+0x0): multiple definition of `Hello<int>::print_hello(int)'
/tmp/cc0dZS9l.o:main.c:(.text+0x0): first defined here
collect2: ld returned 1 exit status
make: ** [all] Erro 1

Se rimuovo il commento "inline" all'interno di hello.h, il codice verrà compilato ed eseguito, ma mi sembra solo una sorta di "soluzione alternativa": cosa succede se la funzione specializzata è grande e utilizzata molte volte? Otterrò un binario grande? C'è un altro modo di fare questo? Se sì, come? In caso contrario, perché?

Ho provato a cercare risposte, ma tutto ciò che ho ottenuto è stato "utilizzare in linea" senza ulteriori spiegazioni.

Grazie

Intuitivamente, quando si specializza completamente qualcosa, non dipende più da un parametro del modello, quindi a meno che non si effettui la specializzazione in linea, è necessario inserirla in un file .cpp invece di .h o si finisce per violare il una regola di definizione come dice David. Si noti che quando si specializzano parzialmente i modelli, le specializzazioni parziali dipendono ancora da uno o più parametri del modello, quindi vanno ancora in un file .h.

La parola chiave inline è più per dire al compilatore che il simbolo sarà presente in più di un file oggetto senza violare la regola di una definizione che per l'inlining effettivo, che il compilatore può decidere di fare o non fare.

Il problema che stai riscontrando è che senza l'inline, la funzione verrà compilata in tutte le unità di traduzione che includono l'intestazione, violando l'ODR. Aggiungere inlinec'è la strada giusta da percorrere. Altrimenti, puoi inoltrare la dichiarazione della specializzazione e fornirla in un'unica unità di traduzione, come faresti con qualsiasi altra funzione.

Hai esplicitamente istanziato un modello nell'intestazione (void Hello<T>::print_hello(T var) ). Questo creerà più definizioni. Puoi risolverlo in due modi:

1) Rendi la tua istanziazione in linea.

2) Dichiarare l'istanza in un header e poi implementarla in un cpp.

Ecco alcune parti dello standard C ++ 11 relative a questo problema:

Una specializzazione esplicita di un modello di funzione è inline solo se è dichiarato con l'identificatore inline o definito come cancellato e indipendentemente dal fatto che il modello di funzione sia inline. [ Esempio:

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

template <> inline void f <> (int) {/ * ... /} // OK: inline template <> int g <> (int) {/ ... * /} // OK: non inline - end esempio ]

Quindi, se effettui alcune specializzazioni esplicite (ovvero complete) dei modelli in *.hfile, dovrai comunque inlineaiutarti a sbarazzarti della violazione di ODR .