Comment puis-je démanteler les noms de types C mutilés de « std :: type_info » ?

Déchiffrer le nom énigmatique de std::type_info

Dans le domaine du C, std::type_info fournit des informations vitales sur le type d'une entité, illustrées par la classe instances ou fonctions. Cependant, la représentation mutilée de ce nom de type obscurcit souvent sa véritable identité. Par exemple, typeid(std::vector).name() donne "St6vectorIiSaIiEE", le rendant déchiffrable uniquement par des esprits astucieux ou des algorithmes obscurs.

Démêler le mystère

Pour apprivoiser cette bête mutilée, nous présentons une solution qui utilise les formidables capacités de démantelage de std::demangle, un outil puissant pour dévoiler la forme lisible par l'homme du type sous-jacent. Voici un guide étape par étape pour utiliser cette solution :

1. type.hpp : Établissez le fichier d'en-tête de base avec la déclaration suivante :

#include <string>
#include <typeinfo>

std::string demangle(const char* name);

template <class T>
std::string type(const T& t) {
    return demangle(typeid(t).name());
}

2. type.cpp (C 11) : Utiliser C 11 fonctionnalités pour des opérations de démêlage efficaces :

   #ifdef __GNUG__
   #include <cstdlib>
   #include <memory>
   #include <cxxabi.h>
   
   std::string demangle(const char* name) {
   int status = -4;
   std::unique_ptr<char, void(*)(void*)> res {
   abi::__cxa_demangle(name, NULL, NULL, &status),
   std::free
   };
   
   return (status==0) ? res.get() : name ;
   }
   
   #else
   std::string demangle(const char* name) {
   return name;
   }
   #endif

3. type.cpp (C 98) : Fournir une solution alternative pour les systèmes sans fonctionnalités C 11 :

   #ifdef __GNUG__
   #include <cstdlib>
   #include <memory>
   #include <cxxabi.h>
   
   struct handle {
   char* p;
   handle(char* ptr) : p(ptr) { }
   ~handle() { std::free(p); }
   };
   
   std::string demangle(const char* name) {
   
   int status = -4; // some arbitrary value to eliminate the compiler warning
   
   handle result( abi::__cxa_demangle(name, NULL, NULL, &status) );
   
   return (status==0) ? result.p : name ;
   }
   
   #else
   
   // does nothing if not g++
   std::string demangle(const char* name) {
   return name;
   }
   
   #endif

4. Utilisation : Intégrer la solution dans votre code pour extraire sans effort des noms de types lisibles par l'homme :

   #include <iostream>
   #include "type.hpp"
   
   struct Base { virtual ~Base() {} };
   struct Derived : public Base { };
   
   int main() {
   Base* ptr_base = new Derived(); 
   std::cout << "Type of ptr_base: " << type(ptr_base) << std::endl;
   std::cout << "Type of pointee: " << type(*ptr_base) << std::endl;
   delete ptr_base;
   }

En utilisant cette approche, le résultat suivant est produit :

Type of ptr_base: Base*
Type of pointee: Derived

Compatibilité et Mises en garde :
La solution fournie a été testée sur diverses plates-formes et compilateurs, notamment g , clang et Mingw32. Bien qu'elle cible principalement g , la version C 98 peut être utilisée sur des systèmes non-g. Il est essentiel de noter que les API spécifiques au fournisseur peuvent différer en conséquence.

En conclusion, cette solution de démêlage vous permet d'extraire sans effort des noms de types lisibles par l'homme de std::type_info, éliminant ainsi l'obscurité associée aux représentations mutilées. En tirant parti des extraits de code fournis, vous pouvez intégrer de manière transparente cette fonctionnalité dans vos projets, améliorant ainsi les capacités de débogage et de journalisation avec clarté et facilité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!