我想获取类型名称并将其打印出来以进行调试。我使用以下代码：
#include <cxxabi.h>
inline const char* demangle(const char *s) {
abi::__cxa_demangle(s, 0, 0, NULL);
}
template<typename T>
inline const char* type_name() {
return demangle(typeid(T).name());
}
它的功能很好，但我认为存在不必要的运行时开销。是否有一种方法可以在编译时计算出可读性更高的类型标识符呢？我想到了类似于这样的东西：
boost::mpl::type_name<MyType>::value
该函数将返回一个类型名称的字符串常量。
typeid(T).name() 会产生运行时开销。如果 expr 是多态类型，那么 typeid(expr) 会有运行时开销。这种方法的主要优点是您无需启用RRTI。另一方面，类名的提取可能与编译器有关。
template <class MyT>
class NamedClass
{
static std::string ComputeClassName()
{
std::string funcMacro=__FUNCTION__;
//compiler dependant
static const std::string start="scul::NamedClass<class ";
static const std::string end=">::ComputeClassName";
return funcMacro.substr(start.size(),funcMacro.size()-end.size()-start.size());;
}
static const std::string _ClassName;
};
template <class MyT>
const std::string NamedClass<MyT>::_ClassName=NamedClass<MyT>::ComputeClassName();
您可以使用标准的 std::source_location，其中它的静态方法 ::current 是 consteval，这意味着您可以在编译时使用它，然后您可以获取 function_name 方法。
template <typename T>
consteval auto func_name() {
const auto& loc = std::source_location::current();
return loc.function_name();
}
template <typename T>
consteval std::string_view type_of_impl_() {
constexpr std::string_view functionName = func_name<T>();
// since func_name_ is 'consteval auto func_name() [with T = ...]'
// we can simply get the subrange
// because the position after the equal will never change since
// the same function name is used
// another notice: these magic numbers will not work on MSVC
return {functionName.begin() + 37, functionName.end() - 1};
}
template <typename T>
constexpr auto type_of(T&& arg) {
return type_of_impl_<decltype(arg)>();
}
template <typename T>
constexpr auto type_of() {
return type_of_impl_<T>();
}
注意：源代码位置对象中的函数名称可能因编译器而异，如果您的编译器尚未支持源代码位置库，则可以使用宏__PRETTY_FUNCTION__或任何其他相关宏。
int x = 4;
// type_of also preserves value category and const-qualifiers
// note: it returns std::string_view
type_of(3); // int&&
type_of(x); // int&
type_of(std::as_const(x)); // const int&
type_of(std::move(x)); // int&&
type_of(const_cast<const int&&>(x)); // const int&&
struct del { del() = delete; };
type_of<del>(); // main()::del (if inside main function)
// type_of(del{}); -- error
type_of<int>(); // int
type_of<const int&>(); // const int&
type_of<std::string_view>(); // std::basic_string_view<char>
type_of([]{}); // main()::<lambda()>&&
type_of<decltype([]{})>(); // main()::<lambda()>
type_of<std::make_index_sequence<3>>(); // std::integer_sequence<long unsigned int, 0, 1, 2>
// let's assume this class template is defined outside main function:
template <auto X> struct hello {};
type_of<hello<1>>(); // hello<1>
type_of<hello<3.14f>>(); // hello<3.1400001e+0f>
// also this:
struct point { int x, y; };
type_of<hello<point{.x = 1, .y = 2}>>() // hello<point{1, 2}>
type_of比在typeid(...).name()中使用解构名称的优势：（同时注意：我没有测试其他编译器的能力，因此我只保证对于GCC）
static_assert(type_of(4.0) == "double&&")是有效的。const，volatile，& 和 &&）。