blocks|key|1764582|text|最接近的方法是调用typeid(your_class).name()+--但这会产生编译器特定的乱码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1764583|要在类中使用它，只需使用typeid(*this).name()|1764584|entityMap^0|9|P|0|C|K|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The closest thing there's is to call <code>typeid(your_class).name()</code> - but this produces compiler specific mangled name.

To use it inside class just <code>typeid(*this).name()</code>

blocks|key|465244|text|还没。(我认为__class__是在某个地方被提议的)。您还可以尝试从__PRETTY_FUNCTION__中提取类部分。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|465245|entityMap^0|7|9|Z|J|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Not yet. (I think <code>__class__</code> is proposed somewhere). You can also try to extract class part from <code>__PRETTY_FUNCTION__</code>.

blocks|key|465867|text|如果你谈论的是MS+C%2B%2B+(你应该声明，尤其是因为__FUNCTION__是一个非标准的扩展)，有一些__FUNCDNAME__+and+__FUNCSIG__+symbols你可以解析|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|465868|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/b0084kay(VS.80).aspx^0|Q|C|1G|D|1Y|B|1G|11|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you're talking MS C++ (You should state, esp as <code>__FUNCTION__</code> is a non-standard extension), there are <a href="http://msdn.microsoft.com/en-us/library/b0084kay(VS.80).aspx" rel="nofollow noreferrer"><code>__FUNCDNAME__</code> and <code>__FUNCSIG__</code> symbols</a> which you could parse

blocks|key|397766|text|如果您的编译器恰好是g%2B%2B，并且您请求__CLASS__，因为您想要一种获得当前方法名(包括类)的方法，__PRETTY_FUNCTION__应该提供帮助(根据info+gcc，第5.43节函数名为字符串)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|397767|entityMap^0|A|3|J|9|1G|J|28|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

If your compiler happens to be <code>g++</code> and you are asking for <code>__CLASS__</code> because you want a way to get the current method name including the class, <code>__PRETTY_FUNCTION__</code> should help (according to <code>info gcc</code>, section 5.43 Function Names as Strings).

blocks|key|465312|text|使用typeid(*this).name()的问题是在静态方法调用中没有this指针。宏__PRETTY_FUNCTION__在静态函数和方法调用中报告类名。但是，这只适用于gcc。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|465313|下面是一个通过宏样式接口提取信息的示例。|465314|inline+std::string+methodName(const+std::string&+prettyFunction)
{
++++size_t+colons+=+prettyFunction.find("::");
++++size_t+begin+=+prettyFunction.substr(0,colons).rfind("+")+%2B+1;
++++size_t+end+=+prettyFunction.rfind("(")+-+begin;

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

#define+__METHOD_NAME__+methodName(__PRETTY_FUNCTION__)|code-block|syntax|javascript|465315|宏__METHOD_NAME__将返回<class>::<method>()形式的字符串，从__PRETTY_FUNCTION__提供的内容中裁剪返回类型、修饰符和参数。|465316|对于仅提取类名的内容，必须注意捕获没有类的情况：|465317|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("+")+%2B+1;
++++size_t+end+=+colons+-+begin;

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

#define+__CLASS_NAME__+className(__PRETTY_FUNCTION__)|465318|entityMap^0|2|K|10|4|18|J|0|0|0|1|F|J|J|1A|J|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|T|$]]

The problem with using <code>typeid(*this).name()</code> is that there is no <code>this</code> pointer in a static method call. The macro <code>__PRETTY_FUNCTION__</code> reports a class name in static functions as well as method calls. However, this will only work with gcc.

Here's an example of extracting the information through a macro style interface. 

<pre><code>inline std::string methodName(const std::string&amp; 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__)
</code></pre>

The macro <code>__METHOD_NAME__</code> will return a string of the form <code>&lt;class&gt;::&lt;method&gt;()</code>, trimming the return type, modifiers and arguments from what <code>__PRETTY_FUNCTION__</code> gives you.

For something which extracts just the class name, some care must be taken to trap situations where there is no class:

<pre><code>inline std::string className(const std::string&amp; 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__)
</code></pre>

blocks|key|1805085|text|我认为使用__PRETTY_FUNCTION__已经足够好了，尽管它也包含了名称空间，比如namespace::classname::functionname，直到__CLASS__可用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1805086|entityMap^0|5|J|19|Y|2A|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

I think using <code>__PRETTY_FUNCTION__</code> is good enough though it includes namespace as well i.e. <code>namespace::classname::functionname</code> until <code>__CLASS__</code> is available.

blocks|key|1805129|text|您可以获取函数名，包括类名。这可以处理C类型的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1805130|static+std::string+methodName(const+std::string&+prettyFunction)
{
++++size_t+begin,end;
++++end+=+prettyFunction.find("(");
++++begin+=+prettyFunction.substr(0,end).rfind("+")+%2B+1;
++++end+-=+begin;
++++return+prettyFunction.substr(begin,end)+%2B+"()";
}|code-block|syntax|javascript|1805131|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can get the function name including class name.
This can process C-type funcitons.

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

blocks|key|1805165|text|我的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1805166|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__)|code-block|syntax|javascript|1805167|我在Visual+C%2B%2B+12工作。|1805168|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My solution:

<pre><code>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__)
</code></pre>

I works for Visual C++ 12.

blocks|key|1805190|text|这是一个基于__FUNCTION__宏和C%2B%2B模板的解决方案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1805191|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+%2B+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();
}|code-block|syntax|javascript|1805192|下面是一个示例，说明如何将其用于记录器类|1805193|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);
++}
}|1805194|然后，Example::Run的输出将是|1805195|Example:+0
Logger<Example>:+0|1805196|entityMap^0|6|C|0|0|0|0|3|C|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Here's a solution based on the <code>__FUNCTION__</code> macro and C++ templates:

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

template &lt;class T&gt;
std::string GetClassName(const T* _this = NULL)
{
 return ClassName&lt;T&gt;::Get();
}
</code></pre>

Here's an example of how this could be used for a logger class

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

class Example : protected Logger&lt;Example&gt;
{
public:
 void Run()
 {
 Log(0);
 }
}
</code></pre>

The output of <code>Example::Run</code> will then be

<pre><code>Example: 0
Logger&lt;Example&gt;: 0
</code></pre>

blocks|key|397963|text|如果你愿意支付指针的费用，这将会很好的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|397964|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__+)+{};
};|code-block|syntax|javascript|397965|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This works quite nicely if you are willing to pay the cost of a pointer.

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

blocks|key|1766659|text|我想推荐boost::typeindex，这是我从Scott+Meyer的“有效的现代C%2B%2B”中学到的。下面是一个基本的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1766660|示例|style|BOLD|1766661|#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";
}|code-block|syntax|javascript|1766662|使用"g%2B%2B+--std=c%2B%2B14“进行编译会产生以下结果|1766663|输出|1766664|1766665|如果你想打印一个模板类型，这很容易。|blockquote|1766666|1766667|T=双精度|1766668|要从对象实例中获取它，只需使用decltype：|1766669|fb类型为:+foo_bar|1766670|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_58_0/doc/html/boost_typeindex.html^0|4|G|0|0|0|2|0|0|0|0|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|6|7|1D|8|@$A|1E|B|1F|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1G|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1I|8|@$A|1J|B|1K|F|G]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]|$1|R|3|S|5|T|7|1M|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|1O|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|1P|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]]]

I would like to suggest <a href="http://www.boost.org/doc/libs/1_58_0/doc/html/boost_typeindex.html" rel="noreferrer">boost::typeindex</a>, which I learned about from Scott Meyer's &quot;Effective Modern C++&quot; Here's a basic example:
Example
<pre><code>#include &lt;boost/type_index.hpp&gt;

class foo_bar
{
 int whatever;
};

namespace bti = boost::typeindex;

template &lt;typename T&gt;
void from_type(T t)
{
 std::cout &lt;&lt; &quot;\tT = &quot; &lt;&lt; bti::type_id_with_cvr&lt;T&gt;().pretty_name() &lt;&lt; &quot;\n&quot;;
}

int main()
{
 std::cout &lt;&lt; &quot;If you want to print a template type, that's easy.\n&quot;;
 from_type(1.0);
 std::cout &lt;&lt; &quot;To get it from an object instance, just use decltype:\n&quot;;
 foo_bar fb;
 std::cout &lt;&lt; &quot;\tfb's type is : &quot;
 &lt;&lt; bti::type_id_with_cvr&lt;decltype(fb)&gt;().pretty_name() &lt;&lt; &quot;\n&quot;;
}
</code></pre>
Compiled with &quot;g++ --std=c++14&quot; this produces the following
Output
<blockquote>
If you want to print a template type, that's easy.
T = double
To get it from an object instance, just use decltype:
fb's type is : foo_bar
</blockquote>

blocks|key|1805274|text|也与msvc和gcc合作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1805275|#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),+"%25s::%25s",+demangled,+f);
++++free(demangled);
++++return+buff;
}
#define+__class_func__+class_func(typeid(*this).name(),+__func__)
#endif|code-block|syntax|javascript|1805276|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Works with msvc and gcc too

<pre><code>#ifdef _MSC_VER
#define __class_func__ __FUNCTION__
#endif

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

blocks|key|1764816|text|下面的方法(基于上面的methodName()+)也可以处理像"int+main(int，char**+argv)“这样的输入：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1764817|string+getMethodName(const+string&+prettyFunction)
{
++++size_t+end+=+prettyFunction.find("(")+-+1;
++++size_t+begin+=+prettyFunction.substr(0,+end).rfind("+")+%2B+1;

++++return+prettyFunction.substr(begin,+end+-+begin+%2B+1)+%2B+"()";
}|code-block|syntax|javascript|1764818|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Following method (based on methodName() above) can also handle input like "int main(int argc, char** argv)":

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

 return prettyFunction.substr(begin, end - begin + 1) + "()";
}
</code></pre>

blocks|key|1805380|text|如果需要在编译时实际生成类名，可以使用C%2B%2B11：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1805381|#define+__CLASS__+std::remove_reference<decltype(classMacroImpl(this))>::type

template<class+T>+T&+classMacroImpl(const+T*+t);|code-block|syntax|javascript|1805382|我认识到这与__FUNCTION__不是一回事，但我是在寻找这样的答案时发现这篇文章的。:D|offset|length|style|CODE|1805383|entityMap^0|0|0|6|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you need something that will actually produce the class name at compile time, you can use C++11 to do this:

<pre><code>#define __CLASS__ std::remove_reference&lt;decltype(classMacroImpl(this))&gt;::type

template&lt;class T&gt; T&amp; classMacroImpl(const T* t);
</code></pre>

I recognize that this is not the same thing as <code>__FUNCTION__</code> but I found this post while looking for an answer like this. :D

blocks|key|1805433|text|上面发布的所有依赖于__PRETTY_FUNCTION__的解决方案都有特定的边缘情况，其中它们不只返回类名/类名。例如，考虑以下漂亮的函数值：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1805434|static+std::string+PrettyFunctionHelper::Test::testMacro(std::string)|code-block|syntax|javascript|1805435|使用最后出现的函数作为分隔符将不起作用，因为"::"参数还包含一个"::"+(std::string)。您可以找到与分隔符等"("类似的边缘情况。我找到的唯一解决方案是同时使用__FUNCTION__和__PRETTY_FUNCTION__宏作为参数。下面是完整的代码：|1805436|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%2B1);
++++++++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%2B2);
++++++++}
++++++++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|1805437|entityMap^0|A|J|0|0|M|4|X|4|13|B|1Q|3|2G|C|2T|J|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|P|$]]

All the solutions posted above that rely on the <code>__PRETTY_FUNCTION__</code> do have specific edge case(s) where they do not return the class name / class name only. For example, consider the following pretty function value:
<pre><code>static std::string PrettyFunctionHelper::Test::testMacro(std::string)
</code></pre>
Using the last occurence of <code>&quot;::&quot;</code> as delimter won't work since the function parameter also contains a <code>&quot;::&quot;</code> (<code>std::string</code>).
You can find similar edge cases for <code>&quot;(&quot;</code> as delimiter and more.
The only solution I found takes both the <code>__FUNCTION__</code> and <code>__PRETTY_FUNCTION__</code> macros as parameters. Here is the full code:
<pre><code>namespace PrettyFunctionHelper{
 static constexpr const auto UNKNOWN_CLASS_NAME=&quot;UnknownClassName&quot;;
 /**
 * @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: &quot;MyNamespace1::MyNamespace2::MyClassName&quot;,&quot;MyNamespace1::MyClassName&quot; &quot;MyClassName&quot;
 */
 static std::string namespaceAndClassName(const std::string&amp; function,const std::string&amp; prettyFunction){
 //AndroidLogger(ANDROID_LOG_DEBUG,&quot;NoT&quot;)&lt;&lt;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 &quot;namespaceAndClass&quot; 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 &quot;void &quot;,&quot;std::optional&lt;std::string&gt; &quot;, &quot;static std::string &quot;
 // See how the 3rd example return type also contains a &quot; &quot;.
 // However, it is guaranteed that the area NamespaceAndClassName does not contain an empty space
 const size_t begin1 = returnTypeAndNamespaceAndClassName.rfind(&quot; &quot;);
 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&amp; namespaceAndClassName){
 const size_t end=namespaceAndClassName.rfind(&quot;::&quot;);
 if(end!=std::string::npos){
 return namespaceAndClassName.substr(end+2);
 }
 return namespaceAndClassName;
 }
 class Test{
 public:
 static std::string testMacro(std::string exampleParam=&quot;&quot;){
 const auto namespaceAndClassName=PrettyFunctionHelper::namespaceAndClassName(__FUNCTION__,__PRETTY_FUNCTION__);
 //AndroidLogger(ANDROID_LOG_DEBUG,&quot;NoT2&quot;)&lt;&lt;namespaceAndClassName;
 assert(namespaceAndClassName.compare(&quot;PrettyFunctionHelper::Test&quot;) == 0);
 const auto className=PrettyFunctionHelper::className(namespaceAndClassName);
 //AndroidLogger(ANDROID_LOG_DEBUG,&quot;NoT2&quot;)&lt;&lt;className;
 assert(className.compare(&quot;Test&quot;) == 0);
 return &quot;&quot;;
 }
 };
}
#ifndef __CLASS_NAME__
#define __CLASS_NAME__ PrettyFunctionHelper::namespaceAndClassName(__FUNCTION__,__PRETTY_FUNCTION__)
#endif
</code></pre>

blocks|key|1766777|text|我使用__PRETTY_FUNCTION__和constexpr以及C%2B%2B17+constexpr+std::string_view方法创建了一个函数。我还对算法进行了一些更新，使其更加可靠(感谢在中的帮助)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1766778|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)+%2B+1;
++++return+prettyFunction.substr(space,+bracket-space);
}
#define+__METHOD_NAME__+method_name(__PRETTY_FUNCTION__)|code-block|syntax|javascript|1766779|在C%2B%2B20中，可以将函数声明为consteval，强制它在编译时求值。此外，还有std::basic_fixed_string+for+use+as+template+parameter。|1766780|entityMap|0|LINK|mutability|MUTABLE|url|http://www.modernescpp.com/index.php/c-20-the-core-language#h1-2-string-literals-as-template-parameters^0|3|J|N|9|14|9|1E|G|0|0|G|9|15|N|15|1H|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|M|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I created a function using <code>__PRETTY_FUNCTION__</code> and <code>constexpr</code> with C++17 <code>constexpr</code> <code>std::string_view</code> methods. I also updated the algorithm a bit to be more reliably (Thanks to <a href="https://stackoverflow.com/users/775806/n-pronouns-m">@n. 'pronouns' m</a> for your help in <a href="https://stackoverflow.com/a/64393468/3779655">64387023</a>).
<pre class="lang-cpp prettyprint-override"><code>constexpr std::string_view method_name(const char* s)
{
 std::string_view prettyFunction(s);
 size_t bracket = prettyFunction.rfind(&quot;(&quot;);
 size_t space = prettyFunction.rfind(&quot; &quot;, bracket) + 1;
 return prettyFunction.substr(space, bracket-space);
}
#define __METHOD_NAME__ method_name(__PRETTY_FUNCTION__)
</code></pre>
In C++20, one can declare the function as <code>consteval</code> forcing it to evaluate at compile-time. Furthermore, there is <a href="http://www.modernescpp.com/index.php/c-20-the-core-language#h1-2-string-literals-as-template-parameters" rel="nofollow noreferrer"><code>std::basic_fixed_string</code> for use as template parameter</a>.

Is there a <code>__CLASS__</code> macro in C++ which gives the class name similar to <code>__FUNCTION__</code> macro which gives the function name

Is there a __CLASS__ macro in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

C++中是否有一个__CLASS__宏，它给出的类名类似于__FUNCTION__宏，它给出的函数名

问C++中有CLASS宏吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中有__CLASS__宏吗？EN