¿Existe una macro __CLASS__ en C ++?

¿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?

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()

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__)

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

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

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.

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 ).

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

Si está hablando de MS C ++ (debe indicar, especialmente porque __FUNCTION__es una extensión no estándar), hay símbolos __FUNCDNAME__y__FUNCSIG__ que podría analizar

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) + "()";
}

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.

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

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__ ) {};
};

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

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

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) + "()";
}