__CLASS__C ++ 'da, sınıf adını __FUNCTION__makroya benzer ve işlev adını veren bir makro var mı?
Yanıtlar:
En yakın şey typeid(your_class).name()aramaktır - ancak bu, derleyiciye özgü karıştırılmış ad üretir.
Sadece sınıf içinde kullanmak için typeid(*this).name()
__func__ve standart __FUNCTION__olmayan makrolar değil. Microsoft __FUNCTION__, bir makro olarak belgeler , ancak gerçekte olmadığı, derleme yaparken önişlemci tarafından genişletilmemesidir /P.
Kullanmanın sorunu, statik bir yöntem çağrısında işaretçi typeid(*this).name()olmamasıdır this. Makro __PRETTY_FUNCTION__, statik işlevlerde ve yöntem çağrılarında bir sınıf adı bildirir. Ancak bu yalnızca gcc ile çalışacaktır.
Makro tarzı bir arayüz aracılığıyla bilgilerin çıkarılmasına bir örnek.
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__)
Makro , size verenin dönüş türünü, değiştiricileri ve argümanları keserek __METHOD_NAME__formun bir dizesini <class>::<method>()döndürür __PRETTY_FUNCTION__.
Sadece sınıf adını çıkaran bir şey için, sınıfın olmadığı durumları tuzağa düşürmek için biraz özen gösterilmelidir:
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__)
#ifdef __GNU_C__?
substr(0,colons).rfind(" ")kullanılabilir rfind(' ', colons).
constexprderleme zamanında değerlendirmek için bir işlev haline getirmeyi deneyebilirsiniz
Scott Meyer'in "Etkili Modern C ++" adlı kitabından öğrendiğim boost :: typeindex'i önermek istiyorum İşte temel bir örnek:
Misal
#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";
}
"G ++ --std = c ++ 14" ile derlendiğinde bu, aşağıdakileri üretir
Çıktı
Bir şablon türü yazdırmak istiyorsanız, bu kolaydır.
T = çift
Bir nesne örneğinden almak için decltype kullanmanız yeterlidir:
fb türü: foo_bar
Henüz değil. (Sanırım __class__bir yerde önerildi). Ayrıca, içinden sınıf bölümünü çıkarmayı deneyebilirsiniz __PRETTY_FUNCTION__.
Derleme zamanında sınıf adını gerçekten üretecek bir şeye ihtiyacınız varsa, bunu yapmak için C ++ 11'i kullanabilirsiniz:
#define __CLASS__ std::remove_reference<decltype(classMacroImpl(this))>::type
template<class T> T& classMacroImpl(const T* t);
Bunun aynı şey olmadığını __FUNCTION__biliyorum ama böyle bir cevap ararken bu yazıyı buldum. : D
MS C konuşuyorsak ++ (Sen esp, belirtmelidir __FUNCTION__vardır standart dışı bir uzantısıdır) __FUNCDNAME__ve __FUNCSIG__semboller ayrıştırmak olabilir
Sınıf adını içeren işlev adını alabilirsiniz. Bu, C tipi işlevleri işleyebilir.
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) + "()";
}
Çözümüm:
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__)
Visual C ++ 12 için çalışıyorum.
İşte __FUNCTION__makro ve C ++ şablonlarına dayalı bir çözüm :
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();
}
İşte bunun bir günlükçü sınıfı için nasıl kullanılabileceğine dair bir örnek
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);
}
}
Çıktısı Example::Runo zaman olacaktır
Example: 0
Logger<Example>: 0
Bir işaretçinin maliyetini ödemeye istekliysen, bu oldukça iyi çalışıyor.
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__ ) {};
};
Msvc ve gcc ile de çalışır
#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
Yukarıda yayınlanan tüm çözümlerin __PRETTY_FUNCTION__, yalnızca sınıf adını / sınıf adını döndürmedikleri belirli uç durum (lar) ı vardır. Örneğin, aşağıdaki güzel işlev değerini düşünün:
static std::string PrettyFunctionHelper::Test::testMacro(std::string)
"::"İşlev parametresi aynı zamanda a "::"( std::string) içerdiğinden, ayırıcı olarak son oluşumunu kullanmak işe yaramaz . "("Sınırlayıcı ve daha fazlası için benzer uç durumları bulabilirsiniz . Bulduğum tek çözüm hem alır __FUNCTION__ve __PRETTY_FUNCTION__parametre olarak makro. İşte tam kod:
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
C ++ 17 yöntemlerini kullanarak __PRETTY_FUNCTION__ve constexprile bir işlev oluşturdum constexpr std::string_view. Ben de biraz daha güvenilir olması için algoritma güncellenmiş (sayesinde @n. 'Zamirler' m için yardımınızı 64387023 ).
constexpr std::string_view method_name(const char* s)
{
std::string_view prettyFunction(s);
size_t bracket = prettyFunction.rfind("(");
size_t space = prettyFunction.rfind(" ", bracket) + 1;
return prettyFunction.substr(space, bracket-space);
}
#define __METHOD_NAME__ method_name(__PRETTY_FUNCTION__)
C ++ 20'de, işlevin constevalderleme zamanında değerlendirmeye zorlandığı bildirilebilir. Ayrıca, std::basic_fixed_stringşablon parametresi olarak kullanım için vardır .
Aşağıdaki yöntem (yukarıdaki methodName () temel alınarak), "int main (int argc, char ** argv)" gibi girdileri de işleyebilir:
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) + "()";
}