Perché decltype viene utilizzato nei tipi di restituzione finali?

Question

considerano i seguenti codici:

template< class T1 , class T2> 
auto calc(T1 a , T2 b) 
{ 
    return a + b ; 
} 


template< class T1 , class T2> 
auto calc(T1 a , T2 b) -> decltype(a + b) 
{ 
    return a + b ; 
} 

cosa è la differenza nel secondo codice? Puoi dare qualche esempio dove questo fa la differenza o fa la differenza qui?

Answer 1

Si noti che il tipo di ritorno semplice auto è qualcosa che è solo per C++ 14, mentre il tipo di ritorno finale con decltype è per C++ 11. La differenza arriva quando i riferimenti entrano nell'immagine, ad es. in codice come questo:

#include <type_traits> 

struct Test 
{ 
    int& data; 

    auto calc1() 
    { 
     return data; 
    } 

    auto calc2() -> decltype(data) 
    { 
     return data; 
    } 
}; 

int main() 
{ 
    int x; 
    Test t{x}; 
    static_assert(std::is_same<int, decltype(t.calc1())>::value, ""); 
    static_assert(std::is_same<int&, decltype(t.calc2())>::value, ""); 
} 

Se si desidera rimuovere ->decltype() e mantenere il vostro codice di comportarsi lo stesso, è possibile utilizzare il C++ 14 costrutto decltype(auto)

decltype(auto) calc3() // same as calc2() above 
{ 
    return data; 
} 

che conserva la referenceness del ritorno scrivi pure.

Se già sapete che il vostro tipo di ritorno è un riferimento, basta fare esplicita

auto& calc4() // same as calc2() above 
{ 
    return data; 
}