Come avvolgere sovraccarichi di funzioni multiple con un oggetto funzione TR1 generico?

Question

Ho una funzione foo() che viene fornita in un contesto di libreria. La libreria definisce una manciata di sovraccarichi per questa funzione, come:.

char foo(float x, int y); 
short foo(double x, char y); 

(Feci il/tipi di risultato sopra argomenti up L'asporto è che non c'è una relazione generica tra i tipi di argomento e sovraccarico del corrispondente tipo di ritorno.)

L'idea è che l'utente della libreria possa aggiungere sovraccarichi per foo() per i propri tipi definiti dall'utente secondo necessità. L'overloading delle funzioni lo fa molto facilmente.

Mi piacerebbe rendere la famiglia di funzioni foo() utilizzabile in un'espressione Boost.Proto. Per fare ciò, penso che avrei bisogno di avvolgere quanto sopra in un oggetto funzione con un operatore modello di chiamata:

struct foo_wrap 
{ 
    template <typename A1, typename A2> 
    result_type operator()(A1 a1, A2 a2) { return foo(a1, a2); } 
}; 

Il problema è dotato di come definire result_type. Mi rendo conto che sarebbe facile con C++ 11 e decltype() e con i tipi di ritorno funzione finale, ma sto cercando una soluzione C++ 03. Pertanto, foo_wrap deve essere un oggetto funzione stile TR1. Devo trovare un modo per definire result_type come funzione di compilazione dei tipi di argomento A1 e A2. Questo è necessario non solo per il tipo di ritorno di operator(), ma anche per il protocollo TR1 result_of. In breve:

• Esiste una tecnica di metaprogrammazione che, dato un nome di funzione e un insieme di tipi di argomenti, restituirà il tipo di ritorno corrispondente della funzione?
• In alternativa, esiste un'altra tecnica che è possibile utilizzare per avvolgere sovraccarichi multipli di una funzione con un oggetto funzione generico?

Answer 1

Si può alimentare manualmente un tratti per questo:

template <typename A1, typename A2> 
struct foo_wrap_result; 

con

struct foo_wrap 
{ 
    template <typename A1, typename A2> 
    typename foo_wrap_result<A1, A2>::type 
    operator()(A1 a1, A2 a2) const { return foo(a1, a2); } 
}; 

e specializzazione dei tratti:

template <> 
struct foo_wrap_result<float, int> { typedef char type; }; 

template <> 
struct foo_wrap_result<double, char> { typedef short type; };