Понимание значения слова и понятия - RAII (Приобретением ресурса является Инициализация),

См.:

Программисты других языков, помимо C++, используют, знают или понимают RAII?

RAII и интеллектуальные указатели в C++

C++ поддерживает 'наконец' блоки? (И каков этот 'RAII', о котором я продолжаю слышать?)

RAII по сравнению с исключениями

и т.д.

RAII использует семантику деструкторов C++ для управления ресурсами. Например, рассмотрите интеллектуальный указатель. У Вас есть параметризованный конструктор указателя, который инициализирует этот указатель с адресом объекта. Вы выделяете указатель на стеке:

SmartPointer pointer( new ObjectClass() );

Когда интеллектуальный указатель выходит из объема, деструктор класса указателя удаляет подключенный объект. Указатель выделяется стеку и объект - выделенный "куче".

Существуют определенные случаи, когда RAII не помогает. Например, если Вы используете интеллектуальные указатели подсчета ссылок (как повышение:: shared_ptr), и создают подобную графику структуру с циклом, Вы рискуете сталкиваться с утечкой памяти, потому что объекты в цикле будут препятствовать друг другу быть выпущенными. Сборка "мусора" помогла бы против этого.

Я соглашаюсь с cpitis. Но хотел бы добавить, что ресурсы могут быть чем-либо не просто память. Ресурс мог быть файлом, критическим разделом, потоком или соединением с базой данных.

Это называют, Приобретение Ресурса Является Инициализацией, потому что ресурс получен, когда объект, управляющий ресурсом, создается, Если конструктор перестал работать (т.е. из-за исключения), ресурс не получен. Затем, после того как объект выходит из объема, ресурс выпущен. C++ гарантирует, что все объекты на стеке, которые были успешно созданы, будут разрушены (это включает конструкторов базовых классов и участников, даже если конструктор суперкласса перестал работать).

Рациональное позади RAII должно сделать исключение приобретения ресурса безопасным. Это все полученные средства правильно высвобождены, неважно, где исключение происходит. Однако это действительно полагается на качество класса, который получает ресурс (это должно быть безопасным исключением, и это твердо).

Я хотел бы поместить его немного более сильно затем предыдущие ответы.

RAII, Приобретение Ресурса Является средствами Инициализации, что все полученные ресурсы должны быть получены в контексте инициализации объекта. Это запрещает "явное" приобретение ресурса. Объяснение - то, что очистка в C++ работает на объектной основе, не основании вызова функции. Следовательно, вся очистка должна быть сделана объектами, не вызовами функции. В этом смысле C++ более - объектно-ориентированный затем, например, Java. Очистка Java основана на вызовах функции в finally пункты.

Проблема со сборкой "мусора" состоит в том, что Вы теряете детерминированное разрушение, это крайне важно для RAII. После того как переменная выходит из объема, это до сборщика "мусора", когда объект будет исправлен. Ресурс, которым это сохранено объектом, продолжит быть сохраненным, пока деструктор не называют.

И как можно сделать что-то на стеке, который вызовет очистку чего-то, что живет на "куче"?

class int_buffer
{
   size_t m_size;
   int *  m_buf;

   public:
   int_buffer( size_t size )
     : m_size( size ), m_buf( 0 )
   {
       if( m_size > 0 )
           m_buf = new int[m_size]; // will throw on failure by default
   }
   ~int_buffer()
   {
       delete[] m_buf;
   }
   /* ...rest of class implementation...*/

};


void foo() 
{
    int_buffer ib(20); // creates a buffer of 20 bytes
    std::cout << ib.size() << std::endl;
} // here the destructor is called automatically even if an exception is thrown and the memory ib held is freed.

Когда экземпляр int_buffer появляется, он должен иметь размер, и он выделит необходимую память. То, когда это выходит из объема, это - деструктор, называют. Это очень полезно для вещей как объекты синхронизации. Рассмотреть

class mutex
{
   // ...
   take();
   release();

   class mutex::sentry
   {
      mutex & mm;
      public:
      sentry( mutex & m ) : mm(m) 
      {
          mm.take();
      }
      ~sentry()
      {
          mm.release();
      }
   }; // mutex::sentry;
};
mutex m;

int getSomeValue()
{
    mutex::sentry ms( m ); // blocks here until the mutex is taken
    return 0;  
} // the mutex is released in the destructor call here.

Кроме того, есть ли случаи, где Вы не можете использовать RAII?

Нет, не действительно.

Вы когда-либо желаете сборки "мусора"? По крайней мере, сборщик "мусора" Вы могли использовать для некоторых объектов, позволяя другим управляться?

Никогда. Сборка "мусора" только решает очень небольшое подмножество динамического управления ресурсами.

RAII прибывает из Распределения ресурсов, Инициализация. В основном это означает, что, когда конструктор заканчивает выполнение, созданный объект полностью инициализируется и готов использовать. Это также подразумевает, что деструктор высвободит любые средства (например, память, ресурсы ОС) принадлежавший объекту.

По сравнению с собравшими "мусор" языками/технологиями (например, Java.NET), C++ позволяет полный контроль над жизнью объекта. Для стека выделенный объект Вы будете знать, когда деструктор объекта назовут (когда выполнение выйдет из объема), вещь, которой действительно не управляют в случае сборки "мусора". Даже с помощью интеллектуальных указателей в C++ (например, повышение:: shared_ptr), Вы будете знать, что, когда нет никакой ссылки на резкий объект, деструктор того объекта назовут.

Уже существует много хороших ответов здесь, но я был бы точно так же, как для добавления:
Простое объяснение RAII состоит в том, что в C++ объект, выделенный на стеке, уничтожается каждый раз, когда он выходит из объема. Это означает, деструктор объектов назовут и может сделать всю необходимую очистку.
Это означает, если объект создается без "нового", нет "удалите", требуется. И это - также идея позади "интеллектуальных указателей" - они находятся на стеке, и по существу переносит основанный на "куче" объект.

RAII является акронимом для Приобретения Ресурса, Инициализация.

Эта техника очень уникальна для C++ из-за их поддержки обоих Конструкторов и Деструкторов и почти автоматически конструкторов, которые соответствуют этому аргументы, передаваемые в или худший случай, которым конструктора по умолчанию называют и деструкторы, если обеспеченный explicity называют иначе по умолчанию, который добавляется компилятором C++, назван, если Вы не записали деструктор явно для класса C++. Это происходит только для объектов C++, которыми автоуправляют - значение, которые не используют свободное хранилище (память выделила/освободила использование, новое, новое [] / удаляют, удаляют [] операторы C++).

Метод RAII использует эту функцию автоуправляемого объекта для обработки объектов, которые создаются на heap/free-store просьбой explcitly о большей памяти, использующей новый/новый [], который должен быть явно уничтожен вызовом, удаляют/удаляют []. Класс автоуправляемого объекта перенесет этот другой объект, который создается на heap/free-store памяти. Следовательно, когда конструктор автоуправляемого объекта выполняется, перенесенный объект создается на heap/free-store памяти и когда дескриптор автоуправляемого объекта выходит из объема, деструктор того автоуправляемого объекта называют автоматически, в котором перенесенный объект уничтожается с помощью, удаляют. С понятиями ООП при обертывании таких объектов в другом классе в частном объеме у Вас не было бы доступа к перенесенным участникам классов и методам, и это - причина, почему интеллектуальные указатели (иначе классы дескриптора) разработаны для. Эти интеллектуальные указатели выставляют перенесенный объект как типизированный объект к внешнему миру и там позволяя вызывать любых участников/методы, из которых составлен выставленный объект памяти. Обратите внимание, что интеллектуальные указатели имеют различные разновидности на основе различных потребностей. Необходимо обратиться к современному программированию на C++ Andrei Alexandrescu или стимулировать библиотеку (www.boostorg) shared_ptr.hpp реализация/документация для получения дополнительной информации о нем. Надежда это помогает Вам понять RAII.