¿Existe una macro __CLASS__ en C ++?

100

¿Hay una __CLASS__macro en C ++ que da el nombre de la clase similar a la __FUNCTION__macro que da el nombre de la función?

mortal
fuente

Respuestas:

67

Lo más cercano que hay es llamar typeid(your_class).name(), pero esto produce un nombre mutilado específico del compilador.

Para usarlo dentro de la clase solo typeid(*this).name()

Aleksei Potov
fuente
2
typeid (* this) .name () se puede usar dentro de las funciones de clase
Aleksei Potov
2
Eso es mejor. En cuanto a conocer la clase, definir la matriz de caracteres suena mejor que posponerla hasta el tiempo de ejecución.
Michael Krelin - hacker
5
Es una lástima que no esté definido como __ CLASS __, ¡puede ser útil en la etapa de preprocesador! :(
k3a
2
@Max No lo hace, pero podría. De manera similar, conoce las funciones
:-P
5
@kexik: el preprocesador tampoco conoce las funciones, estándar __func__y no estándar __FUNCTION__no son macros. Microsoft documenta __FUNCTION__como una macro, pero el indicio de que no lo es en realidad es que el preprocesador no lo expande cuando compila con /P.
Steve Jessop
77

El problema con el uso typeid(*this).name()es que no hay thispuntero en una llamada a un método estático. La macro __PRETTY_FUNCTION__informa un nombre de clase en funciones estáticas, así como llamadas a métodos. Sin embargo, esto solo funcionará con gcc.

A continuación, se muestra un ejemplo de cómo extraer la información a través de una interfaz de estilo macro.

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__devolverá una cadena de la forma <class>::<method>(), recortando el tipo de retorno, modificadores y argumentos de lo que __PRETTY_FUNCTION__le da.

Para algo que extrae solo el nombre de la clase, se debe tener cuidado de atrapar situaciones donde no hay una clase:

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__)
Andrew Prock
fuente
5
¿No deberías rodear esto con #ifdef __GNU_C__?
einpoklum
1
en lugar de substr(0,colons).rfind(" ")uno podría utilizar rfind(' ', colons)para ahorrar una creación de una cadena extra.
mariusm
1
Prefiero usar find_last_of ("::") De lo contrario, la función solo devolverá un espacio de nombres si hay uno
underdoeg
Escribí una versión posiblemente más amplia de la __METHOD_NAME__macro. Mira aquí .
Antonio
En C ++ 11, podría intentar hacer de esto una constexprfunción para evaluarla en tiempo de compilación
Andre Holzner
11

Me gustaría sugerir boost :: typeindex , que aprendí de "Effective Modern C ++" de Scott Meyer. Aquí hay un ejemplo básico:

Ejemplo

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

Compilado con "g ++ --std = c ++ 14", esto produce lo siguiente

Salida

Si desea imprimir un tipo de plantilla, es fácil.

T = doble

Para obtenerlo de una instancia de objeto, simplemente use decltype:

el tipo de fb es: foo_bar

Spacemoose
fuente
¿Es posible obtener solo el nombre de la clase sin espacios de nombres con esto? también conocido
tower120
9

Aún no. (Creo que __class__se propone en alguna parte). También puede intentar extraer la parte de la clase __PRETTY_FUNCTION__.

Michael Krelin - hacker
fuente
7

Creo que usar __PRETTY_FUNCTION__es lo suficientemente bueno, aunque también incluye espacio de nombres, es decir, namespace::classname::functionnamehasta que __CLASS__esté disponible.

vaibhav
fuente
4

Si su compilador lo es g++y lo está solicitando __CLASS__porque desea una forma de obtener el nombre del método actual, incluida la clase, __PRETTY_FUNCTION__debería ayudar (de acuerdo con la info gccsección 5.43 Nombres de funciones como cadenas ).

ndim
fuente
3

Si necesita algo que realmente produzca el nombre de la clase en tiempo de compilación, puede usar C ++ 11 para hacer esto:

#define __CLASS__ std::remove_reference<decltype(classMacroImpl(this))>::type

template<class T> T& classMacroImpl(const T* t);

Reconozco que esto no es lo mismo que __FUNCTION__pero encontré esta publicación mientras buscaba una respuesta como esta. :RE

Jon Thompson
fuente
2

Puede obtener el nombre de la función, incluido el nombre de la clase. Esto puede procesar funciones de tipo C.

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) + "()";
}
Charles.Lee
fuente
1

Mi solución:

std::string getClassName(const char* fullFuncName)
{
    std::string fullFuncNameStr(fullFuncName);
    size_t pos = fullFuncNameStr.find_last_of("::");
    if (pos == std::string::npos)
    {
        return "";
    }
    return fullFuncNameStr.substr(0, pos-1);
}

#define __CLASS__ getClassName(__FUNCTION__)

Trabajo para Visual C ++ 12.

Andrey Epifantsev
fuente
1

Aquí hay una solución basada en las __FUNCTION__plantillas macro y 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();
}

Aquí hay un ejemplo de cómo se podría usar esto para una clase de registrador

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 salida de Example::Runserá entonces

Example: 0
Logger<Example>: 0
Sven Vranckx
fuente
Tenga en cuenta que esto no tendrá en cuenta el polimorfismo si tiene un puntero a base (que probablemente esté bien).
Lightness Races in Orbit
0

Esto funciona bastante bien si está dispuesto a pagar el costo de un puntero.

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__ ) {};
};
Robert Basler
fuente
0

También funciona con msvc y gcc

#ifdef _MSC_VER
#define __class_func__ __FUNCTION__
#endif

#ifdef __GNUG__
#include <cxxabi.h>
#include <execinfo.h>
char *class_func(const char *c, const char *f)
{
    int status;
    static char buff[100];
    char *demangled = abi::__cxa_demangle(c, NULL, NULL, &status);
    snprintf(buff, sizeof(buff), "%s::%s", demangled, f);
    free(demangled);
    return buff;
}
#define __class_func__ class_func(typeid(*this).name(), __func__)
#endif
Costa
fuente
0

Todas las soluciones publicadas anteriormente que se basan en __PRETTY_FUNCTION__sí tienen casos de borde específicos en los que no devuelven solo el nombre de clase / nombre de clase. Por ejemplo, considere el siguiente valor de función bonita:

static std::string PrettyFunctionHelper::Test::testMacro(std::string)

El uso de la última aparición de "::"como delimter no funcionará ya que el parámetro de la función también contiene un "::"( std::string). Puede encontrar casos extremos similares para "("como delimitador y más. La única solución que encontré toma las macros __FUNCTION__y __PRETTY_FUNCTION__como parámetros. Aquí está el código completo:

namespace PrettyFunctionHelper{
    static constexpr const auto UNKNOWN_CLASS_NAME="UnknownClassName";
    /**
     * @param prettyFunction as obtained by the macro __PRETTY_FUNCTION__
     * @return a string containing the class name at the end, optionally prefixed by the namespace(s).
     * Example return values: "MyNamespace1::MyNamespace2::MyClassName","MyNamespace1::MyClassName" "MyClassName"
     */
    static std::string namespaceAndClassName(const std::string& function,const std::string& prettyFunction){
        //AndroidLogger(ANDROID_LOG_DEBUG,"NoT")<<prettyFunction;
        // Here I assume that the 'function name' does not appear multiple times. The opposite is highly unlikely
        const size_t len1=prettyFunction.find(function);
        if(len1 == std::string::npos)return UNKNOWN_CLASS_NAME;
        // The substring of len-2 contains the function return type and the "namespaceAndClass" area
        const std::string returnTypeAndNamespaceAndClassName=prettyFunction.substr(0,len1-2);
        // find the last empty space in the substring. The values until the first empty space are the function return type
        // for example "void ","std::optional<std::string> ", "static std::string "
        // See how the 3rd example return type also contains a " ".
        // However, it is guaranteed that the area NamespaceAndClassName does not contain an empty space
        const size_t begin1 = returnTypeAndNamespaceAndClassName.rfind(" ");
        if(begin1 == std::string::npos)return UNKNOWN_CLASS_NAME;
        const std::string namespaceAndClassName=returnTypeAndNamespaceAndClassName.substr(begin1+1);
        return namespaceAndClassName;
    }
    /**
     * @param namespaceAndClassName value obtained by namespaceAndClassName()
     * @return the class name only (without namespace prefix if existing)
     */
    static std::string className(const std::string& namespaceAndClassName){
        const size_t end=namespaceAndClassName.rfind("::");
        if(end!=std::string::npos){
            return namespaceAndClassName.substr(end+2);
        }
        return namespaceAndClassName;
    }
    class Test{
    public:
        static std::string testMacro(std::string exampleParam=""){
            const auto namespaceAndClassName=PrettyFunctionHelper::namespaceAndClassName(__FUNCTION__,__PRETTY_FUNCTION__);
            //AndroidLogger(ANDROID_LOG_DEBUG,"NoT2")<<namespaceAndClassName;
            assert(namespaceAndClassName.compare("PrettyFunctionHelper::Test") == 0);
            const auto className=PrettyFunctionHelper::className(namespaceAndClassName);
            //AndroidLogger(ANDROID_LOG_DEBUG,"NoT2")<<className;
            assert(className.compare("Test") == 0);
            return "";
        }
    };
}
#ifndef __CLASS_NAME__
#define __CLASS_NAME__ PrettyFunctionHelper::namespaceAndClassName(__FUNCTION__,__PRETTY_FUNCTION__)
#endif
Constantin Geier
fuente
-2

El siguiente método (basado en methodName () anterior) también puede manejar entradas como "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) + "()";
}
Martín
fuente