"main.cpp"
#include <string>
using namespace std;

int main()
{
    try
    {
        string str="Hallo";
        throw(str.c_str())
    }
    catch(const char* str)
    {
        cout<<str<<endl; //Warum wird hier noch immer was angezeigt,
                         //obwohl der string seinen Sichtbarkeitsbereich
                         //verlassen hat?
    }
}

Ich habe das Gleiche mit einem von mir new angelegten Speicherbereich gemacht, doch bei mir wurde nichts angezeigt.
Ich hab das Objekt statisch gemacht und es wurde angezeigt.

Warum geht es aber bei string, das Objekt ist nicht statisch.

Und hier ist es eben so, dass du nen Zeiger auf nen Speicherbereich hast, der noch nicht anderweitig genutzt wird und deshalb steht eben noch das drin, was du reingeschrieben hast...

bb

throw std::runtime_error("Ein Fehler!");

Und zum Fangen empfiehlt sich eine Referenz:

catch (std::runtime_error& e)

Hat string keinen Destruktor in dem er den angelegten Speicherbereich löscht?

Er gibt den Speicherbereich frei, das heisst, dieser steht wieder anderweitig zur Verfügung. Der verbleibende Speicherinhalt muss sich deswegen nicht gleich ändern.

Btw warum soll ich Standard Exception Klassen benutzen?

warum nicht?

Das heißt er gibt ihn frei, aber löscht ihn nicht?

Den Vorgang "Löschen" gibt es an sich nicht. Man löscht Daten eigentlich erst, indem man sie überschreibt. Der String gibt seinen Speicher frei und erlaubt es anderen Funktionen, diesen wieder zu benutzen und zu überschreiben. Ein wirkliches "Löschen", also beispielsweise Null-Setzen aller Bytes, würde nicht viel Sinn machen.

GuardianOfLife schrieb:

Btw warum soll ich Standard Exception Klassen benutzen?

Zum Beispiel, um die Exception-Hierarchie auszunutzen. Du kannst dir auch eigene Exceptionklassen schreiben, aber grundsätzlich hast du mit der Standard-Hierarchie die Möglichkeit, Exceptions gezielt zu fangen. Viele andere Bibliotheken (darunter Boost) erben ebenfalls von Standard-Exceptions, was dir erlaubt, sowohl sehr spezifisch einzelne Exceptions zu fangen als auch auf hoher Abstraktionsebene festzustellen, dass in deinem Programm ein Fehler aufgetreten ist.

Zumindest solltest du keine Zeiger werfen, deren Gültigkeit bis zum Fangen nicht garantiert ist.

try
{
    string str="Fehler in Datei: "; //Mit string gehts aber ich will eine eigene
    str+=lpfilename;                //Klasse benutzen
    throw(str) //keine Zeiger also werfe ich das Objekt
}
catch(const string& str)
{
    MessageBox(hwnd,str.c_str(),"Error",MB_OK|MB_ICONERROR);
}

Außerdem wollt ich einen char* benutze weil ich in mehreren Abschnitten strings werfe und ich wollt alles verallgemeinern damit ich nicht einen Catchblock für char* und string brauche.

Außerdem wollt ich einen char* benutze weil ich in mehreren Abschnitten strings werfe und ich wollt alles verallgemeinern damit ich nicht einen Catchblock für char* und string brauche.

Verallgemeinerung ist das Stichwort. Würdest du Exceptionklassen benutzen, hättest du dieses Problem zum Beispiel nicht. Denn du kannst auch char* an Funktionen übergeben, die einen std::string erwarten. Zu diesen Funktionen gehören die Konstruktoren gewisser Standard-Exceptionklassen.

Rohe Zeiger durch die Gegend zu werfen kann gefährlich sein, und es besteht normalerweise kein Grund, nicht auf Exceptionklassen zurückzugreifen. Oder siehst du das anders?