std::vector <cStream*> Streams;

Streams.push_back(new cStream)

delete Streams[0];
Streams.erase(Streams.begin());

Das ist jetzt nur ein vereinfachtes Beispiel. Natürlich sind in dem
Vector noch mehr cStream Pointer. Mein Problem ist, dass das delete hier
einen Segfault ergibt. Ich will nicht nur den Pointer aus dem Vecor
entfernen, sondern auch den Speicher, der beim push_back mit new angefordert
wurde, wieder freigeben.
Warum funktioniert es mit diesem delete nicht?

Was spricht bei dir gegen Folgendes?

std::vector <cStream> Streams;

Was spricht bei dir gegen Folgendes?

std::vector <cStream> Streams;

Daß Wertsemantik bei einer Streamklasse unsinnig ist?

Daß Wertsemantik bei einer Streamklasse unsinnig ist?

Huch, hab gar nicht so auf die Bezeichner geachtet. Sorry in diesem Fall...
(Wenn sich mir die Möglichkeit böte, würde ich dennoch zu Pointer-Containern greifen).

Aber zu dem Problem:
Könnte es sein, dass die cStream -Klasse intern etwas falsch handhabt? Ist der Destruktor zum Beispiel richtig implementiert? Versuch ansonsten mal, mit dem Debugger den Fehler genau zu lokalisieren...

Und wie kann ich das Problem mit den ungültigen Iteratoren umgehen?

mit std::list...

bb

Die Streams werden so in den Vector eingefügt:

Streams.push_back(new cStream);

Wenn ein Stream entfernt werden soll, wird folgende Funktion aufgerufen:

void RemoveStream(int _StreamNumber)
{
    //remove stream completely
    Streams[_StreamNumber]->CloseStream();
    std::vector<cStream*>::iterator Iter = Streams.begin();
    for (int i = 0; i < _StreamNumber; i++)
    {
        Iter++;
    }

    delete Streams[_StreamNumber];
    Streams.erase(Iter);
    NumberOfStreams--;

    return;
}

_StreamNumber ist der entsprechenden Bezeichner.
Das CloseStream() der cStream-Klasse löscht nichts. Es wird lediglich die
Serververbindung beendet.
Das delete hier führt zu einem Segfault.

Streams.push_back(boost::shared_ptr<cStream>(new cStream));

Der Vector ist so deklariert:

boost::ptr_vector<boost::shared_ptr<cStream> > Streams;

Doch es kompiliert nicht.
By the way: Ist es besser, anstatt erase() ein release() aufzurufen, wenn
das Objekt auch zerstört werden soll?
Das ist die Fehlermeldung des Compilers:

error: no matching function for call to 'boost::ptr_vector<boost::shared_ptr<cStream>, boost::heap_clone_allocator, 
std::allocator<void*> >::push_back(boost::shared_ptr<cStream>)'
/usr/include/boost/ptr_container/ptr_sequence_adapter.hpp:178: note: candidates are: void boost::ptr_sequence_adapter<T, VoidPtrSeq,
CloneAllocator>::push_back(typename boost::ptr_container_detail::reversible_ptr_container<boost::ptr_container
_detail::sequence_config<T, VoidPtrSeq>, CloneAllocator>::value_type) [with T
= boost::shared_ptr<cStream>, VoidPtrSeq = std::vector<void*, std::allocator<void*> >, CloneAllocator = boost::heap_clone_allocator]

boost::ptr_vector<cStream>::iterator Iter = Streams.begin();
    for (int i = 0; i < _StreamNumber; i++)
    {
        Iter++;
    }

    Streams.erase(Iter);

Normalerweise iteriert man aber auch anders.

for (boost::ptr_vector<cStream>::iterator iter = Streams.begin(); i != Streams.end(); ++i) // wichtig: nicht i++
{
   // Mache für jedes Element etwas
}

Wenn du allerdings nur ein Element an einem bestimmten Index löschen willst, kannst du das bei Random-Access-Containern auch so machen:

Streams.erase(Streams.begin() + Index);

Aber sei dir bewusst, dass Zeiger, Referenzen und Iteratoren auf Elemente des Containers anschliessend ungültig werden können.

Du versuchst wahrscheinlich, ein Element zu löschen, das bereits jenseits der Sequenz liegt.

Normalerweise iteriert man aber auch anders.

for (boost::ptr_vector<cStream>::iterator iter = Streams.begin(); i != Streams.end(); ++i) // wichtig: nicht i++
{
   // Mache für jedes Element etwas
}

Wenn du allerdings nur ein Element an einem bestimmten Index löschen willst, kannst du das bei Random-Access-Containern auch so machen:

Streams.erase(Streams.begin() + Index);

Aber sei dir bewusst, dass Zeiger, Referenzen und Iteratoren auf Elemente des Containers anschliessend ungültig werden können.

Ich hab's nach der 2. Methode gemacht. Ich hab jedoch gelesen, dass release(),
anstatt erase() aufgerufen werden sollte, da so auch der Speicher für das
Element freigegeben würde. Mein Ziel war ja, dass nicht nur das Element
aus dem Vector entfernt wird, sondern auch ein delete für das Element auf-
gerufen wird.
Seh ich das richtig:
Beim std::vector muss als Typ <cStream*> angegeben werden, beim
boost::ptr_vector ein <cStream>, sonst wären es ja Zeiger auf Zeiger.
Der Elementzugriff erfolgt mit Punktoperator, anstatt ->.