C ++ RAII не работает?

У вас нет обработчика для вашего исключения. Когда это происходит, стандарт говорит, что вызывается std :: terminate, который, в свою очередь, вызывает abort. См. Раздел 14.7 в языке программирования C ++, 3-е издание.

Проблема в том, что main имеет особый статус. Когда оттуда генерируется исключение, стек не может быть осмысленно развернут, вместо этого приложение просто вызывает std:terminate.

И тогда становится понятным, почему переменные не выходят за рамки. Мы фактически не вышли из области, в которой они были объявлены. То, что происходит, можно считать эквивалентным этому:

int main(void) {
  A a1(1);
  A a2(2);
  std::terminate();
}

(Я считаю, что это зависит от реализации, вызываются ли деструкторы в этом случае, поэтому на некоторых платформах он будет работать так, как вы ожидали)

У вас есть необработанное исключение в main, что означает завершение вызова. Попробуй это:

int main(void)
{
    try
    {
        A a1(1);
        A a2(2);
        throw std::exception();
        return 0;
    }
    catch(const std::exception & e)
    {
        return 1;
    }


}

Если исключение ускользает из main (), это определяется реализацией, когда стек разматывается.

пытаться

int main()
{
    try
    {
        doWork(); // Do you experiment here. 
    }
    catch(...)
    {   /*
         * By catching here you force the stack to unwind correctly.
         */
        throw;  // re-throw so exceptions pass to the OS for debugging.
    }
}

Как указывали другие, у вас есть неперехваченное исключение, которое вызывает terminate (). Это определяется реализацией (см. Стандарт, 15.3 параграф 9 и 15.5.1 параграф 2), вызываются ли деструкторы в этом случае, и определение в вашей реализации, очевидно, «Нет, они не будут». (Если terminate () вызывается по любой другой причине, кроме выброса исключения, у которого нет обработчика, деструкторы не будут вызываться.)

Ваши объекты A не уничтожаются из-за вызова std :: terminate.

std :: terminate вызывается при утечке необработанного исключения из main. Если вы заключите свой код в команду try / catch (даже если уловка просто перерейзит), вы увидите ожидаемое поведение.

Вы не обрабатываете исключение должным образом, поэтому ваше приложение завершает работу до того, как объекты выйдут за пределы области видимости.

Я объясню еще немного. Если исключение «всплывает» наверх, стек разматывается (редактировать). Даже перенос кода во второстепенную функцию не решит эту проблему. бывший:

      1 #include <exception>
      2 #include <iostream>
      3
      4 void test();
      5
      6 class A {
      7     public:
      8         A(int i) { i_ = i; std::cout << "A " << i_ << " constructed" << std::endl; }
      9         ~A() { std::cout << "A " << i_ << " destructed" << std::endl; }
     10     private:    int i_;
     11 };
     12
     13
     14 int main(void) {
     15     test();
     16     return 0;
     17 }
     18
     19 void test(){
     20             A a1(1);
     21             A a2(2);
     22            throw std::exception();
     23 }

Приведенный выше код не решит проблему. Единственный способ решить эту проблему - заключить выброшенное исключение в блок try-catch. Это предотвратит попадание исключения в основную часть и остановит завершение, которое происходит до того, как объекты выйдут за пределы области видимости.

Другие предлагали поместить в main() команду try / catch, чтобы справиться с этим, что отлично работает. По какой-то причине я считаю, что редко используемый «function-try-block» выглядит лучше, что меня удивляет (я думал, что это будет выглядеть слишком странно). Но я не думаю, что в этом есть реальное преимущество:

int main(void) 
try
{
    A a1(1);
    A a2(2);
    throw std::exception();
    return 0;
}
catch (...) 
{
    throw;
}

Пара недостатков заключается в том, что, поскольку он редко используется, многие разработчики зацикливаются, когда видят его, и VC6 подавляется этим, если это необходимо.

Поскольку исключение не обрабатывается к тому моменту, когда оно достигает main (), оно приводит к вызову std :: terminate (), по сути, у вас есть эквивалент

int main(void) {
  A a1(1);
  A a2(2);
  exit(1);
}

НЕ гарантируется вызов деструкторов в случаях, когда программа завершается до того, как они выйдут за пределы области видимости. Для другой дыры в RAII рассмотрите:

int main(void) {
  A *a1 = new A(1);
}

Следующий код работает.

#include <exception> 
#include <iostream> 

class A { 
public: 
    A(int i) { i_ = i; std::cout << "A " << i_ << " constructed" << std::endl; } 
    ~A() { std::cout << "A " << i_ << " destructed" << std::endl; } 
private: 
    int i_; 
}; 

void test() {
    A a1(1); 
    A a2(2); 
    throw std::exception(); 
} 

int main(void) { 
 try {
  test();
 } catch(...) {
 }
    return 0; 
}