Unklarheit bei folgenden Befehlen...

[Daniel Strigl]

Ich habe innerhalb eines Quelltextes mehrere Befehlsanweisungen gefunden, deren Bedeutung und arbeitsweise mir fremd sind.
Also, wenn mir jemand erklären könnte was es sich mit den foldenden Befehlen auf sich hat wäre ich sehr dankbar!

throw new int('budv');

(wieso eine Exception mit new int..)

virtual VBitmap& init(void *data, BITMAPINFOHEADER *) throw();

(was macht das 'throw()' nach der Funktionsdeklaration?)

virtual void MakeBitmapHeader(BITMAPINFOHEADER *bih) const throw();

(was macht das 'const throw()' nach der Funktionsdeklaration?)

<p>1. Hier wird ein int, welches mit 'budv' initialisiert wird, geworfen</p>
<p>2. throw() hinter einer Funktionsdeklaration bedeutet, dass diese Funktion keine Ausnahmen wird</p>
<p>3. throw() bedeutet das Gleiche wie unter 2, das zusätzliche 'const' bedeutet, dass diese Funktion den Zustand der Klasse ('MakeBitmapHeader()' ist Elementfunktion einer Klasse) nicht ändert (Verstöße werden vom Compiler erkannt).</p&gt

[Christian Ziem]

Aha, alles verstanden. Und was hilft das nun

<p>Das hängt davon, was Du darunter verstehst? Ich habe lediglich die Fragen beantwortet...</p>

<p>Die ersten beiden Fragen beziehen sich auf das sog. 'Exception Handling' unter C++. C++ führt einen neuen Mechanismus ein, Fehler zu fangen und zu verarbeiten. Dieser Mechanismus arbeitet mit den Keywords 'try', 'catch' und 'throw'. Mit einfachen Worten beschrieben funktioniert 'Exception Handling' wie folgt: Eine Funktion versucht einen bestimmten Code abzuarbeiten. Tritt dabei ein Problem auf, kann diese Funktion einen Fehler 'werfen' (-> 'throw'), den die aufrufende Funktion 'fangen' kann (-> 'catch').</p>
<pre>
void GreaterThanZero(const int ciValue)
{
if(ciValue <= 0)
throw "Value less or equal zero"
else
// Do processing
}

void main()
{
int iInt = 0;

try
{
GreaterThanZero(iInt);
}
catch(char *pError)
{
// Error handling
}
}
</pre>
<p>'try' leitet einen Bereich ein, indem Funktionen machen können, was sie wollen. In diesem Fall wird die Funktion 'GreaterThanZero' einen Fehler werfen. Dieser wird durch den Block, der mit 'catch' beginnt, aufgefangen.</p>
<p>Intern passieren die folgenden Dinge:</p>
<ul>
<li>Das geworfene Objekt wird an eine neutrale Stelle kopiert</li>
<li>Es wird versucht, das Ende des 'try'-Blocks zu finden</li>
<li>Wenn die aktuelle Funktion keinen 'try'-Block enthält, wird in der aufrufenden Funktion gesucht</li>
<li>Enthält auch diese keine, wird die nächsthöhere aufrufende Funktion durchsucht usw. - dies nennt sich 'Unwinding the stack' -> Aufrollen des Stacks</li>
<li>Währenddessen werden Onjekte in den verlassenen Funktionen zerstört, um 'memory leaks' zu vermeiden</li>
<li>Wird der einschließende 'try'-Block gefunden, wird der erste 'catch'-Block direjt nach der schließenden Klammer des 'try'-Blocks gesucht</li>
<li>Stimmt das geworfene Objekt mit dem Typ des 'catch'-Blocks überein, geht die Steuerung an diesen Block über, wenn nicht wird der nächste 'catch'-Block geprüft</li>
<li>Wird kein passender 'catch'-Block gefunden, wird der nächsthöhere 'try'-Block gesucht</li>
<li>Wird kein passender 'catch'-Block gefunden, wird das Programm beendet und das Fehlerobjekt an das Betriebssystem übergeben</li>
</ul>
<p>Geworfen werden können Objekte aller Art, über Standardtypen wie 'int', 'char', 'long' als auch Strukturen oder Klassen.</p>
<p>'catch'-Blöcke können entweder nur auf bestimmte Objekttypen reagieren oder auch alle geworfenen Fehlermeldungen bearbeiten:</p>
<ul>
<li>catch(...) - Fängt jede Art von geworfenem Objekt</li>
<li>catch(CError e) - Fängt geworfene CError-Objekte</li>
</ul>
Objekte können in den entsprechenden 'catch'-Blöcken auch wieder weitergeworfen werden, um mehrere Behandlungsschritte zu ermöglichen.
<pre>
void main()
{
try
{
Funktion();
}
catch(...)
{
if(KannIchKomplettBearbeiten)
{
// Behandlung des Fehlers
}
else
{
// Tu, was ich kann

// Ausnahme weiterwerfen
throw();
}
}
}
</pre&gt

[Daniel Strigl]

Danke für die gute Erklärung