Récupérer le nom d'une classe c++ par programme

Question

Je me demandais s'il était possible en C++ de récupérer le nom d'une classe sous forme de chaîne sans avoir à le coder en dur dans une variable ou un getter. Je suis conscient qu'aucune de ces informations n'est utilisée au moment de l'exécution et qu'elles ne sont donc pas disponibles, mais existe-t-il des macros permettant de créer cette fonctionnalité ?

Edit : Il peut être utile de préciser que j'essaie en fait de récupérer le nom d'une classe dérivée, et que j'utilise Visual C++ 2008 Express Edition.

Answer 1

Vous pouvez utiliser typeid :

#include <typeinfo>

std::cout << typeid(obj).name() << "\n";

Cependant, le nom du type n'est pas normalisé et peut différer d'un compilateur à l'autre (ou même d'une version à l'autre du même compilateur), et il n'est généralement pas lisible par l'homme parce qu'il est mutilé .

Sous GCC et clang (avec libstdc++ et libc++), vous pouvez démêler les noms à l'aide de la commande __cxa_demangle fonction (sur MSVC, le démêlage ne semble pas nécessaire) :

#include <cxxabi.h>
#include <cstdlib>
#include <memory>
#include <string>

std::string demangle(char const* mangled) {
    auto ptr = std::unique_ptr<char, decltype(& std::free)>{
        abi::__cxa_demangle(mangled, nullptr, nullptr, nullptr),
        std::free
    };
    return {ptr.get()};
}

Cela permettra toujours ne doit pas nécessairement être un nom lisible - par exemple, std::string est un nom de type pour le type réel, et son nom de type complet dans la libstdc++ actuelle est std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > Par contre, dans la libc++ actuelle, c'est std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > . "Prettifier" les alias de type n'est malheureusement pas trivial.

Answer 2

Si vous voulez juste vérifier si c'est une certaine classe, alors

typeid(obj) == typeid(CSubClass)

fonctionnera toujours, quelles que soient les implémentations.

Sinon, un moyen pratique consiste à déclarer :

virtual const char* classname() { return "CMyClass";}

et mettre en œuvre par sous-classe.

Answer 3

El typeid(obj).name() thing donne toujours le type de la variable tel qu'il a été déclaré, et non le type réel (classe) de l'objet. Si la variable obj est assignée à une instance d'une sous-classe de la classe pour laquelle obj a été déclarée, typeid ne le révèle pas, malheureusement.

Answer 4

Qu'en est-il de ceci,

Testé sur Windows 10 avec Visual Studio 2019 (v142).

#include <iostream>
#include <typeinfo>
#include <string>

/**
 @author    blongho
 @fn        template<typename Object> std::string classNameOf()

 @brief     Determine the class name of an object

 @tparam    Object  Type of the object.

 @returns   A name of the class
 @date      2019-09-06
 */

template<typename Object>
std::string classNameOf() {
    std::string name = typeid(Object).name(); //* user defined types gives "class Type"*\ 
    size_t spacePosition = name.find_first_of(" ");
    if (spacePosition != std::string::npos) {
        return name.substr(spacePosition + 1, name.length());
    }
    return name; // mostly primitive types
}

class Person {
private:
    /* data */
public:
    Person() {};
    ~Person() {};

};

class Data
{
private:
    /* data */
public:
    Data() {};
    ~Data() {};

};

struct Type {};

int main() {
    std::cout << "Class name of Person() is \"" << classNameOf<Person>() << "\"\n";
    std::cout << "Class name of Data() is \"" << classNameOf<Data>() << "\"\n";
    std::cout << "Class name of Type() is \"" << classNameOf<Type>() << "\"\n";
    std::cout << "Class name of double is \"" << classNameOf<double>() << "\"\n";
    std::cout << "Class name of std::string is \"" << classNameOf<std::string>() << "\"\n";
    std::cout << "Class name of int is \"" << classNameOf<int>() << "\"\n";
    std::cout << "Class name of float is \"" << classNameOf<float>() << "\"\n";
    std::cout << "Class name of char is \"" << classNameOf<char>() << "\"\n";
    return 0;
}

---

Output

Class name of Person() is "Person"
Class name of Data() is "Data"
Class name of Type() is "Type"
Class name of double is "double"
Class name of std::string is "std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >"
Class name of int is "int"
Class name of float is "float"
Class name of char is "char"

Dans Ubuntu 18.04,

g++ -o test src/main.cpp
./test
Class name of Person() is "6Person"
Class name of Data() is "4Data"
Class name of Type() is "4Type"
Class name of double is "d"
Class name of std::string is "NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"
Class name of int is "i"
Class name of float is "f"
Class name of char is "c"

Answer 5

Avec C++17, et une bibliothèque tierce vous pouvez maintenant obtenir le nom d'une classe comme suit

#include <iostream>
#include "nameof.hpp"

namespace test {
    class Object {};
}

int main() {
    constexpr auto obj_name = nameof::nameof_type<test::Object>();
    std::cout << obj_name << std::endl;
    // this prints "test::Object"
}

Cette méthode n'utilise que des informations de compilation, elle peut donc être constexpr . Notez qu'il n'est pas portable ; par exemple, le compilateur d'Intel n'est pas supporté.