Est-il __CLASSE__ macro en C++?

Le problème avec l'aide de typeid(*this).name() est qu'il n'est pas this pointeur dans une méthode statique d'appel. La macro __PRETTY_FUNCTION__ rapports d'un nom de classe dans des fonctions statiques ainsi que les appels de méthode. Toutefois, cela ne fonctionne qu'avec gcc.

Voici un exemple de l'extraction de l'information par le biais d'une macro style de l'interface.

inline std::string methodName(const std::string& prettyFunction)
{
    size_t colons = prettyFunction.find("::");
    size_t begin = prettyFunction.substr(0,colons).rfind(" ") + 1;
    size_t end = prettyFunction.rfind("(") - begin;

    return prettyFunction.substr(begin,end) + "()";
}

#define __METHOD_NAME__ methodName(__PRETTY_FUNCTION__)

La macro __METHOD_NAME__ renverra une chaîne de la forme <class>::<method>(), de découper le type de retour, les modificateurs et les arguments de ce __PRETTY_FUNCTION__ vous donne.

Pour quelque chose qui extrait juste le nom de la classe, certaines précautions doivent être prises au piège de situations où il n'existe pas de classe:

inline std::string className(const std::string& prettyFunction)
{
    size_t colons = prettyFunction.find("::");
    if (colons == std::string::npos)
        return "::";
    size_t begin = prettyFunction.substr(0,colons).rfind(" ") + 1;
    size_t end = colons - begin;

    return prettyFunction.substr(begin,end);
}

#define __CLASS_NAME__ className(__PRETTY_FUNCTION__)

Je voudrais suggérer boost::typeindex, j'ai appris à propos de Scott Meyer "Effective C++ Moderne" Voici un exemple de base:

Exemple

#include <boost/type_index.hpp>

class foo_bar
{
    int whatever;
};

namespace bti =  boost::typeindex;

template <typename T>
void from_type(T t)
{
    std::cout << "\tT = " << bti::type_id_with_cvr<T>().pretty_name() << "\n";
}

int main()
{
    std::cout << "If you want to print a template type, that's easy.\n";
    from_type(1.0);
    std::cout << "To get it from an object instance, just use decltype:\n";
    foo_bar fb;
    std::cout << "\tfb's type is : "
              << bti::type_id_with_cvr<decltype(fb)>().pretty_name() << "\n";
}

Compilé avec g++ --std=c++14" ce produit est le suivant

Sortie

Si vous souhaitez imprimer un type de modèle, c'est facile.

T = double

Pour l'obtenir à partir d'une instance d'objet, il suffit d'utiliser decltype:

fb est de type : foo_bar

Si votre compilateur arrive à être g++ et que vous demandez __CLASS__ parce que vous voulez un moyen d'obtenir de l'actuel nom de la méthode, y compris la classe, __PRETTY_FUNCTION__ devrait aider (selon info gcc, section 5.43 les Noms de Fonction en tant que Chaînes).

Vous pouvez obtenir le nom de la fonction, y compris le nom de classe.
Cela peut processus de type C funcitons.

static std::string methodName(const std::string& prettyFunction)
{
    size_t begin,end;
    end = prettyFunction.find("(");
    begin = prettyFunction.substr(0,end).rfind(" ") + 1;
    end -= begin;
    return prettyFunction.substr(begin,end) + "()";
}

Voici une solution basée sur le __FUNCTION__ macro et les modèles C++:

template <class T>
class ClassName
{
public:
  static std::string Get()
  {
    //Get function name, which is "ClassName<class T>::Get"
    //The template parameter 'T' is the class name we're looking for
    std::string name = __FUNCTION__;
    //Remove "ClassName<class " ("<class " is 7 characters long)
    size_t pos = name.find_first_of('<');
    if (pos != std::string::npos)
      name = name.substr(pos + 7);
    //Remove ">::Get"
    pos = name.find_last_of('>');
    if (pos != std::string::npos)
      name = name.substr(0, pos);
    return name;
  }
};

template <class T>
std::string GetClassName(const T* _this = NULL)
{
  return ClassName<T>::Get();
}

Voici un exemple de comment cela pourrait être utilisé pour un enregistreur de classe

template <class T>
class Logger
{
public:
  void Log(int value)
  {
    std::cout << GetClassName<T>()  << ": " << value << std::endl;
    std::cout << GetClassName(this) << ": " << value << std::endl;
  }
};

class Example : protected Logger<Example>
{
public:
  void Run()
  {
    Log(0);
  }
}

La sortie de Example::Run sera ensuite

Example: 0
Logger<Example>: 0

Cela fonctionne très bien si vous êtes prêt à payer le coût d'un pointeur.

class State 
{
public:
    State( const char* const stateName ) :mStateName( stateName ) {};
    const char* const GetName( void ) { return mStateName; }
private:
    const char * const mStateName;
};

class ClientStateConnected
    : public State
{
public:
    ClientStateConnected( void ) : State( __FUNCTION__ ) {};
};

Méthode suivante (basée sur methodName() ci-dessus) peut également gérer les signaux d'entrée comme "int main(int argc, char** argv)":

string getMethodName(const string& prettyFunction)
{
    size_t end = prettyFunction.find("(") - 1;
    size_t begin = prettyFunction.substr(0, end).rfind(" ") + 1;

    return prettyFunction.substr(begin, end - begin + 1) + "()";
}