Wo ist das Objekt abgelegt?

Hallo Forum,

wo ist der Funktionsparameter abgelegt:

void MyFunc(std::string &s) {}

int main() {
	std::string s1;
	MyFunc(s1); // Hier liegt der string auf dem Stack. Es wird zu keinem Zeitpunkt eine Kopie gemacht. Korrekt?

	std::string *s2 = new std::string("abc");
	MyFunc(s2); // Hier liegt der string auf dem Heap. Es wird auch keine Kopie gemacht?
}

Also ist die Referenz ein Pointer. Der einmal auf den Stack steigt und einmal auf dem Heap?

darthdespotism

void MyFunc(std::string &s) {} 

int main() { 
    std::string s1; 
    MyFunc(s1);

    std::string *s2 = new std::string("abc"); 
    MyFunc(*s2); // Wo eine Referenz erwartet wird, darfst du keinen Pointer übergeben
}

Sonst dürftest du recht ahben

akari

Hallo

Naja damit das zweite auch kompilierbar wird must du aber erstmal noch dereferenzieren.

MyFunc(*s2);

Und ja dann liegt s im Heap. Interessiert in der Funktion auch niemanden.

/Edit : zu langsam

bis bald
akari

Oh, das dereferenzieren hatte ich vergessen. Vielen Dank Darthdespotism und Akari

Simon2

Student_x schrieb:

Oh, das dereferenzieren hatte ich vergessen. ...

Wenn Du schon von "vergessen" sprichst: Bei der zweiten Lösung darfst Du das "delete" nicht vergessen.

Ergänzung1: "Pointer" bedeutet nicht automatisch, dass das Objekt auf dem Stack liegt:

int main() {
    std::string s1; // HIER liegt der string auf dem Stack
    MyFunc(s1); 
    std::string *s2 = &s1; // Der string liegt immer noch auf dem Stack
    MyFunc(*s2); 
}

Ergänzung2: Zwar liegt das string-Objekt selbst auf dem Stack/Heap, aber es selbst kann seine internen Daten durchaus woanders hinlegen:

struct MyObj {
   int* i; // Pointer i kann auf dem Stack liegen ...
   MyObj() : i(new int[10]) {} // ... und zeigt auf 10 ints, die auf dem Heap liegen
   ~MyObj() { delete[] i; }
};

Ich würde davon ausgehen (obwohl das implementationsspezifisch ist und anders gelöst werden kann), dass das bei string (zumindestens bei längeren) auch so ist.

Gruß,

Simon2.

@Simon2: Das mit dem delete war mir auch klar.
Es ging mir nur darum wo die Objekte liegen und ob nicht vielleicht eine Kopie gemacht wird. Eigentlich werden ja die einer Funktion übergebenen Parameter auf den Stack geleget. Wenn ich also std::string& als Parameter übergebe dachte ich das das Objekt vielleicht vom Heap auf den Stack verschoben wird. Hier wird scheibar sowas wie ein Pointer auf dem Stack übergeben, ohne das ich beim Ansprechen des Strings die Dereferenzierung vornehmen muß.

CStoll

student_x schrieb:

Hier wird scheibar sowas wie ein Pointer auf dem Stack übergeben, ohne das ich beim Ansprechen des Strings die Dereferenzierung vornehmen muß.

Ja, so sieht's aus - es wird eine Referenz auf den Stack gepackt. Und die kannst du (stark vereinfacht) auch als einen selbst-dereferenzierenden Zeiger ansehen.

(technisch gesehen ist eine Referenz ein Alias-Name für ein irgendwo anders existierendes Objekt - wo das ist, spielt für den Compiler keine Rolle)