Может ли конструктор класса C++ знать имя своего экземпляра?

Не с самим языком, но вы можете написать что-то вроде:

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

Нет. Имена переменных для программиста, компилятор видит адреса.

Другие языки, которые предоставляют метаданные/отражение своей программы, могут предоставлять эту функциональность, C++ не является одним из этих языков.

Имена переменных не существуют в скомпилированном коде.

Однако вы можете использовать некоторые #define, чтобы получить имя в предварительной обработке и позволить именам быть заполненными до компиляции.

Что-то вроде этого:

#define SHOW(a) std::cout << #a << ": " << (a) << std::endl
// ...
int i = 2;
SHOW (i);

Что бы это значило?

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

Что вы ожидаете? "а" каждый раз? А как же к/д?

Имена переменных не сохраняются при компиляции. Лучшее, что вы можете сделать, это передать имя переменной в конструктор объекта и сохранить его внутри объекта с помощью макроса. Последнее приведет к действительно уродливому коду, поэтому вам нужно это только в крайнем случае.

За награду: это один из самых больших и отвратительных хаков, которые я когда-либо создавал, но, на мой взгляд, он достаточно хорош для отладки.

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

Вывод:

Instance name = ?AV_Foo_INSTANCE_a_@?1?main@
Instance name = ?AV_Foo_INSTANCE_b_@?1?main@
Press any key to continue . . .

Этот макрос создаст класс, который наследует Foo, а имя содержит имя экземпляра. Единственным ограничением является то, что Foo имеет конструктор по умолчанию и должен содержать виртуальный метод, чтобы typeid мог принимать унаследованные классы и вызываться во время выполнения. См. https://stackoverflow.com/a/6747130/1924602 для лучшего объяснения.

Может быть возможно поддерживать конструкторы, если вы используете макрос __VA_ARGS__

Конечно, экземпляр может узнать свое имя из метода класса:

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

будет производить вывод, подобный этому:

Instance name = 0x7fff502b8b48
Instance name = 0x7fff502b8b40

Что касается знания имени переменной, то это, конечно, невозможно. Существование объекта не означает существование переменной - этот экземпляр:

new Foo();

будет существовать до конца процесса, но никогда не будет связан ни с одной переменной. Языковая концепция переменных не отражается в содержимом указанных переменных, и любая потенциальная связь между языковой переменной и объектом выражается только в сгенерированном коде, а не в сгенерированных данных или метаданных. За исключением, конечно, доступа к отладочной информации, которая, как уже отмечалось, не является частью языка.

С самим языком это невозможно. Однако вы можете использовать препроцессор, чтобы получить его. Но это не будет ясно, и вам придется быть осторожным, если ваши классы имеют разные конструкторы. Также вам придется делать это в каждом классе.

Я повторно использую пример Стивена Кейта в сочетании с препроцессором #define:

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

Ключевое слово это

Я новичок в программировании, но изучив структуру классов, я полагаю, что вы, возможно, ищете ключевое слово this. Как и в приведенном ниже примере (взятом с cplusplus.com), вы можете видеть, что this используется везде, где класс должен ссылаться на себя.

Следовательно, это может сделать и конструктор.

// example on this
#include <iostream>
using namespace std;

class Dummy {
  public:
    bool isitme (Dummy& param);
};

bool Dummy::isitme (Dummy& param)
{
  if (&param == this) return true;
  else return false;
}

int main () {
  Dummy a;
  Dummy* b = &a;
  if ( b->isitme(a) )
    cout << "yes, &a is b\n";
  return 0;
}

http://www.cplusplus.com/doc/tutorial/templates/

Это невозможно. C++ не имеет понятия "отражение", как платформа .NET. Но в библиотеке MFC есть класс CRunTime - можете посмотреть, например.

Символы отладки не существуют в C++. В результате никакой механизм C++ не позволяет вам что-либо с ними делать. Можно ли создать решение для конкретной платформы, которое будет работать? Возможный. Придется проанализировать образ процесса в памяти, разобрать его по определенному формату, вычислить отладочные символы (и фреймы) и сопоставить их с адресами. По сути, отлаживать себя. Стоит ли заморачиваться? Не по моему мнению.

Вы можете сделать это с помощью #define. Определите макрос, который будет сохранять имя переменной внутри класса:

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