definizioni distinte di modelli variadic

Question

(domanda finale in basso)

Recentemente, ho chiesto a question riguardo a come avrei correggere errori del linker (sui simboli duplicati riguardanti più definizioni di un vuoto modello.

Perché Stavo usando le funzioni in più file sorgente, mi è stato suggerito di usare la parola chiave inline per consentire dichiarazioni nell'intestazione o mettere le dichiarazioni in un file sorgente compilato

Dopo aver capito che inline ha avuto alcune ripercussioni negative, ho inserito le mie dichiarazioni in un file sorgente.

Ora, questo andava bene, tranne che per i modelli variadic:

template<typename T, typename... Args> 
void cleanup(T *t, Args&&... args); 

ho trovato alcune soluzioni apparenti - ma non per i modelli variadic - utilizzare un file .tpp (ma ha cominciato dichiarando ancora una volta simboli duplicati) o mantenere il file sorgente e aggiungere istanze esplicite.

Ma il void cleanup ha il potenziale per essere utilizzato centinaia di combinazioni di parametri, quindi non voglio istanziare esplicitamente tutto.

Domanda: Così, come potrei fare per entrambi i

1. Mantenere le definizioni variadic template nel file di origine o
2. Mettere le definizioni in un file .tpp senza ottenere simboli duplicati, e in definitiva evitare di utilizzare inline?

Esempi di errori di simboli duplicati/non definiti per la dichiarazione .tpp e rispettivamente la definizione di modello sopra riportata in un file di origine.

duplicate symbol __Z7cleanupI10SDL_WindowJEEvPT_DpOT0_ in: 
    CMakeFiles/Game.dir/Game/main.cc.o 
    CMakeFiles/Game.dir/Game/RichTools/rtexture.cc.o 

_

Undefined symbols for architecture x86_64: 
    "void cleanup<SDL_Renderer, SDL_Window*&>(SDL_Renderer*, SDL_Window*&&&)", 
referenced from: 
cleanQuit() in main.cpp.o 
ld: symbol(s) not found for architecture x86_64 

Answer 1

Il consiglio in risposta alla tua prima domanda: per fare in linea o passare al file sorgente era solo circa le funzioni completamente specializzate - questi con elenco di parametri vuoto template <>.

Quindi, che:

Il file di intestazione:

// This shall be in header - it is not full specialization: 
template<typename T, typename... Args> 
void cleanup(T *t, Args&&... args){ 
    //Cleanup the first item in the list 
    cleanup(t); 
    //Recurse to clean up the remaining arguments 
    cleanup(std::forward<Args>(args)...); 
} 
// These shall be only declared here, and implemented in source file, 
// treat fully specialized function templates as regular functions 
template<> 
void cleanup<SDL_Window>(SDL_Window *win); 
template<> 
void cleanup<SDL_Renderer>(SDL_Renderer *ren); 
template<> 
void cleanup<SDL_Texture>(SDL_Texture *tex); 

il file sorgente:

template<> 
void cleanup<SDL_Window>(SDL_Window *win){ 
    if (!win){ 
     return; 
    } 
    SDL_DestroyWindow(win); 
} 
template<> 
void cleanup<SDL_Renderer>(SDL_Renderer *ren){ 
    if (!ren){ 
     return; 
    } 
    SDL_DestroyRenderer(ren); 
} 
template<> 
void cleanup<SDL_Texture>(SDL_Texture *tex){ 
    if (!tex){ 
     return; 
    } 
    SDL_DestroyTexture(tex); 
} 
template<> 
void cleanup<SDL_Surface>(SDL_Surface *surf){ 
    if (!surf){ 
     return; 
    } 
    SDL_FreeSurface(surf); 
}