C++ Modo elegante per implementare l'assegnazione di un tipo diverso usando un metodo e senza preavviso?

Question

Devo implementare fondamentalmente la stessa funzione ma per dimensioni diverse. In particolare esso è qualcosa di simile ...

type& operator=(unsigned int); 
type& operator=(unsigned long int); 
type& operator=(unsigned long long int); 
type& operator=(int); 
type& operator=(long int); 
type& operator=(long long int); 
type& operator=(short int); 
//so on and so forth... 

Hanno a che fare esattamente la stessa cosa ... (tranne i dovrebbe tener conto delle diverse dimensioni), l'idea principale sarebbe "se il tipo è la più ampia usa il codice per l'attività ... altrimenti esegui un casting ed esegui il codice ". È possibile evitare tutto questo codice ripetitivo utilizzando un solo metodo? (Non voglio che il compilatore mi lanci un avvertimento quando compilo ...).

Grazie

Answer 1

questo lavoro per tutti i tipi integrali:

template< 
    typename T, 
    typename = std::enable_if_t<std::is_integral<T>::value> 
> 
type& operator= (T); 

Se si vuole dipendere da dimensioni, possono essere ottenuti con semplicemente sizeof(T). Puoi confrontarlo con la tua taglia più grande desiderata.

Se si desideravano due funzioni separate, è necessario inserire anche tale clausola e utilizzare una sorta di static-all.

Answer 2

Oltre alla answer of Bartek Banachewicz un modo alternativo per risolverlo:

struct type 
{ 
    ////Solution by Bartek Banachewicz 
    //template<typename T,typename = typename std::enable_if<std::is_integral<T>::value>::type> 
    //type& operator= (T) 
    //{ 
    // return *this; 
    //} 

    template<typename T> 
    auto operator=(T) -> typename std::enable_if<std::is_integral<T>::value, type>::type& 
    { 
     return *this; 
    } 
};