Я создавал класс шаблона, который преобразует тип в строку, описывающую его, например, typeinfo<int(*)()>::name() возвращает строку "int(*)()" (до пробела). Первоначально у меня было множество особых случаев, чтобы обойти тот факт, что typeid(...).name() удаляет ссылочные квалификаторы и cv-квалификаторы верхнего уровня, но потом я вспомнил, что передача типа в качестве параметра шаблона сохранит их. Итак, используя заголовок ABI, я получил что-то вроде этого:
#include <iostream>
#include <typeinfo>
#include <string>
#include <cxxabi.h>
using namespace std;
string demangle(const char* mangledName) {
int status;
char* result = abi::__cxa_demangle(mangledName, nullptr, nullptr, &status);
switch(status) {
case -1:
cerr << "Out of memory!" << endl;
exit(1);
case -2:
return mangledName;
case -3: // Should never happen, but just in case?
return mangledName;
}
string name = result;
free(result);
return name;
}
template<typename T> struct preserve_qualifiers {};
template<typename T> class typeinfo {
using wrap = preserve_qualifiers<T>;
public:
static const string name() {
string name = demangle(typeid(wrap).name());
int i = name.find_first_of('<');
if(i == string::npos) return name;
int j = name.length() - i - 2;
return name.substr(i + 1, j);
}
};
#define TypeOut(...) cout \
<< "Type " #__VA_ARGS__ ": " << endl \
<< " Mangled: " << typeid(__VA_ARGS__).name() << endl \
<< " Demangled: " << demangle(typeid(__VA_ARGS__).name()) << endl \
<< " typeinfo<>: " << typeinfo<__VA_ARGS__>::name() << endl
class A {};
template<typename T> class F {};
template<int T> class G {};
template<template<typename> class T> class H {};
template<template<int> class T> class I {};
template<typename... T> class J {};
template<int... T> class K {};
template<template<typename> class... T> class L {};
template<template<int> class... T> class M {};
template<template<typename> class... T> class N {};
template<template<template<typename> class...> class... T> class O {};
struct bits {int i : 4, j : 2;};
template<typename T, int n> struct bits2 {T val : n;};
int main(int argc, char* argv[]) {
TypeOut(void(*volatile)(void(*const)()));
TypeOut(int (A::*)());
TypeOut(int (A::*)()const);
TypeOut(int (A::*const)());
#ifdef __clang__
TypeOut(int (A::*)()&);
TypeOut(int (A::*)()&&);
#endif
TypeOut(F<int>);
TypeOut(G<3>);
TypeOut(H<F>);
TypeOut(I<G>);
TypeOut(J<int>);
TypeOut(K<3>);
TypeOut(L<F>);
TypeOut(M<G>);
TypeOut(N<F,F,F>);
TypeOut(O<N,N>);
}
Это компилируется и работает (почти) отлично в GCC (4.8). Однако GCC не поддерживает квалификаторы ref для функций-членов, поэтому попробовал его и в Clang (3.2), чтобы посмотреть, будет ли он работать. Это не так. Он отлично компилируется и работает без проблем, но большинство имен шаблонов не расшифровываются, равно как и функции-члены с указанием ссылки.
Здесь представлен вывод GCC из ideone (код был немного изменен, так как версия GCC для ideone не поддерживает объявления nullptr или псевдонимов). Обратите внимание на отсутствующий квалификатор const в параметре функции. Это единственное, что не сработало, как я надеялся, в GCC. То же самое и в Clang, что, я думаю, не особенно удивительно. (Что удивительно, так это то, что он вообще отсутствует, а не то, что GCC и Clang согласуются с ним.)
К сожалению, при компиляции и запуске с помощью Clang шаблонные классы с переменным числом аргументов не удалось разобрать. Например, J был искажен до 1JIJiEE вместо 1JIIiEE, который выбрал GCC.
Выбранный вывод из clang (показаны только те, которые не сработали)
Type int (A::*)()&:
Mangled: M1AFivRE
Demangled: M1AFivRE
typeinfo<>: 19preserve_qualifiersIM1AFivREE
Type int (A::*)()&&:
Mangled: M1AFivOE
Demangled: M1AFivOE
typeinfo<>: 19preserve_qualifiersIM1AFivOEE
Type J<int>:
Mangled: 1JIJiEE
Demangled: 1JIJiEE
typeinfo<>: 19preserve_qualifiersI1JIJiEEE
Type K<3>:
Mangled: 1KIJLi3EEE
Demangled: 1KIJLi3EEE
typeinfo<>: 19preserve_qualifiersI1KIJLi3EEEE
Type L<F>:
Mangled: 1LIJ1FEE
Demangled: 1LIJ1FEE
typeinfo<>: 19preserve_qualifiersI1LIJ1FEEE
Type M<G>:
Mangled: 1MIJ1GEE
Demangled: 1MIJ1GEE
typeinfo<>: 19preserve_qualifiersI1MIJ1GEEE
Type N<F,F,F>:
Mangled: 1NIJ1FS0_S0_EE
Demangled: 1NIJ1FS0_S0_EE
typeinfo<>: 19preserve_qualifiersI1NIJ1FS1_S1_EEE
Type O<N,N>:
Mangled: 1OIJ1NS0_EE
Demangled: 1OIJ1NS0_EE
typeinfo<>: 19preserve_qualifiersI1OIJ1NS1_EEE
Кто-нибудь знает, как это можно решить? Это ошибка в clang? (Или, может быть, ошибка в GCC?) Моим первым подозрением была несовместимость версий между C++ ABI, связанным с моим кодом, и C++ ABI, который использует clang. Тот факт, что проблема возникает только с новыми функциями С++ 11 (квалификаторы ссылок на функции-члены и шаблоны с переменным числом переменных), похоже, подтверждает это подозрение... хотя ссылки на r-значения (например) не имеют проблемы.
Если это уместно, я использую Mac OSX Lion, а GCC 4.8 и clang 3.2 были установлены с MacPorts. Я использую следующие команды для компиляции:
clang++-mp-3.2 -isystem/usr/local/include/c++/v1 -stdlib=libc++ -std=gnu++11 typeinfo-min.cpp -o typeinfofun-clang
G++-mp-4.8 -std=gnu++11 typeinfo-min.cpp -o typeinfofun-gcc
Флаг isystem кажется необходимым, чтобы позволить clang найти заголовки libc++ (что было необходимо, когда я использовал <type_traits> для более сложной версии этого). Без него он даже не сможет найти <iostream>.
(Дополнительное примечание: эта проблема влияет и на более сложную версию, поскольку имена классов не были — что, вероятно, неудивительно — не среди специализаций для сложных типов, и, таким образом, просто использовался вызов ABI demangle.)
(Кроме того, мне любопытна переносимость этого. Я знаю, что в MSVC это не обязательно, так как это возвращает неискаженное имя из typeid(...).name(), но помимо этого...)
