Comment puis-je démanteler std::type_info::name pour révéler le type sous-jacent en C ?

De-Mangler pour std::type_info::name : Dévoilement du nom démystifié

Le nom mutilé par std::type_info reste énigmatique , ce qui rend difficile la compréhension du type sous-jacent. La recherche d'une solution qui résout cette énigme a conduit à l'exploration de diverses approches.

Démanteler le nom mutilé

Une solution exploite les puissantes fonctionnalités de C 11 et g' s libstdc via la fonction abi::__cxa_demangle. Cette fonction décode le nom mutilé, renvoyant une chaîne lisible par l'homme.

Implémentation C 11

Dans l'implémentation C 11, la fonction demangle est incluse dans le "type .hpp", et la logique de démêlage réelle réside dans "type.cpp". L'extrait de code suivant illustre :

#include "type.hpp"

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 ;
}

Version compatible C 98

Pour ceux qui n'utilisent pas C 11, une alternative reste disponible. L'implémentation compatible C 98 dans "type.cpp" utilise une technique différente pour démanteler le nom :

#include "type.hpp"

struct handle {
    char* p;
    handle(char* ptr) : p(ptr) { }
    ~handle() { std::free(p); }
};

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

    int status = -4; 
    handle result( abi::__cxa_demangle(name, NULL, NULL, &status) );

    return (status==0) ? result.p : name ;
}

Utilisation et considérations

Le nom démêlé peut être récupéré en utilisant la fonction type, qui accepte une référence au type à démanteler. Le code suivant démontre son utilisation :

#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;
}

Conclusion

Grâce à ces techniques, les développeurs peuvent désormais dévoiler les identités cachées des noms de types mutilés, acquérant ainsi une meilleure compréhension de les types impliqués dans leur code.

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!