Chiamare la versione non specificata di una funzione specializzandola in C++?

Question

Dire che ho una classe template:

template <typename T> 
class foo { 
    void do_someting(T obj) { 
    // do something generic... 
    } 
}; 

e voglio specializzarmi fa_qualcosa, ma all'interno di esso voglio chiamare il "normale" funzione fai_qualcosa:

template<> 
void foo<MyObj>::do_something(MyObj obj) { 
    // do something specific... 
    // and ALSO do something generic! 
} 

c'è un modo per riferirsi alla versione normale di do_qualcosa all'interno della mia funzione specializzata? O devo solo copiare il codice?

(So che potrei refactor foo in modo tale che non avrei questo problema esatto, ma come accade non posso davvero modificare il "vero" pippo, in quanto è codice fortemente condiviso.)

Answer 1

No. La tua specializzazione è l'unica definizione che esisterà per l'argomento di tipo MyObj. Ma, considerare modificando il modello foo in questo modo, che sarà trasparente agli attuali utilizzatori del modello:

template<typename T> 
class foo { 
    void prelude(T &obj){ // choose a better name 
    /* do nothing */ 
    } 
    void do_something(T obj){ 
    prelude(obj); 
    // do something generic... 
    } 
}; 

Poi definire una specializzazione per prelude:

template<> 
void foo<MyObj>::prelude(MyObj &obj){ 
    // do something specific 
} 

Questo è simile a struttura allo main use case for private virtual members. (Si tratta di qualcosa che mi ha ispirato in questa risposta.)

Answer 2

Si potrebbe anche considerare un tipo che non è MyObj, ma in modo implicito si converte ad esso, ma il modo migliore sarebbe quello di refactoring e forse estrarre il qualcosa di generico comune

#include <iostream> 
#include <boost/ref.hpp> 
typedef int MyObj; 


template <typename T> 
struct foo { 
    void do_something(T obj) { 
    // do something generic... 
    std::cout << "generic " << obj << '\n'; 
    } 
}; 

template<> 
void foo<MyObj>::do_something(MyObj obj) { 
    // do something specific... 
    std::cout << "special " << obj << '\n'; 
    // and ALSO do something generic! 
    foo<boost::reference_wrapper<MyObj> >().do_something(boost::ref(obj)); 
} 

int main() 
{ 
    foo<int> f; 
    f.do_something(10); 
} 

Answer 3

Sì, questo questo è in realtà abbastanza semplice. Lasciate semplicemente che la versione generica principale della vostra funzione serva da pass-through per una funzione generica di 'implementazione' che non sia parzialmente specializzato, quindi potete semplicemente chiamarlo dalla versione specializzata della funzione iniziale come necessario .

template <typename T> 
class foo 
{ 
    void do_something(T obj) 
    { 
    do_something_impl(obj); 
    } 

    void do_something_impl(T obj) 
    { 
    // do something generic... 
    } 
}; 

Ora la specializzazione può chiamare la versione generica senza problemi:

template<> 
void foo<MyObj>::do_something(MyObj obj) 
{ 
    // do something specific... 
    do_something_impl(obj); //The generic part 
} 

penso che questo più vicino alle tue intenzioni originali di risposta di Steve M., ed è quello che faccio quando di fronte a questa edizione.