Qu'est-ce que ce type est auto & x = const int *?

Question

En fonction main, je créé une variable de pointeur const int, l'assigner à une variable déclarée par auto&. Ensuite, en utilisant le decltype(x) pour vérifier le type. Je m'attendais à ce que le type soit const int*. Mais is_same renvoie false.

int main() 
{ 
    int a = 10; 
    const int * cp_val= &a; 
    auto& x = cp_val; 
    bool is_const_int_ptr = std::is_same<decltype(x), const int *>::value; // returns 0 

    // *x = 100; // error: assignment of read-only location '* x' 
} 

Mais si j'ajoute la fonction d'aide suivante:

#include <boost/type_index.hpp> 

template<typename T> 
void print_type(T) 
{cout << "type T is: "<< boost::typeindex::type_id_with_cvr<T>().pretty_name()<< '\n';} 

Dans l'ensemble, j'invoque la fonction

print_type(x); // It returns int const* 

me manque quelque chose dans std::is_same-je?

Answer 1

déduction argument du modèle et auto sont intimement liés: La déclaration auto x = e; donne x du même type que f(e) donnerait à T dans une fonction inventée template <typename T> f(T);, et de même pour auto& et f(T&), const auto* et f(const T*), etc.

Par conséquent, pour obtenir la bonne réponse de Boost, vous devez déclarer:

template <typename T> void print_type(T&); 
//         ^^^^ 

Le ty pe de x est bien sûr const int*&.

Answer 2

Notez que pour auto& x, vous déclarez x comme référence explicitement; alors son type doit être const int *&, à savoir une référence à pointeur vers const int.

Voici une meilleure idée (de Effective moderne C++ (Scott Meyers)) pour obtenir le type précis à la compilation à partir du message d'erreur de compilation.

template <typename> 
struct TD; 

utiliser ensuite comme

TD<decltype(x)> td; 

vous obtiendrez un message d'erreur comme

source_file.cpp:15:21: error: implicit instantiation of undefined template 'TD<const int *&>' 
    TD<decltype(x)> td; 
        ^

LIVE

Votre fonction d'aide prend paramètre par valeur; la référence-ness de l'argument sera ignorée dans la déduction de type, c'est pourquoi vous avez const int*.