C++ Builder 参考手册 ➙ C++ Builder 获取任意一个类或对象的类名
前面写了两篇关于 C++ Builder 反射的文章，应该写第三篇了。前面两篇都是关于从 TObject 继承的类的反射，那么其他类到底和 TObject 继承的类有什么不同？又是因为什么影响了其他类的反射？与前一篇文章《 C++ Builder 的反射 (二) - Reflection Factory 》比较，其他的类只差一个获取类名，从 TObject 继承的类可以直接通过类名或对象指针得到类名字符串，而其他的类不能。本文程序和例子在 C++ Builder 10.2.3 版本 clang 32位和 clang64位编译器测试通过。
C++ Builder 获取类名的方法
1.1. THsuanluClassName 类及使用方法
1.2. THsuanluClassName 类的实现
获取类名的示例程序
1. C++ Builder 获取类名的方法

1.1. THsuanluClassName 类及使用方法

class THsuanluClassName
public:
    static UnicodeString _TObject_QualifiedClassName(UnicodeString s); // Vcl.StdCtrls.TMemo -> Vcl::Stdctrls::TMemo
    static UTF8String _TypeNameToQualifiedClassName32(UTF8String s);   // $Hsuanlu@Test@THsuanluClass -> Hsuanlu::Test::THsuanluClass
    static UTF8String _TypeNameToQualifiedClassName64(UTF8String s);   // N7Hsuanlu4Test13THsuanluClassE -> Hsuanlu::Test::THsuanluClass
    static UTF8String _TypeNameToQualifiedClassName(UTF8String s);     // Hsuanlu::Test::THsuanluClass
    static UTF8String _TypeNameToClassName(UTF8String s);              // THsuanluClass
    template <class T>
    static UnicodeString GetClassName(std::true_type)
        return T::ClassName(); // 这是从 TObject 继承的类的类名
    template <class T>
    static UnicodeString GetClassName(std::false_type)
        return _TypeNameToClassName(typeid(T).name()); // 不是从 TObject 继承的类的类名
    template <class T>
    static UnicodeString GetClassName(T*) // 通过对象指针获取类名
        return GetClassName<T>(std::bool_constant<__is_base_of(TObject,T)>());
    template <class T>
    static UnicodeString GetClassName(void) // 直接获取类的类名
        return GetClassName<T>(std::bool_constant<__is_base_of(TObject,T)>());
    template <class T>
    static UnicodeString GetQualifiedClassName(std::true_type)
        return _TObject_QualifiedClassName(T::QualifiedClassName()); // 这是从 TObject 继承的类的类名，带命名空间
    template <class T>
    static UnicodeString GetQualifiedClassName(std::false_type)
        return _TypeNameToQualifiedClassName(typeid(T).name()); // 不是从 TObject 继承的类的类名，带命名空间
    template <class T>
    static UnicodeString GetQualifiedClassName(T*) // 通过对象指针获取类名，带命名空间
        return GetQualifiedClassName<T>(std::bool_constant<__is_base_of(TObject,T)>());
    template <class T>
    static UnicodeString GetQualifiedClassName(void) // 直接获取类的类名，带命名空间
        return GetQualifiedClassName<T>(std::bool_constant<__is_base_of(TObject,T)>());
这个类里面都是静态函数和静态函数模板，在实际应用上，一般只需要调用这两个成员：

• THsuanluClassName::GetClassName 获取类名；

• THsuanluClassName::GetQualifiedClassName 获取带命名空间的类名；

由于其他函数在某些特定环境可能会使用，所以都放在了 public: 里面。
使用方法：由于类型只能做模板参数，对象指针可以做函数参数，所以带参数的函数版本的参数是对象指针，不带参数的函数利用模板参数直接获取类的类名。
s = THsuanluClassName::GetClassName<TMemo>();

s = THsuanluClassName::GetClassName(Memo1);

都将得到 L"TMemo" 字符串。
s = THsuanluClassName::GetQualifiedClassName<TMemo>();

s = THsuanluClassName::GetQualifiedClassName(Memo1);

都将得到 L"Vcl::Stdctrls::TMemo" 字符串
通过 this 指针也可以得到当前代码所在类的类名，例如在窗口 Form1 的代码里面  THsuanluClassName::GetClassName(this) 可以得到字符串 "TForm1"
1.2. THsuanluClassName 类的实现
#include <memory>
#include <cxxabi.h> // $(BDS)\source\cpprtl\Source\libcxxabi\win64\include
UnicodeString THsuanluClassName::_TObject_QualifiedClassName(UnicodeString s)
    std::auto_ptr<TStringList> slNames(new TStringList);
    slNames->TrailingLineBreak = false;
    slNames->LineBreak = L".";
    slNames->Text = s;
    slNames->LineBreak = L"::";
    int iCount = slNames->Count;
    for(int iIdx=0; iIdx<iCount-1; iIdx++) // 处理命名空间
        UnicodeString s = slNames->Strings[iIdx];      // 从 TObject 继承的类的命名空间
        slNames->Strings[iIdx] = s.SubString(1,1).UpperCase()         // 第一个字母大写
                               + s.SubString(2,s.Length()).LowerCase(); // 其余字母小写
    return slNames->Text;
UTF8String THsuanluClassName::_TypeNameToQualifiedClassName32(UTF8String s)
    UTF8String sReal;
    const char *pChar = s.c_str();
    if(*pChar++ == '$')
        bool bTemplate = false;
        while(*pChar)
            if(bTemplate)
                if(*pChar == '$')
                    break;
                sReal += *pChar;
            else switch(*pChar)
                case '%': bTemplate = true; break;
                case '@': sReal += "::"; break;
                default : sReal += *pChar; break;
            pChar++;
    return sReal;
UTF8String THsuanluClassName::_TypeNameToQualifiedClassName64(UTF8String s)
    UTF8String sReal;
    char *psname = abi::__cxa_demangle(s.c_str(), nullptr, nullptr, nullptr);
    if(psname)
        sReal = psname;
        free(psname);
    return sReal;
UTF8String THsuanluClassName::_TypeNameToQualifiedClassName(UTF8String s)
    UTF8String sRealName = _TypeNameToQualifiedClassName32(s);
    if(sRealName.IsEmpty())
        sRealName = _TypeNameToQualifiedClassName64(s);
    if(sRealName.IsEmpty())
        sRealName = s;
    int iPos = sRealName.Pos("<");
    if(iPos > 0)
        sRealName = sRealName.SubString(1, iPos-1);
    return sRealName;
UTF8String THsuanluClassName::_TypeNameToClassName(UTF8String s)
    UTF8String sRealName = _TypeNameToQualifiedClassName(s);
    const char *pLastColon = std::strrchr(sRealName.c_str(),':');
    if(pLastColon)
        return pLastColon+1;
    return sRealName;
标准 C++ 的类，可以通过 typeid(T).name() 获取类型名，对于类来说，不仅仅是类名，还包含了命名空间和一些其他信息，这个格式并没有统一标准，gcc 和 clang 都给出了 abi::__cxa_demangle 函数把类型名转成类名，包含在头文件 cxxabi.h 里面。
C++ Builder 使用 clang 编译器，所以也应该有这个头文件，结果在 C++ Builder 的文件夹里面找到了在 $(BDS)\source\cpprtl\Source\libcxxabi\win64\include 这个文件夹里面，为什么在 Win64 里面，其他平台里面没有？经过测试，Win32 使用这个头文件可以编译通过，但是无法把类型名转成类名，Win64 可以转换成功，所以头文件就在 Win64 文件夹里面。
经过测试，C++ Builder 的 Win32 编译器类的类型名都是 $ 字符开头，命名空间之间用 @ 分割，例如 $Hsuanlu@Test@THsuanluClass 即为 Hsuanlu::Test::THsuanluClass，而 Win64 编译器生成的类名都是字母或数字开头的，所以程序就简单了，先判断如果 $ 开头使用这个规则，不是 $ 开头的使用 abi::__cxa_demangle 函数转换。
由于从 TObject 继承的类与标准 C++ 的类使用不同的 RTTI，TObject 是为了兼容 Delphi 程序，使用的是兼容的 Delphi RTTI，而其他的不从 TObject 继承的类，都是使用的标准 C++ RTTI，这两种 RTTI 不兼容，如果用 typeid(T).name() 获取 TObject 继承的类的类型名会抛出内存访问错误的异常，所以程序必须先判断是否从 TObject 继承，然后再判断是否 $ 开头的类型名。
函数 _TObject_QualifiedClassName 是把 TObject::QualifiedClassName 获取到的带命名空间的类名转成 C++ 格式，因为直接获取到的命名空间和类名之间用 . 分割，需要改成 ::，并且命名空间的大小写也和实际不符，所有这些类的命名空间应该是开头字母大写，其余小写，所以用这个函数转换。
函数 _TypeNameToQualifiedClassName32 把 $ 开头的类型名转成带命名空间的类名，如果类型是模板，类名会在第一个 % 和之后的第一个 $ 之间。
函数 _TypeNameToQualifiedClassName64 把字母和数字开头的类型名，使用 abi::__cxa_demangle 转成类名。
函数 _TypeNameToQualifiedClassName 把类型名转成带命名空间的类名，先使用 32 位那个 $ 开头的转换，如果转换失败，即开头不是 $，那么就使用 64 位那个字母或数字开头的类型名转换，如果都失败了，直接返回类型名。如果是模板，把模板参数去掉，即把第一个 < 和后面的东西删掉。
函数 _TypeNameToClassName 把类型名转成类名，先调用 _TypeNameToQualifiedClassName 得到带命名空间的类名，然后把命名空间去掉，保留最后一个 : 后面的部分。
由于 typeid(T).name() 返回的类型名是 UTF-8 编码的，所以处理类型名的函数都是 UTF8String 类型的参数和返回值，在 GetClassName 和 GetQualifiedClassName 里面调用并转成 UnicodeString 类型的，这也说明类型是可以用汉字或其他非英语语言的。
函数模板 GetClassName 使用 __is_base_of(TObject,T) 判断 T 是为 TObject 或他的子类，如果是，使用 std::true_type 参数的函数，如果否，使用 std::false_type 参数的函数。使用这个方法，而不是使用 if else，原因是 if else 无论是否满足条件都要编译，不满足条件会语法错误，而这个方法，不满足条件不但不会执行，也不会编译和检查语法错误。
2. 获取类名的示例程序
通过自己写的类 (非 TObject 继承) 和控件类 (TObject 继承) 测试获取类名。

包括带命名空间和不带命名空间的，同时也测试了汉字类名。
namespace Hsuanlu {
    namespace Test {
        class THsuanluClass
        public:
            THsuanluClass(){}
            virtual ~THsuanluClass(){}
            class TTest1{};
    class 玄坴测试类
    public:
        玄坴测试类(){}
    template<class T>
    class THsuanluTemp : public Test::THsuanluClass
using namespace Hsuanlu;
using namespace Hsuanlu::Test;
void __fastcall TForm1::Button1Click(TObject *Sender)
    THsuanluClass Obj;
    THsuanluClass::TTest1 t1;
    玄坴测试类 Test;
    const THsuanluClass Obj1;
    THsuanluTemp<double> Temp;
    Memo1->Lines->Add(THsuanluClassName::GetClassName(this));
    Memo1->Lines->Add(THsuanluClassName::GetClassName(Memo1));
    Memo1->Lines->Add(THsuanluClassName::GetClassName(&Obj));
    Memo1->Lines->Add(THsuanluClassName::GetClassName(&Obj1));
    Memo1->Lines->Add(THsuanluClassName::GetClassName(&t1));
    Memo1->Lines->Add(THsuanluClassName::GetClassName(&Test));
    Memo1->Lines->Add(L"");
    Memo1->Lines->Add(THsuanluClassName::GetClassName<TForm>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName<TMemo>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName<THsuanluClass>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName<THsuanluClass::TTest1>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName<玄坴测试类>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName<THsuanluTemp<UnicodeString>>());
    Memo1->Lines->Add(THsuanluClassName::GetClassName(&Temp));
    Memo1->Lines->Add(L"");
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(this));
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(Memo1));
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(&Obj));
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(&Obj1));
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(&t1));
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(&Test));
    Memo1->Lines->Add(L"");
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<TForm>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<TMemo>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<THsuanluClass>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<THsuanluClass::TTest1>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<玄坴测试类>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName<THsuanluTemp<UnicodeString>>());
    Memo1->Lines->Add(THsuanluClassName::GetQualifiedClassName(&Temp));
运行结果：
C++ Builder 的反射 (三) - 通用 Reflection Factory
C++ Builder 的反射 (二) - Reflection Factory
C++ Builder 的反射 (一) - Reflection 简单实现
枚举控件所有的属性、事件和方法
枚举窗口内所有的控件
C++ Builder 的枚举类型
C / C++ 可变参数的函数
C / C++ 可变参数的宏，__VA_ARGS__，...