¿Es posible imprimir el tipo de una variable en C++ estándar?

287

C++ 11 actualización a una pregunta muy antigua: Tipo de impresión variable en C++.

La respuesta aceptada (y buena) es usar typeid(a).name(), donde a es un nombre de variable.

Ahora en C++ 11 tenemos decltype(x), que puede convertir una expresión en un tipo. Y decltype() viene con su propio conjunto de reglas muy interesantes. Por ejemplo, decltype(a) y decltype((a)) generalmente serán tipos diferentes (y por razones buenas y comprensibles una vez que esos motivos están expuestos).

¿Nos ayudará nuestro confiable typeid(a).name() a explorar este mundo nuevo y valiente?

Nº

Pero la herramienta que no es tan complicado. Y es esa herramienta que estoy usando como respuesta a esta pregunta. Voy a comparar y contrastar esta nueva herramienta al typeid(a).name(). Y esta nueva herramienta en realidad está construida en la parte superior de typeid(a).name().

La cuestión fundamental:

typeid(a).name()

tira a la basura CV-calificadores, referencias y lvalue/rvalue-dad. Por ejemplo:

const int ci = 0; 
std::cout << typeid(ci).name() << '\n';

Para mí salidas:

y supongo que en las salidas de MSVC:

int

es decir, el const se ha ido. Esto no es un problema de QOI (Quality Of Implementation). El estándar ordena este comportamiento.

Lo que estoy recomendando a continuación es:

template <typename T> std::string type_name();

que se utilizaría como esto:

const int ci = 0; 
std::cout << type_name<decltype(ci)>() << '\n';

y para mí salidas:

int const

<disclaimer> No he probado esto en MSVC. </disclaimer> Pero agradezco los comentarios de quienes lo hacen.

La solución C++ 11

estoy usando __cxa_demangle para plataformas que no son de MSVC como recomendar por ipapadop en su respuesta a demangle tipos. Pero en MSVC confío en typeid para exigir nombres (no probados). Y este núcleo se basa en algunas pruebas sencillas que detectan, restauran e informan cv-calificadores y referencias al tipo de entrada.

#include <type_traits> 
#include <typeinfo> 
#ifndef _MSC_VER 
# include <cxxabi.h> 
#endif 
#include <memory> 
#include <string> 
#include <cstdlib> 

template <class T> 
std::string 
type_name() 
{ 
    typedef typename std::remove_reference<T>::type TR; 
    std::unique_ptr<char, void(*)(void*)> own 
      (
#ifndef _MSC_VER 
       abi::__cxa_demangle(typeid(TR).name(), nullptr, 
              nullptr, nullptr), 
#else 
       nullptr, 
#endif 
       std::free 
      ); 
    std::string r = own != nullptr ? own.get() : typeid(TR).name(); 
    if (std::is_const<TR>::value) 
     r += " const"; 
    if (std::is_volatile<TR>::value) 
     r += " volatile"; 
    if (std::is_lvalue_reference<T>::value) 
     r += "&"; 
    else if (std::is_rvalue_reference<T>::value) 
     r += "&&"; 
    return r; 
}

Los resultados

Con esta solución que pueda hacer esto:

int& foo_lref(); 
int&& foo_rref(); 
int foo_value(); 

int 
main() 
{ 
    int i = 0; 
    const int ci = 0; 
    std::cout << "decltype(i) is " << type_name<decltype(i)>() << '\n'; 
    std::cout << "decltype((i)) is " << type_name<decltype((i))>() << '\n'; 
    std::cout << "decltype(ci) is " << type_name<decltype(ci)>() << '\n'; 
    std::cout << "decltype((ci)) is " << type_name<decltype((ci))>() << '\n'; 
    std::cout << "decltype(static_cast<int&>(i)) is " << type_name<decltype(static_cast<int&>(i))>() << '\n'; 
    std::cout << "decltype(static_cast<int&&>(i)) is " << type_name<decltype(static_cast<int&&>(i))>() << '\n'; 
    std::cout << "decltype(static_cast<int>(i)) is " << type_name<decltype(static_cast<int>(i))>() << '\n'; 
    std::cout << "decltype(foo_lref()) is " << type_name<decltype(foo_lref())>() << '\n'; 
    std::cout << "decltype(foo_rref()) is " << type_name<decltype(foo_rref())>() << '\n'; 
    std::cout << "decltype(foo_value()) is " << type_name<decltype(foo_value())>() << '\n'; 
}

y la salida es:

decltype(i) is int 
decltype((i)) is int& 
decltype(ci) is int const 
decltype((ci)) is int const& 
decltype(static_cast<int&>(i)) is int& 
decltype(static_cast<int&&>(i)) is int&& 
decltype(static_cast<int>(i)) is int 
decltype(foo_lref()) is int& 
decltype(foo_rref()) is int&& 
decltype(foo_value()) is int

Nota (por ejemplo) la diferencia entre decltype(i) y decltype((i)). El primero es el tipo de la declaración de i. Este último es el "tipo" de la expresión i. (las expresiones nunca tienen tipo de referencia, pero como una convención decltype representa expresiones lvalue con referencias lvalue).

Por lo tanto, esta herramienta es un excelente vehículo para aprender acerca de decltype, además de explorar y depurar su propio código.

Por el contrario, si yo fuera a construir esta sólo en typeid(a).name(), sin añadir perdidos CV-calificadores o referencias, la salida sería:

decltype(i) is int 
decltype((i)) is int 
decltype(ci) is int 
decltype((ci)) is int 
decltype(static_cast<int&>(i)) is int 
decltype(static_cast<int&&>(i)) is int 
decltype(static_cast<int>(i)) is int 
decltype(foo_lref()) is int 
decltype(foo_rref()) is int 
decltype(foo_value()) is int

es decir, Cada referencia y cv-qualifier se elimina.

C++ 14 Actualización

Justo cuando crees que tienes una solución a un problema clavado, siempre hay alguien que sale de la nada y que muestra una manera mucho mejor. :-)

This answer de Jamboree muestra cómo obtener el nombre del tipo en C++ 14 en tiempo de compilación. Es una solución brillante por un par de razones:

¡Es en tiempo de compilación!
Usted obtiene el compilador para hacer el trabajo en lugar de una biblioteca (incluso una std :: lib).Esto significa resultados más precisos para las últimas características del lenguaje (como lambdas).

Jamboree's answer no deja todo en claro para VS, y estoy modificando su código un poco. Pero dado que esta respuesta tiene muchos puntos de vista, tómese un tiempo para ir allí y votar su respuesta, sin la cual, esta actualización nunca hubiera sucedido.

#include <cstddef> 
#include <stdexcept> 
#include <cstring> 
#include <ostream> 

#ifndef _MSC_VER 
# if __cplusplus < 201103 
# define CONSTEXPR11_TN 
# define CONSTEXPR14_TN 
# define NOEXCEPT_TN 
# elif __cplusplus < 201402 
# define CONSTEXPR11_TN constexpr 
# define CONSTEXPR14_TN 
# define NOEXCEPT_TN noexcept 
# else 
# define CONSTEXPR11_TN constexpr 
# define CONSTEXPR14_TN constexpr 
# define NOEXCEPT_TN noexcept 
# endif 
#else // _MSC_VER 
# if _MSC_VER < 1900 
# define CONSTEXPR11_TN 
# define CONSTEXPR14_TN 
# define NOEXCEPT_TN 
# elif _MSC_VER < 2000 
# define CONSTEXPR11_TN constexpr 
# define CONSTEXPR14_TN 
# define NOEXCEPT_TN noexcept 
# else 
# define CONSTEXPR11_TN constexpr 
# define CONSTEXPR14_TN constexpr 
# define NOEXCEPT_TN noexcept 
# endif 
#endif // _MSC_VER 

class static_string 
{ 
    const char* const p_; 
    const std::size_t sz_; 

public: 
    typedef const char* const_iterator; 

    template <std::size_t N> 
    CONSTEXPR11_TN static_string(const char(&a)[N]) NOEXCEPT_TN 
     : p_(a) 
     , sz_(N-1) 
     {} 

    CONSTEXPR11_TN static_string(const char* p, std::size_t N) NOEXCEPT_TN 
     : p_(p) 
     , sz_(N) 
     {} 

    CONSTEXPR11_TN const char* data() const NOEXCEPT_TN {return p_;} 
    CONSTEXPR11_TN std::size_t size() const NOEXCEPT_TN {return sz_;} 

    CONSTEXPR11_TN const_iterator begin() const NOEXCEPT_TN {return p_;} 
    CONSTEXPR11_TN const_iterator end() const NOEXCEPT_TN {return p_ + sz_;} 

    CONSTEXPR11_TN char operator[](std::size_t n) const 
    { 
     return n < sz_ ? p_[n] : throw std::out_of_range("static_string"); 
    } 
}; 

inline 
std::ostream& 
operator<<(std::ostream& os, static_string const& s) 
{ 
    return os.write(s.data(), s.size()); 
} 

template <class T> 
CONSTEXPR14_TN 
static_string 
type_name() 
{ 
#ifdef __clang__ 
    static_string p = __PRETTY_FUNCTION__; 
    return static_string(p.data() + 31, p.size() - 31 - 1); 
#elif defined(__GNUC__) 
    static_string p = __PRETTY_FUNCTION__; 
# if __cplusplus < 201402 
    return static_string(p.data() + 36, p.size() - 36 - 1); 
# else 
    return static_string(p.data() + 46, p.size() - 46 - 1); 
# endif 
#elif defined(_MSC_VER) 
    static_string p = __FUNCSIG__; 
    return static_string(p.data() + 38, p.size() - 38 - 7); 
#endif 
}

Este código se auto-retroceso en la constexpr si todavía está atascado en la antigua C++ 11. Y si estás pintando en la pared de la cueva con C++ 98/03, también se sacrificará el noexcept.

C++ 17 Actualización

En los comentarios a continuación Lyberta señala que el nuevo std::string_view puede reemplazar static_string:

template <class T> 
constexpr 
std::string_view 
type_name() 
{ 
    using namespace std; 
#ifdef __clang__ 
    string_view p = __PRETTY_FUNCTION__; 
    return string_view(p.data() + 34, p.size() - 34 - 1); 
#elif defined(__GNUC__) 
    string_view p = __PRETTY_FUNCTION__; 
# if __cplusplus < 201402 
    return string_view(p.data() + 36, p.size() - 36 - 1); 
# else 
    return string_view(p.data() + 49, p.find(';', 49) - 49); 
# endif 
#elif defined(_MSC_VER) 
    string_view p = __FUNCSIG__; 
    return string_view(p.data() + 84, p.size() - 84 - 7); 
#endif 
}

He actualizado las constantes para VS gracias a la muy agradable trabajo detectivesco por Jive Dadson en los comentarios a continuación.

¿Es posible imprimir el tipo de una variable en C++ estándar?

Respuesta

Cuestiones relacionadas