ich bekomm immer wieder Probleme beim Verwenden von Zeigern und Referenzen.
Bei Referenzen weiss ich, dass sie nur innerhalb des anlegenden Scopes gültig sind, aber wie siehts mit Zeigern aus?

Z.B.:

vector<Test *> testVector;
void MyClass::test()
{
    Test t1();
    testVector.push_back(&t1);
    Test t2();
    testVector.push_back(&t2);
}

Sind nun nach Verlassen der Methode test() im testVector gültige Zeiger oder nicht?

Was passiert hier eigentlich:

vector<Test> testVector;
void MyClass::add(const Test& test) { testVector.push_back(test); }

Wird hier ein Duplikat des Objekts angelegt, welches sich hinter der übergebenen Referenz verbirgt?

Hab nun schon einiges zu Referenzen und Zeigern gelesen, komme aber bei solchen Situationen immer wieder ins Schleudern.

Kann mir das einer bitte idiotensicher erklären?!

Danke schon mal.

Ciao

void foo()
{
  int x; // x ist nur innerhalb der Funktion Foo gültig
  int *y = new int; // y zeigt auf einen Speicherbereich der auch nach verlassen der Funktion Foo belegt ist
}

// von obj wird eine referenz übergeben, also keine Kopie des Objektes selbst angelegt. 
// Da "const" kann obj aber auch nicht geändert werden
void bar( const Klasse &obj ) 
{
  obj.nurlesezugriff...
}

// Wie oben eine Referenz, aber auch mit dem Recht zu verändern
void bar( Klasse &obj )
{
  int x;

  // set will einen zeiger und bekommen die adresse "&" von x übergeben
  // leider leider wird x aber nach verlassen der Funktion zerstört und der 
  // Zeiger hinter "set" zeigt auf einen ungültigen Speicherbereich
  obj.set( &x ) 
  obj.get()
}

// Ähnliche Anwendung wie Referenzen, keine Kopie und Objekt kann geändert werden
void bar( Klasse *obj )
{
}

std::list< int > l;
// referenz von list übergeben, so spart man sich die kopie und die Änderung wirkt sich auch nach Aussen aus...
void blubb( std::list< int > &list ) 
{
  int x = 10;
  list.push_back( x ); // von x wird eine kopie erzeugt und in list abgelegt
}

grüße

Aber wie verhält es sich denn bei meinem 2. Bsp.?
Wird dort eine Kopie des Objektes angelegt, dessen Referenz übergeben wird?
Darf ja eigentlich nicht sein, da const - oder?
Aber was wird dann auf den vector gelegt? Funktioniert hat der Code zumindest!

Ciao

Das ist egal ob const oder nicht. Der Vektor erwartet keinen Zeiger und noch viel weniger eine Referenz. Das Objekt wird kopiert und im Vektor abgelegt.

grüße

Kann dann das abgelegte Objekt geändert werden, wenn man es aus dem vector holt? Denke schon, oder?

Eine letzte Frage noch: Gibt es denn dann Möglichkeiten, Objekte und Variablen über Methoden- und Klassengrenzen hinweg zu verwenden, ohne sie immer alle zu übergeben, ohne sie alle global zu machen und ohne new zu verwenden?

Kenne zumindest keine.
Mein Problem mit new und delete ist, dass ich wenn ich Objekte dynamisch erzeuge ja nicht weiss, wie viele es sind wenn new und delete an unterschiedlichen Stellen ausgeführt werden müssen.
Noch schlimmer wird es, wenn Zeiger auf Objekte an unterschiedlichen Stellen eingetragen werden und dann u.U. versucht wird ein Objekt 2 Mal mit delete freizugeben.

Gibts da ne gute Vorgehensweise?

Konkret hab ich ne Klasse, in deren init-Methode ich eine Reihe von Objekten anlege, die in dieser Klasse und in anderen Klassen verwendet werden. Zeiger darauf werden in einen vector eingetragen. Die Objekte werden mit new angelegt.
Aber wo gebe ich sie wie wieder frei? Wenn sie nur in diesem einen vector stehen ist es kein Problem: Ich durchlaufe ihn und mache ein delete mit jedem Objekt im vector. Aber wenn ich sie in untersch. vector-Objekte lege, dann bekomme ich Probleme, wenn ich den delete mit jedem dieser vector-Objekte wie eben beschrieben mache.

Ciao

Du könntest Statische Variablen verwenden. Was mir nicht ganz klar ist, ist was du mit "immer übergeben" meinst.

Das Problem mit dem mehrfachfreigeben von Speicher kannst du mit Shared Pointern und Referenzenzählung lösen.
Auch ein Thema in das du dich mal einlesen solltest: Smart Pointer.

Dieser Lösungsansatz hilft dir auch bei der Problemlösung deiner letzten Frage!

grüße

Hi!

Du könntest Statische Variablen verwenden. Was mir nicht ganz klar ist, ist was du mit "immer übergeben" meinst.

An andere Klassen, Methoden usw.

Das Problem mit dem mehrfachfreigeben von Speicher kannst du mit Shared Pointern und Referenzenzählung lösen.
Auch ein Thema in das du dich mal einlesen solltest: Smart Pointer.

Dieser Lösungsansatz hilft dir auch bei der Problemlösung deiner letzten Frage!

grüße

Das muss ich mir dann wohl auch mal antun! Gibt es noch nen anderen Ansatz, um mit new und delete ordentlich umzugehen?

Danke!

Ciao

Es gibt mehrere Vorgehensweisen. Aber wenn du wissen willst wieviel Zeiger auf einen Speicherbereich zeigen kommst du kaum um einen Refcounter rum.
Das schöne an Smartpointern ist ja, das der Speicher automatisch freigegeben wird und du dich um nichtsmehr kümmern musst.
Die Speicherfreigabe geschieht auch im falle von Ausnahmen:

try
{
   smartpointer< aufdeinobjekt > ptr( new deinobjekt );
   irgendeinfehlerwirdgeschmissen
}
catch( ... )
{
  //
}

// Normal wär der Speicher hier verloren...

grüße

Hi!

Es gibt mehrere Vorgehensweisen. Aber wenn du wissen willst wieviel Zeiger auf einen Speicherbereich zeigen kommst du kaum um einen Refcounter rum.

Hm, eigentlich interessiert mich das nur sekundär.
Mein Problem ist, dass ich in einer Methode anonyme Objekte mit new erzeuge und diese in einer anderen Klasse eintrage. Nun dachte ich mir, dass ich im Destruktor dieser anderen Klasse alle diese eingetragenen Objekte mit delete lösche.

Oder wie ist in C++ das Vorgehen mit anonym mit new erzeugten Objekten?

Das schöne an Smartpointern ist ja, das der Speicher automatisch freigegeben wird und du dich um nichtsmehr kümmern musst.
Die Speicherfreigabe geschieht auch im falle von Ausnahmen:

Heisst das, dass man kein delete mehr braucht?

Ciao

Du brauchst es also noch in der Smartpointerklasse, aber sonst nicht mehr. Die Gefahr, ein delete mal zu vergessen, ist somit eigentlich nicht mehr gegeben.

Das delete steht im Dtor der Smartpointerklasse. Objekte von dieser Smartpointerklasse erstellst auf dem Stack, nicht auf dem Heap(new/delete). Sobald dann dieses Objekt den Gültigkeitsbereich verlässt wird der Dtor aufgerufen und automatisch deleted.

Vielen Dank für die Erklärung!
Das ist aber genau das, was ich eigentlich nicht brauche - Objekte/Zeiger auf dem Stack. Die Objekte, die ich mit new anlege, werden während des ganzen Programmablaufs benötigt und das an verschiedenen Stellen.
Werde dann wohl am besten auf eine Art Factory-Modell umsteigen, und die Objekte über create-Methoden in ihren Verwaltungsklassen erstellen lassen. In den Destruktoren der Verwalterklassen werden diese Objekte dann wieder deleted.
Oder gibt es auch ne Art SmartPointer für den Heap?

Ciao

Kenne mich wie gesagt mit Smartpointern nicht aus.
Was passiert denn, wenn ich in einer Methode ein Objekt mittels Smartpointer erstelle und diesen dann einer anderen Klasse übergebe und die Methode, in welcher der Smartpointer erstellt wurde beendet wird?

Ciao

Kommt auf die Art des SmartPtr an. Wenn du Referenzenzählung machst passiert garnichts. Dann wird der Speicher erst freigegeben sobald keine Instanz mehr den Speicher verwendet.

grüße

Die Klasse kapselt nur die new/delete-Aufrufe, sehr elementar sieht das ganze so aus:

template<class C>
class SmartPtr {
    public:
        SmartPtr(C* ob) : m_Object(ob) {
        }
        ~SmartPtr() {
            delete m_Object();
        }
    private:
        C* m_Object;
};

verwenden kannst Du das dann so:

SmartPtr<Klasse1> ptr( new Klasse1() );

Das Objekt von Klasse1 wird ganz normal auf dem Heap platziert, aber das Objekt der Klasse SmartPtr<Klasse1> landet auf dem Stack, also wird der Dtor aufgerufen, sobald das Objekt vom SmartPtr<Klasse1> den Gültigkeitsbereich verlässt, dort wird dann delete aufgerufen.
Jetzt kann man in der Klasse noch nen Member einfügen, der bei jedem neuen Zeiger erhöht wird und im Dtor runterzählt und erst, wenn der Zähler auf 0 steht, dann wird delete aufgerufen.
Dann kann man noch Operatoren überladen, irgendwie muss man ja auch auf das Objekt zugreifen, welches im SmartPtr gehalten wird.

mantiz schrieb:

Jop, in solch' einem Fall sollte man wohl Referenzzählung verwenden.

Das Objekt von Klasse1 wird ganz normal auf dem Heap platziert, aber das Objekt der Klasse SmartPtr<Klasse1> landet auf dem Stack, also wird der Dtor aufgerufen, sobald das Objekt vom SmartPtr<Klasse1> den Gültigkeitsbereich verlässt, dort wird dann delete aufgerufen.
Jetzt kann man in der Klasse noch nen Member einfügen, der bei jedem neuen Zeiger erhöht wird und im Dtor runterzählt und erst, wenn der Zähler auf 0 steht, dann wird delete aufgerufen.

Ohne den würde ja das Objekt entfernt, wenn ich den SmartPointer aus der Methode, in der er erzeugt wurde einer anderen Klasse übergebe und die Methode dann verlasse, oder?

Wie sieht denn so ein Zähler codemäßig aus, d.h. wo ist er zu platzieren?

[/quote]
Dann kann man noch Operatoren überladen, irgendwie muss man ja auch auf das Objekt zugreifen, welches im SmartPtr gehalten wird. :)[/quote]

Liefert der Standard autopointer schon so eine Funktionalität mit Referenzzählung? Muss ich doch noch mal wühlen!