blocks|key|2033250|text|不是使用语言本身，但您可以编写类似这样的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033251|#include+<iostream>
#include+<string>

class+Foo
{
+public:
++++Foo(const+std::string&+name)+{+m_name+=+name;}
++++void+Print()+{+std::cout+<<+"Instance+name+=+"+<<+m_name+<<+std::endl;+}

++private:
++++std::string+m_name;
};

int+main()+
{
++++Foo+a("a");
++++Foo+b("b");

++++a.Print();
++++b.Print();

++++return+0;
}|code-block|syntax|javascript|2033252|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|$]]

Not with the language itself, but you could code something like:

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

class Foo
{
 public:
 Foo(const std::string&amp; name) { m_name = name;}
 void Print() { std::cout &lt;&lt; "Instance name = " &lt;&lt; m_name &lt;&lt; std::endl; }

 private:
 std::string m_name;
};

int main() 
{
 Foo a("a");
 Foo b("b");

 a.Print();
 b.Print();

 return 0;
}
</code></pre>

blocks|key|2033198|text|不是的。变量名是给程序员的，编译器看到的是地址。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033199|其他提供关于其程序的元数据/反射的语言可能会提供此功能，C%2B%2B不是这些语言之一。|2033200|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

No. Variable names are for the programmer, the compiler sees addresses.

Other languages that provide meta-data/reflection about their program might provide this functionality, C++ isn't one of those languages.

blocks|key|2033202|text|编译后的代码中不存在变量名。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033203|但是，您可以使用一些#define在预处理过程中获取名称，并在编译之前填充名称。|offset|length|style|CODE|2033204|如下所示：|2033205|#define+SHOW(a)+std::cout+<<+#a+<<+":+"+<<+(a)+<<+std::endl
//+...
int+i+=+2;
SHOW+(i);|code-block|syntax|javascript|2033206|entityMap^0|0|A|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Variable names do not exist in the compiled code.

However you can use some <code>#define</code> to get the name in preprocessing and let the names be populated before the compile.

Something like this:

<pre><code>#define SHOW(a) std::cout &lt;&lt; #a &lt;&lt; ": " &lt;&lt; (a) &lt;&lt; std::endl
// ...
int i = 2;
SHOW (i);
</code></pre>

blocks|key|1819616|text|这意味着什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1819617|void+f(T+const&+p)+{
++++cout+<<+p.name();
}

T+r()+{
++++T+c;
++++return+c;
}

void+g()+{
++++T+a;
++++cout+<<+a.name();
++++T+&+b+=+a;
++++cout+<<+b.name();
++++T+*+ptr+=+&b;+
++++cout+<<+ptr->name();

++++T+d+=+r();
++++cout+<<+d.name();
}|code-block|syntax|javascript|1819618|你想要什么？每次都是"a“？那么c/d呢？|1819619|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|$]]

What would that mean?

<pre><code>void f(T const&amp; p) {
 cout &lt;&lt; p.name();
}

T r() {
 T c;
 return c;
}

void g() {
 T a;
 cout &lt;&lt; a.name();
 T &amp; b = a;
 cout &lt;&lt; b.name();
 T * ptr = &amp;b; 
 cout &lt;&lt; ptr-&gt;name();

 T d = r();
 cout &lt;&lt; d.name();
}
</code></pre>

What would you expect? "a" each time? And what about c/d?

blocks|key|1819549|text|变量名在编译后不会存活。最好的做法是将变量名传递到对象构造函数中，并使用宏将其存储在对象中。后者将导致非常丑陋的代码，所以您只会希望这是最后的手段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1819550|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Variable names don't survive compilation. The best you can do is to pass the variable name into the object constructor and store it inside the object by using a macro. The latter will lead to really ugly code so you would only want this as a last resort.

blocks|key|2033391|text|这是我创建过的最大和最恶心的黑客之一，但在我看来，出于调试的原因，它已经足够好了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033392|#include+<iostream>

#include+<typeinfo>
#define+DEBUG_INSTANCE(+classtype,+name+)+class+_+##+classtype+##+_INSTANCE_+##+name+##+_++:+public+classtype+\
++++{+\
++++++++public:+\
++++++++++++_+##+classtype+##+_INSTANCE_+##+name+##+_+(){+}+\
++++};+\
_+##+classtype+##+_INSTANCE_+##+name+##+_+name

class+Foo+{
public:
++++virtual+void+_MakeTypeIDRunTime()+{+}
++++//+A+virtual+method+in+the+class+forces+typeid(*this)+to+be+used+runtime+rather+than+compiled
++++//+See:+https://stackoverflow.com/a/6747130/1924602

++++void+Print();
};

void+Foo::Print()+{
++++std::cout+<<+"Instance+name+=+"+<<+typeid(*this).name()+<<+std::endl;
}

int+main()
{
++++DEBUG_INSTANCE(Foo,+a);
++++DEBUG_INSTANCE(Foo,+b);

++++a.Print();
++++b.Print();

++++system("PAUSE");
++++return+0;
}|code-block|syntax|javascript|2033393|输出：|2033394|Instance+name+=+?AV_Foo_INSTANCE_a_@?1?main@
Instance+name+=+?AV_Foo_INSTANCE_b_@?1?main@
Press+any+key+to+continue+.+.+.|2033395|这个宏将创建一个继承Foo的类，并且name包含实例名称。唯一的限制是Foo有一个默认的构造函数，并且必须包含一个虚方法，以便typeid接受继承的类并在运行时被调用。有关更好的解释，请参阅https://stackoverflow.com/a/6747130/1924602|offset|length|2033396|如果使用__VA_ARGS__宏，则可能支持构造函数|style|CODE|2033397|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/6747130/1924602^0|0|0|0|0|2N|17|0|0|4|B|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@$M|19|N|1A|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

For the bounty:
This is one of the biggest and most disgusting hacks I've ever created but its good enough for debug reasons in my opinion

<pre><code>#include &lt;iostream&gt;

#include &lt;typeinfo&gt;
#define DEBUG_INSTANCE( classtype, name ) class _ ## classtype ## _INSTANCE_ ## name ## _ : public classtype \
 { \
 public: \
 _ ## classtype ## _INSTANCE_ ## name ## _ (){ } \
 }; \
_ ## classtype ## _INSTANCE_ ## name ## _ name

class Foo {
public:
 virtual void _MakeTypeIDRunTime() { }
 // A virtual method in the class forces typeid(*this) to be used runtime rather than compiled
 // See: https://stackoverflow.com/a/6747130/1924602

 void Print();
};

void Foo::Print() {
 std::cout &lt;&lt; "Instance name = " &lt;&lt; typeid(*this).name() &lt;&lt; std::endl;
}

int main()
{
 DEBUG_INSTANCE(Foo, a);
 DEBUG_INSTANCE(Foo, b);

 a.Print();
 b.Print();

 system("PAUSE");
 return 0;
}
</code></pre>

Output:

<pre><code>Instance name = ?AV_Foo_INSTANCE_a_@?1?main@
Instance name = ?AV_Foo_INSTANCE_b_@?1?main@
Press any key to continue . . .
</code></pre>

This macro will create a class that inherits Foo and name contains the instance name. Only limitation is that Foo has a default constructor and must contain a virtual method in order for typeid to accept inherited classes and be called used at runtime. See <a href="https://stackoverflow.com/a/6747130/1924602">https://stackoverflow.com/a/6747130/1924602</a> for a better explanation

Might be possible to support constructors if you use the <code>__VA_ARGS__</code> macro

blocks|key|2033430|text|一个实例当然可以从类方法中知道它的名称：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033431|#include+<iostream>

class+Foo+{
++public:
++++void+Print()+{+std::cout+<<+"Instance+name+=+"+<<+this+<<+std::endl;+}
};

int+main()+{
++++Foo+a,+b;
++++a.Print();
++++b.Print();
++++return+0;
}|code-block|syntax|javascript|2033432|将产生类似以下内容的输出：|2033433|Instance+name+=+0x7fff502b8b48
Instance+name+=+0x7fff502b8b40|2033434|至于知道变量名，这肯定是不可能的。对象的存在并不意味着变量的存在-此实例：|2033435|new+Foo();|2033436|将在流程的剩余持续时间内存在，但永远不会与任何变量相关联。变量的语言概念不反映在所述变量的内容中，并且语言变量和对象之间的任何潜在关系仅在生成的代码中表达，而不在生成的数据或元数据中表达。当然，禁止访问调试信息，如已经指出的，调试信息不是语言的一部分。|2033437|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It is certainly possible for an instance to know its name from within the class method:

<pre><code>#include &lt;iostream&gt;

class Foo {
 public:
 void Print() { std::cout &lt;&lt; "Instance name = " &lt;&lt; this &lt;&lt; std::endl; }
};

int main() {
 Foo a, b;
 a.Print();
 b.Print();
 return 0;
}
</code></pre>

will produce the output similar to this:

<pre><code>Instance name = 0x7fff502b8b48
Instance name = 0x7fff502b8b40
</code></pre>

As for knowing the variable name, it is certainly not possible. The existence of the object does not imply the existence of the variable - this instance:

<pre><code>new Foo();
</code></pre>

will exist for the remaining duration of the process, yet will never be associated with any variable. The language concept of variables is not reflected in the contents of said variables, and any potential relation between language variable and an object is expressed only in the generated code and not in generated data or meta-data. Barring of course the access to the debug information which, as already pointed out, is not part of the language.

blocks|key|2033407|text|这对于语言本身是不可能的。但是，您可以使用预处理器来获取它。但这并不清楚，如果您的类具有不同的构造函数，则必须小心。此外，你还必须在每节课上做这件事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033408|我将Steven+Keith的例子与#define预处理器结合使用：|offset|length|style|CODE|2033409|#include+<iostream>
#include+<string>

using+namespace+std;

class+Foo
{
+public:
++++Foo(const+string&+name)+:+m_name(name)+{}
++++void+Print()+{+cout+<<+"Instance+name+=+"+<<+m_name+<<+endl;+}

+private:
++++string+m_name;
};

#define+DRESSED_Foo(var)+Foo+var(#var)

int+main()+
{
++++DRESSED_Foo(a);
++++DRESSED_Foo(b);

++++a.Print();
++++b.Print();

++++return+0;
}|code-block|syntax|javascript|2033410|entityMap^0|0|I|7|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It is not possible with the language itself. However, you can use preprocessor to get it. But it is not going to be clear and you will have to be careful if your classes have different constructors. Also you will have to do it in each class.

I reuse the example of Steven Keith in combination with <code>#define</code> preprocessor:

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

using namespace std;

class Foo
{
 public:
 Foo(const string&amp; name) : m_name(name) {}
 void Print() { cout &lt;&lt; "Instance name = " &lt;&lt; m_name &lt;&lt; endl; }

 private:
 string m_name;
};

#define DRESSED_Foo(var) Foo var(#var)

int main() 
{
 DRESSED_Foo(a);
 DRESSED_Foo(b);

 a.Print();
 b.Print();

 return 0;
}
</code></pre>

blocks|key|1819896|text|This+is+not+possible+"Directly",+consider+this+simple+program;

+//+stove.cpp+

#include+<string.h>
#include+<stdio.h>
#include+<iostream>

using+namespace+std;

class+Foo+{
+++char*+t;
+++size_t+length;

+++++public:
+++++Foo()
+++++{
+++++++t+=+new+char(8);
+++++++t+=+static_cast<char*>(static_cast<void*>(this));

+++++}
++++++void+Print();
};

++++void+Foo::Print()+{
+++++++++//+what+should+be+?????????+below+?
++++++++++cout+<<+this+<<+"+"+<<+strlen+(t)+<<+t+<<+endl;
++++}

++++int+main()+{
++++++++Foo+a;
++++++++a.Print();
++++++++Foo+b;
++++++++b.Print();
++++++++return+0;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1819897|unstyled|1819898|++++you+can+check+the+value+of+t+in+gdb+for+both+a+and+b+objects,
1)+run+binary+in+gdb+and+put+breakpoints+on+lines+where+both+objects+a+and+b+gets+created.
2)+for+both+objects+a+and+b+,+after+creation+(or+in+print+function,+check
print+this
print+t
++++18+++++++++++}
++++(gdb)+print+this
++++$1+=+(Foo+*+const)+0x7fffffffe6e0
++++(gdb)+print+t
++++$2+=+0x7fffffffe6e0+"\340\346\377\377\377\177"
++++...
++++...
++++...
++++30++++++++++Foo+b;
++++(gdb)+s
++++Foo::Foo+(this=0x7fffffffe6d0)+at+stov.cpp:15
++++15+++++++++++++t+=+new+char(8);
++++(gdb)+n
++++16+++++++++++++t+=+static_cast<char*>(static_cast<void*>(this));
++++(gdb)+n
++++18+++++++++++}
++++(gdb)+print+this
++++$3+=+(Foo+*+const)+0x7fffffffe6d0
++++(gdb)+print+t
++++$4+=+0x7fffffffe6d0+"\320\346\377\377\377\177"|1819899|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|K|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|L|8|@]|9|@]|A|$B|C]]|$1|H|3|-4|5|E|7|M|8|@]|9|@]|A|$]]]|I|$]]

<pre><code>This is not possible "Directly", consider this simple program;

 // stove.cpp 

#include &lt;string.h&gt;
#include &lt;stdio.h&gt;
#include &lt;iostream&gt;

using namespace std;

class Foo {
 char* t;
 size_t length;

 public:
 Foo()
 {
 t = new char(8);
 t = static_cast&lt;char*&gt;(static_cast&lt;void*&gt;(this));

 }
 void Print();
};

 void Foo::Print() {
 // what should be ????????? below ?
 cout &lt;&lt; this &lt;&lt; " " &lt;&lt; strlen (t) &lt;&lt; t &lt;&lt; endl;
 }

 int main() {
 Foo a;
 a.Print();
 Foo b;
 b.Print();
 return 0;
 }
</code></pre>

<hr>

<pre><code> you can check the value of t in gdb for both a and b objects,
1) run binary in gdb and put breakpoints on lines where both objects a and b gets created.
2) for both objects a and b , after creation (or in print function, check
print this
print t
 18 }
 (gdb) print this
 $1 = (Foo * const) 0x7fffffffe6e0
 (gdb) print t
 $2 = 0x7fffffffe6e0 "\340\346\377\377\377\177"
 ...
 ...
 ...
 30 Foo b;
 (gdb) s
 Foo::Foo (this=0x7fffffffe6d0) at stov.cpp:15
 15 t = new char(8);
 (gdb) n
 16 t = static_cast&lt;char*&gt;(static_cast&lt;void*&gt;(this));
 (gdb) n
 18 }
 (gdb) print this
 $3 = (Foo * const) 0x7fffffffe6d0
 (gdb) print t
 $4 = 0x7fffffffe6d0 "\320\346\377\377\377\177"
</code></pre>

blocks|key|1819581|text|这是不可能的。与.NET平台不同，C%2B%2B没有“反射”的概念。但是MFC库有CRunTime类-例如，你可以看到。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1819582|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It is not possible. C++ does not have a concept of "reflection" like .NET platform.
But MFC library has CRunTime class - you can see for example.

blocks|key|2033263|text|就C%2B%2B而言，调试符号并不存在。因此，没有任何C%2B%2B机制允许您对它们执行任何操作。有没有可能创建特定于平台的解决方案？有可能。人们必须分析内存中的进程图像，根据特定的格式对其进行解析，找出调试符号(和帧)并将它们映射到地址。从本质上讲，就是自我调试。这么麻烦值得吗？在我看来不是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033264|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Debug symbols do not exist as far as C++ is concerned. As a result, no C++ mechanism allows you to do anything with them.
Would it be possible to create platform-specific solution which would work? Possible. One would have to analyze the image of the process in memory, parse it according to specific format, figure out debug symbols (and frames) and map them to addresses. Essentially, debug itself. 
Does it worth the trouble? Not in my opinion.

blocks|key|1819915|text|您可以使用#define来完成此操作。定义一个宏，它将变量名保存在类中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1819916|#include+<iostream>
#include+<string>

using+namespace+std;

#define+CREATE_FOO(f)+Foo+f+=+Foo(#f);

class+Foo+{
+++++public:
++++++++++void+Print()+const;
++++++++++Foo(string+s):+name(s)+{};
+++++protected:
++++++++++string+name;

};

void+Foo::Print()+const++{
+++++cout+<<+"Instance+name+=+"+<<+name;
}


int+main()+{
++++CREATE_FOO(a);
++++CREATE_FOO(b);
++++a.Print();
++++b.Print();
++++return+0;
}|code-block|syntax|javascript|1819917|entityMap^0|5|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can do it using <code>#define</code>. Define a macro which would save variable name inside class:

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

using namespace std;

#define CREATE_FOO(f) Foo f = Foo(#f);

class Foo {
 public:
 void Print() const;
 Foo(string s): name(s) {};
 protected:
 string name;

};

void Foo::Print() const {
 cout &lt;&lt; "Instance name = " &lt;&lt; name;
}


int main() {
 CREATE_FOO(a);
 CREATE_FOO(b);
 a.Print();
 b.Print();
 return 0;
}
</code></pre>

Is it possible to know the object instance name / variable name from within a class method? For example:

<pre><code>#include &lt;iostream&gt;

using namespace std;

class Foo {
 public:
 void Print();
};

void Foo::Print() {
 // what should be ????????? below ?
 // cout &lt;&lt; "Instance name = " &lt;&lt; ?????????;
}

int main() {
 Foo a, b;
 a.Print();
 b.Print();
 return 0;
}
</code></pre>

Can a C++ Class Constructor Know Its Instance Name?

编译器

可以从类方法中知道对象实例名/变量名吗？例如：#include <iostream>using namespace std;class Foo { public: void Print();};void Foo::Print() { // what should be ????????? below ? // cout << "Instance name

问C++类构造函数能知道它的实例名吗？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++类构造函数能知道它的实例名吗？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++类构造函数能知道它的实例名吗？
EN