C++ applica la ricerca nome secondo passaggio nella funzione modello

Question

Esiste un modo per forzare i compilatori C++ a eseguire la ricerca del nome per un determinato simbolo durante l'istanziazione del modello (e non prima)?

Dato il seguente codice:

template <class T> 
auto wrapper(T t) -> decltype(f(t)) 
{ 
    return f(t); 
} 

unsigned char f(int x) { return x % 256; } 
unsigned char f(unsigned char x) { return x; } 

int main(int, char **) 
{ 
    auto x = wrapper(3100); 
    return 0; 
} 

C'è qualcosa che posso fare (a parte spostare la definizione di f verso l'alto), al fine di rendere il codice di compilazione e dare gli stessi risultati come se tutte le definizioni di f erano disponibili prima della definizione di wrapper?

Non sono riuscito a trovare nulla, probabilmente perché non so come formulare correttamente questa domanda. Tutti i tipi di argomento di f possono essere considerati tipi definiti dall'utente, se questo aiuta.

Answer 1

C'è qualche modo per forzare compilatori C++ per eseguire la ricerca dei nomi per un data simbolo durante istanziazione di template (e non prima)?

Sì. Prima di tutto, il nome deve essere dipendente. Il nome f in wrapper quando utilizzato come f(t) dipende dal fatto che t dipende dal tipo. [Temp.dep]/1:

In un'espressione della forma:

                postfix-espressione (espressione-list _opt)

dove il postfix-espressione è un qualificato-id, il qualificato-id denota un nome dipendente se

• qualsiasi espressioni nella espressione-list è un pacchetto di espansione (14.5.3),
• qualsiasi espressioni nella espressione-list è un tipo dipendente dalla espressione (14.6.2.2), o
• se il qualificato-id è un modello -id in cui nessuno degli argomenti modello dipende da un parametro di modello.

Il problema è che i nomi dichiarati dopo il modello stesso, vale a dire solo in l'istanza, ma non il contesto definizione, possono solo essere trovati utilizzando argomento nome dipendente ricerca. I suoi f sovraccarichi solo prendere tipi fondamentali, ma quelli non hanno lo spazio dei nomi globale associato con loro in base al [basic.lookup.argdep]/2:

Se T è un tipo fondamentale, i suoi gruppi associati di spazi dei nomi e Le classi sono entrambe vuote.

Così i f s stati dichiarati non possono mai essere trovato se gli argomenti sono dello stesso tipo dei parametri. Un piccolo trucco può aiutare:

template <typename T> 
struct refwrap 
{ 
    T&& t; 
    refwrap(T&& t) : t(std::forward<T>(t)) {} 
    operator T&&() {return std::forward<T>(t);} 
}; 

template <typename T> 
auto make_refwrap(T&& t) -> refwrap<T> // making use of reference collapsing 
{ return {std::forward<T>(t)}; }   // inside refwrap to get forwarding 

Questo modello, quando ha dichiarato nel namespace globale, causerà ADL a considerarlo. Riscrivere wrapper come segue:

template <class T> 
auto wrapper(T t) -> decltype(f(make_refwrap(t))) 
{ 
    return f(make_refwrap(t)); 
} 

Demo. Questo non è il modo corretto di farlo, poiché fallirà in scenari più complessi.

Answer 2

Ciò funzionerebbe con la specializzazione del modello. Nota che devi decidere quale sia la funzione predefinita, perché non riesco a vederla in questione.

// default function 
template <class T> 
unsigned char f(T x) { return x; } 

// specialization for int 
template <> 
unsigned char f(int x) { return x % 256; } 

int main(int, char **) 
{ 
    auto x = f(3100); 
    return 0; 
} 

Answer 3

Il seguente codice non è abbastanza pulito, ma illustra come modello di classe di specializzazione può essere utilizzato al fine di risolvere il problema. Mantiene l'interfaccia originale (ad esempio f e wrapper può essere utilizzata nello stesso modo di prima).

Grazie per avermi dato i consigli giusti. Sono aperto a una soluzione meno verbosa.

#include <type_traits> 

template <class ...> 
struct F; 

template <class T> 
auto wrapper(T t) 
    -> decltype(F<typename std::decay<T>::type>::f(t)) 
{ 
    return F<typename std::decay<T>::type>::f(t); 
} 

template <> 
struct F<unsigned char> 
{ 
    static unsigned char f(unsigned char x) { return x; } 
}; 

template <> 
struct F<int> 
{ 
    static unsigned char f(int x) { return x % 256; } 
}; 

template <class T> 
auto f(T t) 
    -> decltype(F<typename std::decay<T>::type>::f(t)) 
{ 
    return F<typename std::decay<T>::type>::f(t); 
} 

int main(int, char **) 
{ 
    auto x = wrapper(3100); 
    return 0; 
}