Wenn ich etwas "werfe", wo wird es gespeichert?

Ich verstehe, dass wenn etwas thrown ist, der Stapel bis zu dem Punkt 'abgewickelt' wird, an dem es abgefangen wird, und die Destruktoren von Klasseninstanzen auf dem Stapel in jedem Funktionskontext ausgeführt werden (weshalb Sie keine Ausnahme von einem Destruktor auslösen sollten - Sie könnten am Ende einen zweiten werfen) ... aber ich frage mich, wo im Speicher das Objekt gespeichert ist, das ich geworfen habe, während dies geschieht?

Ist es implementierungsabhängig? Wenn ja, gibt es eine bestimmte Methode, die von den meisten gängigen Compilern verwendet wird?

Ja, die Antwort ist vom Compiler abhängig.

Ein kurzes Experiment mit meinem Compiler ( g++ 4.4.3) zeigt, dass seine Laufzeitbibliothek zuerst versucht, mallocSpeicher für die Ausnahme zu erstellen, und andernfalls versucht, Speicherplatz in einem prozessweiten "Notfallpuffer" zuzuweisen, der sich im Datensegment befindet. Wenn das nicht klappt, ruft es an std::terminate().

Es scheint, dass der Hauptzweck des Notfallpuffers darin besteht, werfen zu können, std::bad_allocnachdem der Prozess keinen Heap-Speicherplatz mehr hat (in diesem Fall würde der mallocAufruf fehlschlagen).

Die relevante Funktion ist __cxa_allocate_exception:

extern "C" void *
__cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) throw()
{
  void *ret;

  thrown_size += sizeof (__cxa_refcounted_exception);
  ret = malloc (thrown_size);

  if (! ret)
    {
      __gnu_cxx::__scoped_lock sentry(emergency_mutex);

      bitmask_type used = emergency_used;
      unsigned int which = 0;

      if (thrown_size > EMERGENCY_OBJ_SIZE)
        goto failed;
      while (used & 1)
        {
          used >>= 1;
          if (++which >= EMERGENCY_OBJ_COUNT)
            goto failed;
        }

      emergency_used |= (bitmask_type)1 << which;
      ret = &emergency_buffer[which][0];

    failed:;

      if (!ret)
        std::terminate ();
    }

  // We have an uncaught exception as soon as we allocate memory.  This
  // yields uncaught_exception() true during the copy-constructor that
  // initializes the exception object.  See Issue 475.
  __cxa_eh_globals *globals = __cxa_get_globals ();
  globals->uncaughtExceptions += 1;

  memset (ret, 0, sizeof (__cxa_refcounted_exception));

  return (void *)((char *)ret + sizeof (__cxa_refcounted_exception));
}

Ich weiß nicht, wie typisch dieses Schema ist.

Von dieser Seite :

Für Ausnahmen, die ausgelöst werden, ist Speicher erforderlich. Dieser Speicher muss bestehen bleiben, während der Stapel abgewickelt wird, da er vom Handler verwendet wird und threadsicher sein muss. Der Speicher für Ausnahmeobjekte wird daher normalerweise im Heap zugewiesen , obwohl Implementierungen möglicherweise einen Notfallpuffer bereitstellen , um das Auslösen von bad_alloc-Ausnahmen unter Bedingungen mit geringem Speicher zu unterstützen.

Dies ist nur der Itanium ABI und ich suche nach Details, die für GCC, Clang und MSVC spezifisch sind. Der Standard spezifiziert jedoch nichts und dies scheint der offensichtliche Weg zu sein, um Ausnahmespeicher zu implementieren, also ...

Ich weiß nicht, ob dies Ihre Frage beantworten wird, aber dies (wie ein C ++ - Compiler die Ausnahmebehandlung implementiert) ist ein ausgezeichneter Artikel über die Ausnahmebehandlung überhaupt :. Ich empfehle es sehr (:

Entschuldigen Sie die kurze Antwort, aber die gesamten Informationen im Artikel sind großartig. Ich kann hier keine Informationen auswählen und veröffentlichen.

Der C ++ - Standard gibt im Allgemeinen an, wie sich die Sprache verhält, nicht jedoch, wie der Compiler dieses Verhalten implementieren soll. Ich denke, diese Frage fällt in diese Kategorie. Der beste Weg, so etwas zu implementieren, hängt von den Besonderheiten der Maschine ab - einige Prozessoren haben viele Allzweckregister, andere nur sehr wenige. Ein Prozessor kann sogar nur für Ausnahmen mit einem speziellen Register erstellt werden. In diesem Fall sollte der Compiler die Möglichkeit haben, diese Funktion zu nutzen.

Nun, es kann nicht auf dem Stapel sein, da das abgewickelt wird, und es kann nicht auf dem Haufen sein, da dies bedeuten würde, dass das System wahrscheinlich nicht werfen könnte std::bad_alloc. Davon abgesehen liegt es ganz bei der Implementierung: Nicht die Implementierung angegeben (die dokumentiert werden muss), sondern nicht angegeben. (Eine Implementierung kann den Heap die meiste Zeit verwenden, solange sie über eine Art Notfallsicherung verfügt, die eine begrenzte Anzahl von Ausnahmen zulässt, selbst wenn kein Speicher mehr vorhanden ist.)