Gibt es in C++ einen Unterschied zwischen „throw“ und „throw ex“?

Diese Frage würde ich gerne stellen (auch hier), aber diesmal zu C++.

Was ist der Unterschied in C++ zwischen

try { /*some code here*/}
catch(MyException& ex)
{ throw ex;} //not just throw

und

try {  /*some code here*/}
catch(MyException& ex)
{ throw;} //not throw ex

Liegt es nur am Stacktrace (was in C++ sowieso kein Standard ist wie in C# oder Java)?

(Wenn es einen Unterschied macht, verwende ich MSVS 2008.)

throw; wirft dasselbe Ausnahmeobjekt erneut aus, das es währenddessen abgefangen hat throw ex; löst eine neue Ausnahme aus. Es macht keinen Unterschied, außer aus Performancegründen, ein neues Ausnahmeobjekt zu erstellen. Wenn Sie eine Ausnahmehierarchie haben, von der einige andere Ausnahmeklassen abgeleitet sind MyException -Klasse und beim Auslösen einer Ausnahme haben Sie Folgendes getan: throw DerivedClassException; es kann von der gefangen werden catch(MyException&). Wenn Sie nun dieses abgefangene Ausnahmeobjekt ändern und mit erneut auslösen throw; der Typ des Ausnahmeobjekts wird weiterhin sein DerivedClassException. Wenn Sie tun throw Ex; das Objekt-Slicing findet statt und die neu ausgelöste Ausnahme hat den Typ MyException.

[C++ FAQ Lite § 17.9] Was macht throw; (ausnahmslos Objekt nach dem throw Stichwort) bedeuten? Wo würde ich es verwenden?

Möglicherweise sehen Sie Code, der in etwa so aussieht:

class MyException {
public:
  ...
  void addInfo(const std::string& info);
  ...
};

void f()
{
  try {
    ...
  }
  catch (MyException& e) {
    e.addInfo("f() failed");
    throw;
  }
}

In diesem Beispiel ist die Anweisung throw; bedeutet “die aktuelle Ausnahme erneut auslösen.” Hier hat eine Funktion eine Ausnahme abgefangen (durch einen nicht konstanten Verweis), die Ausnahme geändert (indem sie Informationen hinzugefügt hat) und dann die Ausnahme erneut ausgelöst. Dieses Idiom kann verwendet werden, um eine einfache Form von Stack-Trace zu implementieren, indem Sie den wichtigen Funktionen Ihres Programms entsprechende Catch-Klauseln hinzufügen.

Eine andere Redewendung ist der “Exception Dispatcher”:

void handleException()
{
  try {
    throw;
  }
  catch (MyException& e) {
    ...code to handle MyException...
  }
  catch (YourException& e) {
    ...code to handle YourException...
  }
}

void f()
{
  try {
    ...something that might throw...
  }
  catch (...) {
    handleException();
  }
}

Dieses Idiom erlaubt eine einzelne Funktion (handleException()) wiederverwendet werden, um Ausnahmen in einer Reihe anderer Funktionen zu behandeln.

[C++ FAQ Lite § 17.11] Wenn ich dieses Objekt werfe, wie oft wird es kopiert?

Hängt davon ab. Könnte “null” sein.

Objekte, die geworfen werden, müssen einen öffentlich zugänglichen Kopierkonstruktor haben. Der Compiler darf Code generieren, der das geworfene Objekt beliebig oft kopiert, einschließlich null. Aber selbst wenn der Compiler das geworfene Objekt nie tatsächlich kopiert, muss er sicherstellen, dass der Kopierkonstruktor der Ausnahmeklasse vorhanden und zugänglich ist.

(bearbeitet, um mehr Klarheit darüber zu erhalten, was ich für offensichtlich hielt …)

catch(MyException& ex) { throw ex; } darf kopieren ex, mit allen damit verbundenen Problemen; catch(MyException& ex) { throw; } nicht dürfen.

Wenn Sie eine Ausnahmehierarchie haben, throw ex kann deine Ausnahme schneiden, während throw Gewohnheit. Beispielsweise:

#include <iostream> 
#include <string> 

using namespace std; 

struct base 
{ 
  virtual string who() {return "base";} 
}; 

struct derived : public base 
{ 
  string who() {return "derived";} 
}; 

int main() { 
  try { 
    try { 
      throw derived(); // throws a 'derived'
    }  
    catch (base& ex)  
    { 
      throw ex; // slices 'derived' object to be a 'base' object
    } 
  } 
  catch (base& ex) 
  { 
    cout<<ex.who()<<endl; // prints 'base'
  } 
} 

Veränderung throw ex nur throw, und Sie erhalten eine Ausgabe von derived, was Sie wahrscheinlich erwartet haben.

Du kannst den … benutzen throw; bilden mit catch(...) (das ist die einzige Möglichkeit zum erneuten Werfen, wenn Sie mit catch(…) erwischt wurden).

Es gibt einen großen Unterschied. Ich habe darüber in meinem Blog geschrieben, unter: https://cpptalk.wordpress.com/2009/08/23/nuances-of-Exception-rethrow/

Schaut gerne mal rein

throw ex wird eine weitere Kopie machen und wird nicht empfohlen throw nur um das aktuelle Ausnahmeobjekt auszulösen.

throw kann einen nicht standardmäßigen Ausnahmetyp auslösen, der von catch(…) abgefangen wurde (zB strukturierte Ausnahme)