Wo ist der "this" - Zeiger im Speicher des Rechners gespeichert?

Wo genau ist der "this" - Zeiger, die im Speicher abgespeichert? Ist reserviert auf dem stack in den heap oder im Daten-segment?

#include <iostream>
using namespace std;

class ClassA
{
    int a, b;

    public:
        void add()
        {
            a = 10;
            b = 20;
            cout << a << b << endl;
        }
};

int main()
{
    ClassA obj;
    obj.add();
    return 0;
}

Im obigen code bin ich dem Aufruf der member-Funktion add() - und das Empfänger-Objekt übergeben wird implizit als die "this" - Zeiger. Wo ist this im Speicher abgelegt?

InformationsquelleAutor nagaradderKantesh | 2013-05-16

c++this-pointer

64

Anderen Antworten haben einen sehr guten job gemacht zu erklären, wie eine typische compiler implementiert this (indem Sie es als einen impliziten ersten parameter der Funktion).

Ich denke, es ist auch nützlich, um zu sehen, was die C++ - ISO-spec explizit dazu schreibt. Entsprechend der C++ - 03 ISO spec, §9.3.2/1:

Im Körper einer nichtstatischen (9.3) die Funktion, die keyword - this ist eine non-lvalue-Ausdruck, dessen Wert der Adresse des Objekts, für das die Funktion aufgerufen wird.

Es ist wichtig zu beachten, dass this ist nicht eine variable - es ist ein Ausdruck, viel in der gleichen Weise, dass die expression 1 + 2 * 3 ist ein Ausdruck. Der Wert dieses Ausdrucks zulässig ist, gespeichert werden, so ziemlich überall. Der compiler könnte legte es auf den Stapel und übergeben Sie es als einen impliziten parameter an eine Funktion, oder es könnte steckte es in ein register, und möglicherweise könnte man es im heap oder im Daten-segment. Die C++ - Spezifikation absichtlich verleiht der Umsetzung eine gewisse Flexibilität hier.

Ich denke, dass die "Sprache-Anwalt" Antwort "das ist völlig Implementierung-definiert, und darüber hinaus this ist technisch kein Zeiger, sondern ein Ausdruck, dessen Wert einen Zeiger."

Hoffe, das hilft!

InformationsquelleAutor templatetypedef
78

Der einfachste Weg ist, zu denken this als eine versteckte zusätzliche argument, das immer automatisch übergeben.

So, eine fiktive Methode wie:
```
size_t String::length(void) const
{
  return strlen(m_string);
}
```
ist eigentlich mehr unter der Haube:
```
size_t String__length(const String *this)
{
  return strlen(this->m_string);
}
```
einen Aufruf wie:
```
{
  String example("hello");
  cout << example.length();
}
```
wird zu etwas, wie:
```
cout << String__length(&example);
```
Beachten Sie, dass die obige transformation wird vereinfacht, hoffentlich um meinen Standpunkt ein wenig klarer. Keine Notwendigkeit, füllen die Kommentare mit "whaaa, wo ist das marshalling für die Methode überladen, nicht wahr?"-Art Einwand, bitte. 🙂

Verwandelt sich die Frage in "wo sind die Argumente gespeichert werden?", und die Antwort ist natürlich "it depends". 🙂

Ist es oft auf dem Stapel, aber es werden könnten, in einem Register zu, oder jeder andere Mechanismus, den der compiler betrachtet ist gut für die Ziel-Architektur.
- Gute Erklärung, aber ich dachte, __thiscall würde am meisten die ecx zum speichern des this-Zeiger.
- AFAIK, dies ist eigentlich ist eine versteckte argument der Methode, bin ich falsch?
- Okay, danke, ich entfernt, der Satz da bin ich nicht sehr erfahren im debugging-x86 C++ - code auf dieser Ebene.
- da ist es für den Benutzer vollkommen transparent, ist dieses argument bedeutungslos. Es ist wahrscheinlich, implementiert auf diese Weise, aber was ändert das?
- OP will wissen, dass 🙂
- Interessanterweise ist die einzige Zeit, die ich gesehen habe, andere als die in ein register wird mit g++ auf Intel-32-bit.
- Nicht jedes system hat etwas namens ecx.
- Mit Visual Studio kompilieren für x86 -, __thiscall immer verwendet ecx übergeben werden, die this Zeiger auf eine member-Funktion (obwohl der compiler kann mische es etwa innerhalb der Funktion, wenn es entscheidet, dass die register für etwas anderes). Siehe hier.
InformationsquelleAutor unwind
34

this ist in der Regel bestanden, als eine versteckte argument der Methode (der einzige Unterschied in den verschiedenen Aufrufkonventionen ist wie).

Wenn Sie rufen:
```
myClass.Method(1, 2, 3);
```
Compiler generiert den folgenden code:
```
Method(&myClass, 1, 2, 3);
```
Wobei der erste parameter ist eigentlich der Zeiger auf this.

Let ' s überprüfen Sie den folgenden code:
```
class MyClass
{
private:
    int a;

public:
    void __stdcall Method(int i)
    {
        a = i;
    }
};

int main(int argc, char *argv[]) 
{
    MyClass myClass;
    myClass.Method(5);

    return 0;
}
```
Mithilfe __stdcall ich gezwungen, den compiler zu übergeben, alle Parameter über den stack. Wenn Sie dann starten Sie den debugger und prüfen Sie die assembly-code, finden Sie etwas wie die folgenden:
```
     myClass.Method(5);
00AA31BE  push        5  
00AA31C0  lea         eax,[myClass]  
00AA31C3  push        eax  
00AA31C4  call        MyClass::Method (0AA1447h)  
```
Wie Sie sehen, ist der parameter der Methode übergeben wird, durch den Stapel, dann die Adresse von myClass ist geladen und die register " eax " und wieder auf den stack geschoben. In anderen Worten, this wird behandelt wie eine reguläre parameter der Methode.
- Ich würde dennoch davor warnen, zu sagen, dass this ist immer übergeben als impliziten ersten parameter der Funktion. Dies ist, wie die meisten Implementierungen machen this Arbeit, aber es ist keine Voraussetzung, dass dies tatsächlich eintreten muss. Andere Implementierungen sind möglich.
- Technisch ist das wahr, aber ich habe nicht begegnet anderen Umsetzung als das implizite parameter doch in der überwiegenden Mehrzahl der Fälle können Sie davon ausgehen, in diesem Fall. Aber technisch korrekt, ich habe immer meistens, das sollte Locker genug.
InformationsquelleAutor Spook
18

this ist ein rvalue (Sie können nicht Ihre Adresse), so ist es nicht
(unbedingt) zu besetzen Speicher. Je nach compiler
und die Ziel-Architektur wird es oft in einem register: i0
auf einem Sparc -, ECX-mit MSVC auf Intel, etc. Wenn der Optimierer ist
aktiv, kann es sogar zu bewegen. (Ich habe es in verschiedenen
Register mit MSVC).

InformationsquelleAutor James Kanze
9

this verhält sich meist wie eine Funktion als argument, und als solche wird auf dem stack gespeichert werden oder - wenn die binären Aufrufkonventionen von der Architektur ermöglichen es, dass - in einem register.

InformationsquelleAutor MvG
0

this ist nicht gespeichert auf einer wohldefinierten Lage! Das Objekt, das er verweist ist irgendwo gespeichert, und hat eine gut definierte Adresse, sondern die Adresse selbst nicht über eine bestimmte Adresse. Es ist mitgeteilt, um in das Programm. Nicht nur, dass, aber es kann viele Kopien der Zeiger.

In der folgenden imaginären init Funktion, das Objekt registriert sich selbst zu erhalten, Ereignisse und timer-callbacks (mit imaginären Quelle-Objekte). Also, nach der Registrierung, gibt es zwei zusätzliche Kopien von this:
```
void foo_listener::init()
{
   g_usb_events.register(this); //register to receive USB events
   g_timer.register(this, 5);   //register for a 5 second timer
}
```
Ich eine Funktion die Aktivierung der Kette, es werden auch mehrere Kopien der this-Zeiger. Nehmen wir an, wir haben ein Objekt obj und rufen Sie seine foo Funktion. Diese Funktion ruft die gleiche Objekt bar Funktion, und bar ruft eine andere Funktion aufgerufen update. Jede Funktion Aktivierung Ebene hat die this Zeiger. Es ist gespeichert in einer Maschine register, oder eine Speicherstelle im stack-frame der Funktion Aktivierung.

InformationsquelleAutor Kaz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.