Determinazione del tipo di ritorno di "funzione generica" ​​

Question

Supponiamo di voler sviluppare una libreria generica che dovrebbe essere utilizzabile con tipi di tipo numerico compresi tipi doppi e definiti dall'utente. Il problema, che sto affrontando in questo momento è che non so come scrivere il tipo di ritorno di una funzione di modello molto simile a questo:

template<class T> 
auto transmogrify(T x) 
-> ??? 
{ 
    using std::abs; 
    return abs(x)+2.0; 
} 

La dichiarazione utilizzando rende il lavoro del corpo di questo modello di funzione per i tipi primitivi perché questi non hanno uno spazio dei nomi associato (e quindi non c'è ADL). Ma voglio che la trasmogrificazione usi funzioni abs specialistiche nel caso in cui l'autore di un tipo definito dall'utente fornisca la sua funzione abs. Non posso semplicemente utilizzare

-> decltype(abs(x)+2.0) 

perché questo non avrebbe funzionato per, diciamo, dal momento che raddoppia std :: abs non è nel campo di applicazione (per quanto posso dire). Ma scrivere

-> decltype(std::abs(x)+2.0) 

disabilita ADL. Ma disabilitare ADL non è un'opzione. Inoltre, il valore restituito da una funzione abs specifica potrebbe non essere di tipo T ma di un altro tipo.

Eventuali idee su come risolvere il problema del tipo restituito mentre (a) mantenere ADL e (b) ricadere su alcune funzioni predefinite (come std :: abs in questo caso) per i tipi che non forniscono un abs specializzato .

Answer 1

Utilizzare uno spazio dei nomi separato, in cui è possibile inserire la clausola using. Ciò impedisce l'inquinamento dello spazio dei nomi, poiché la clausola using si applica solo a tale spazio dei nomi. Consiglierei di nominarlo qualcosa di unico, quindi non lo spargerai per caso.

namespace transmog_detail 
{ 
    using std::abs; 

    template<class T> 
    auto transmogrify(T x) -> decltype(abs(x) + 2.0) 
    { 
     return abs(x) + 2.0; 
    } 
} 

// Then pull it into the current namespace, as recommended by @LucDanton. 
using transmog_detail::transmogrify; 

// Or if there is a reason, you can forward. 
// template<class T> 
// auto transmogrify(T x) 
// -> decltype(transmog_detail::transmogrify(x)) 
// { 
// return transmog_detail::transmogrify(x); 
// } 

Answer 2

Le risposte di cui sopra sono buone, ma il modo in cui simoplest mi viene in mente è quello di utilizzare l'intestazione typeinfo. è stato specificamente progettato per determinare i tipi e i costruttori di oggetti.

vedere qui: http://www.cplusplus.com/reference/std/typeinfo/type_info/