[C++] Istanziamento di funzioni template: dentro o fuori agli header?

[vendettaaaaa]

Ciao, ho questo curioso comportamento con il seguente codice nel file BbVector.hpp:
class BbVector
{
[...cut...]
private:
// ****************** Constructor functions
void create();
void create(size_type n, const double& val);

template<class Iter>
void create(Iter b, Iter e);

void uncreate();

[...cut...]

public:
// ****************** Constructors
BbVector() { create(); }
explicit BbVector(size_type n, const double& val = 0.) { create(n, val); }
BbVector(size_type n, const double* arr) { create(arr, arr + n); }
BbVector(const_iterator begin, const_iterator end) { create(begin, end); }
BbVector(const BbVector& other) { create(other.cbegin(), other.cend()); }
BbVector(BbVector&& other)
: myVector{other.myVector}, start{other.start}, avail{other.avail}, limit{other.limit}, mySize{other.mySize}
{ other.myVector = other.start = other.avail = other.limit = nullptr; }
BbVector(const std::initializer_list<double>& list);
explicit BbVector(const std::vector<double>& vec);
BbVector(const ColumnIterator& begin, const ColumnIterator& end);

Ebbene, se nel main scrivo:
BbVector a{ 2., 4. };
BbVector b{ a };
il codice compila tranquillamente usando GCC 4.8.1 in Debug/Release, e usando Clang in Debug. MA, Clang in release mi dà linker error:
"error: undefined reference to `void BbMath::BbVector::create<double const*>(double const*, double const*)'

Cioè: la funzione template<class Iter> create(Iter b, Iter e) è istanziata direttamente nell'header dov'è definita, poichè chiamata nel copy constructor del vector. E a quanto pare non viene vista dal linker. Se sposto il corpo del costruttore nel file BbVector.cpp, tutto va a posto.
Questo che significa? Che opzione di compilazione può causare questo problema? Vi risulta un comportamento anomalo o corretto? Non vorrei spostare il corpo del costruttore fuori dalla dichiarazione della classe, in quanto non sarebbe più inlined...

[nico159]

Sposta la dichiarazione di
template<class Iter>
void create(Iter b, Iter e);
Nell'header

http://stackoverflow.com/questions/3749099/why-should-the-implementation-and-the-declaration-of-a-template-class-be-in-the?lq=1

[vendettaaaaa]

Sposta la dichiarazione di
template<class Iter>
void create(Iter b, Iter e);
Nell'header

http://stackoverflow.com/questions/3749099/why-should-the-implementation-and-the-declaration-of-a-template-class-be-in-the?lq=1
Intendi la definizione. Vero...:muro:
Però perchè negli altri casi il compilatore andava a recuperare il corpo del template dal file .cpp?

[nico159]

Sì, mi ero confuso

Non so darti una risposta alla domanda perchè bisognerebbe conoscere come internamente funziona clang, insomma non cosa da nulla

[marco.r]

Intendi la definizione. Vero...:muro:
Però perchè negli altri casi il compilatore andava a recuperare il corpo del template dal file .cpp?

Faccio prima un breve riassunto di come funziona la storia, anche se probabilmente gia' la sai, che mi viene piu' semplice spiegare poi cosa accade:
Con il codice normale piu' o meno funziona cosi'
1 - Durante la compilazione quando trovi una chiamata a create(a,b) di cui
conosce solo la dichiarazione il compilatore lascia un "riferimento" alla funzione, nella speranza che venga definita da qualche altra parte. Se trova anche la definizione e valuta che val la pena fare l'inline allora la utilizza direttamente
2 - Durante la fase di link il linker cerca di risolvere il riferimento andando a pescare tra i vari file oggetto se/dove e' la definizione.

Nel caso dei template la cosa e' piu' complessa;
1- Quando trova una chiamata a create<A>(a,b), il compilatore verifica se trova oltre alla dichiarazione anche la definizione. Se trova la definizione allora genera il codice relativo ai tipi argomento (A nel nostro caso) e lo usa in loco. Questo potenzialmente genera piu' copie dello stesso codice, ma questa ridondanza viene eliminata successivamente dal linker. Se la definizione del codice non c'e', al pari del caso normale viene messo un riferimento alla funzione specializzata per quel tipo, nella speranza che venga generato il codice da qualche altra parte.
2 - Il linker opera analogamente al caso no-template, con l'accortezza di eliminare le parti di codice ridondanti.

La differenza sostanziale e' che mentre col codice normale quando il compilatore trova la definizione genera il codice corrispondente, per cui il codice il linker lo trova sempre, nelcaso dei template questo non accade, per cui e' necessario che per un tipo, ad esempio A venga chiamta create<A>(...) almeno in un punto in cui e' visibile la definizione. Questo e' imotivo che per garantire questo solitamente si mette anche la definizione dei template negli header. Quello che faccio o di solito e' avere un file .hpp con la dichiarazione dei metodi/funzioni/classi che include a sua volta un file .tcc (suffisso arbitrario) che contiene l'implementazione.

Da quel che descrivi tu l'ipotesi che faccio io e' che nel file cpp dove e' definito il template venga utilizzato in qualche modo la create(a,b) con lo stesso tipo che usi dall'altra parte e che quindi solitamente il codice relativo sia disponibile al linker. Con clang potrebbe essere che per qualche ottimizzazione tale chiamata viene eliminata per cui il compilatore non genera piu' il codice di create<> sottostante.
Un po' improbabile, ma non impossibile.

[vendettaaaaa]

Figo...thx! Più tardi lo rileggo meglio, la questione va valutata attentamente :D
E poi provo a contattare i dev di Clang per vedere cosa dicono.