Angenommen ich würde meinen Code splitten, das heisst, ich würde einen Teil mit der Definition von diesen Variablen in einen try-Block setzen, und den Rest des Codes in den anderen try-Block. Könnte ich dann aus dem catch-Block des zweiten try-Blocks auf die Variablen zugreifen, die im ersten try-Block definiert wurden?

Viele Grüsse
Ewgenij

Gruß
Ewgenij

Hmm, aber wenn der compiler im catch-Block meckert, dass die Variable nicht definiert ist, dann heisst es doch, dass auch eine im try-Block initialisierte Referenz darauf nicht definiert sein wird. Oder? Ich meine, es ist doch wurscht, was ich im try-Block definiere: eine Variable oder einen Zeiger darauf, alles ist im catch-Block dann nicht sichtbar.

kopie erstellen?

das problem ist doch: catch ist etwas, dass komplett unabhaengig von dem code ist der die exception wirft. das ist der hintergedanke. man hat ein exception objekt wo alle wichtigen infos drinnen stehen. wenn man die fehlerbehandlung nun auf dem vorhanden sein von bestimmten variablen die (hoffentlich) gesetzt werden bevor die exception fliegt aufbaut, dann bindet man die fehlerbehandlung an den fehlererzeugenden code. genau das wollen exception aber vermeiden.

ein throw steht irgendwo und irgendwo komplett anders fange ich es dann. das exception objekt selber gibt mir alle nötigen infos über den kontext der exception.

void foo()
{
  int a = 0;
  {
    int b = 0;
    // <-- Hier ist a und b gültig
  }
  // <-- Hier ist a gültig
}

Damit erklärt sich schon alles andere.

cu André

OK, danke, Leute, habs verstanden Ich mache es einfach so, dass ich vor dem try-Block die Variable deklariere und noch eine zusätzliche boolische Variable. Die boolische Variable wird im try-Block zu true, wenn die erste Variable erfolgreich initialisiert wurde. Und in der Exception wird auf diese erste Variable nur dann zugegriffen, wenn die boolische Variable true ist. Das ist doch eine vernünftige Lösung, oder?

Das erscheint unlogisch. Die Exception kann entweder vor bzw. während der Initialisierung der Variablen auftreten oder erst danach. Nur wenn sie danach auftritt, ist der Zugriff auf diese Variable sinnvoll, zudem ist dann die Behandlung der Ausnahme eine Andere. Folglich sollte auch zwei try-catch-Blöcke geben, etwa so:

try
{
  /*...*/
  Typ variable = ...
  try
  {
     /*...*/
  }
  catch ( /*...*/ )
  {
      /*...*/ // spezieller Code, der nach der Initialisierung sinnvoll ist
      throw;
  }
}
catch ( /*...*/ )
{
  /* ... */
}

das kann man auch abwandeln. Natürlich deuten verschachtelte try-catch-Konstrukte oft auf ein anderes Problem hin: Entweder tut die betreffende Funktion nicht nur eine Sache, dann sollte man hier Refactoring betreiben, oder die Behandlung von Ausnahmen wird besser durch RAII z.B. mit Sentries gestaltet. Der automatische Aufruf von Destruktoren ist ja gerade deshalb nützlich, weil sich die Anzahl der möglichen Ausführungspfade nicht multipliziert.