Ich mache folgendes, um eine neue Instanz einer Klasse über einen String aufzurufen:

std::map<std::string,MyClass*> m_pCreate;
m_pCreate.insert(std::make_pair("for",new MyClass()));

// Neue Instanzen erstellen
MyClass * pmc = m_pCreate["for"];
MyClass * pmc1 = m_pCreate["for"];

Das ganze funktioniert recht gut, nur das problem ist, das pmc und pmc1 auf das selbe objekt verweisen, d.h. wenn ich in pmc1 etwas ändere, so wird es auch in pmc geändert!
Wie kann ich dieses Problem am besten beheben, ohne allzugroße Änderungen durchführen zu müssen?

Danke,

Bsp:

int main()
{
    map<string, int> m;
    m.insert(make_pair("eins", 1));
    m.insert(make_pair("zwei", 2));

    int x = m["eins"]; // hier Kopie in x speichern.

    x = ...; // jetzt kannst du x verändern, ohne dass dies Auswirkungen auf m["eins"] hat.
}

Gruß Caipi

MyClass mc1=*m_pCreate["for"];
MyClass mc2=*m_pCreate["for"];
//nun sind mc1 und mc2 lokale Kopien des Objekts "for" - und damit unabhängig von diesem (und voneinander)

also werden auch änderungen auch bei der _gleichen_ instanz, auf die mit einem _anderen_ pointer gezeigt wird "ankommen"

ich denke du solltest dich etwas mit dem begriff factory auseinandersetzen, denn wirst du automatisch eine korrekte lösung finden

es sollte etwa wie folgt aussehen:

class MyClass{
....
virtual MyClass* create();///< macht neue instanzen
...
virtual ~MyClass();
}

class m_p_factory {

map<sting,auto_ptr<MyCLass>> creators;// autoptr nimmt mit das ab, was normalerweise im dtor von m_p_factory steht

void register(sting name,MyCLass* class)
{
creators.instert(PAIR(name,autoptr(class); //das ist kein korrektes c++, hätte sonst ctors für autoptr und so anschaun müssen ;P
}
MyClass* create(string name)
{
return creators[string]->create();
}
} // end class m_p_factory

[edit]
glaub jezze hab ich alle typo'S

Kurze Zwischenfrage: Wozu brauchst du eigentlich zwei unabhängige Kopien deines Objekts?

Ich habe ein skript in xml vorliegen.
Also z.b.

<for>
...
</for>

soll die Klasse mit dem Namen "for" aufrufen.

class base
{
public:
  ...
  base* copy() const = 0;
  ...
}

class forClass : public MyClass
{
public:
  forClass(const forClass& other) {...}
  ...
  base* copy() const
  {
    return new forClass(*this);
  }
  ...
}

map<string,base*> classes;
classes.insert(make_pair("for",new forClass(...)));
...
string input/* ="for" */;
base* mc = classes[input].copy();