String-Speicherverwaltung während der Zuweisung in der Karte gespeichert

Question

Ich habe eine Zeichenfolge, und ich möchte einen Verweis auf diese Zeichenfolge in eine Karte einfügen.

string m_tmp; 
map<pair<string, string>, string&> m; 
m[pair<string, string>("Foo","Bar")]= m_tmp; 

then, I change the m_tmp; 
m_tmp="DFDFD"; 

Wird die Karte (auf allen konformen Plattformen) verweist noch m_tmp mit einem neuen Wert?

Nach dem Dummy-Programm unten ändert sich die Adresse s nicht (Linux AS4, gcc 3.4). Ist das Speichermanagement in dieser Hinsicht über die Plattformen gleichwertig?

#include<string> 
#include<iostream> 

using namespace std; 

int main() 
{ 

    string s="Sasha"; 
    cout<<&s<<endl; 
    s="Bar"; 
    cout<<&s<<endl; 
    s="Foo"; 
    cout<<&s<<endl; 
} 

Answer 1

Warum nicht Sie tun dies statt:

map<pair<string, string>, shared_ptr<string> > m; 

mir Sieht aus sicherer.

Answer 2

Obwohl die Adresse s nicht ändert (Variablen, die nicht tun dürfen in C++), wird der Inhalt der Zeichenfolge (zB der Zeiger von s.c_str()) ändern, so vorsichtig sein, beim Spielen mit solchen Sachen.

map<pair<const char*, const char*>, string&> m; 

Id ein Konstrukt wie das sehr gefährlich halten, ich zum Beispiel an, dass Sie den Schlüssel suchen Vergleiche basierend auf der Saite, nicht die Lage der Saiten (dh die poitner Werte) erwarten.

Allerdings ignorieren Sie Ihre Wahl des Schlüssels, was Sie tun, mit dem m_tmp Wert ist sicher und gut definiert (das ändert man wird das andere ändern, weil dort die "gleiche" Variable), vorausgesetzt, dass die "Zeichenfolge m_tmp; " Wird der Gültigkeitsbereich nicht überschritten (oder anderweitig gelöscht), und Sie versuchen, über die Karte darauf zuzugreifen (da kein gültiger Speicher mehr referenziert wird).

ZB das Folgende ist nicht sicher.

std::map<int, string &> myMap; 
void foo() 
{ 
    string s = "Hello World"; 
    myMap[5] = s; 
} 
int main() 
{ 
    foo(); 
    //string s was destroyed when foo() returned, so myMap[5] is no longer a valid reference, 
    //so it is not defined what will happen here, hopefully an access violation 
    //rather than some obscure bug because the stack/heap got corrupted 
    std::cout << myMap[5] << std::end; 
} 

Es ist auch erwähnenswert, dass man es anders machen kann um wieder vorausgesetzt, dass das Element, das Sie von einer Referenz bekommen nicht gelöscht wird (aber das ist das einzig Mal, ein std :: map erlaubt ist ein ungültig Referenz oder Iterator).

std::map<int,string> myMap; 
myMap[5] = "x"; 
string &s = myMap[5];//get a referecnce 
myMap[5] = "Foo"; 
std::cout << s << std::end;//print Foo 
s = "Bar"; 
std::cout << myMap[5] << std::endl;//print Bar 

Answer 3

Wenn Sie nicht auf den Typ eingeschränkt sind, würde ich empfehlen, Ihre Zeichenfolge in einer anderen Klasse zu wickeln, anstatt eine Zeichenfolge & direkt zu tun, wird es ein kleines bisschen Overhead sein, aber geben Ihnen einen Platz, um den Grund dafür gründlich zu kommentieren die Veränderlichkeit, während auch der Code ein wenig offensichtlicher in Bezug auf die Bedeutung macht.

Heck machen es eine Klasse namens ReassignableString mit seinem einzigen Mitglied eine öffentliche Zeichenfolge, wenn Sie möchten.