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

Повышение имеет много они включая тех в Повышение. Межпроцессный для общей памяти. Это значительно упрощает управление памятью, особенно в вызывающих головную боль ситуациях как то, когда у Вас есть 5 процессов, совместно использующих ту же структуру данных: когда все сделали с блоком памяти, Вы хотите, чтобы она автоматически была освобождена & не должны находиться, там пытаясь выяснить, кто должен быть ответственен за вызов delete на блоке памяти, чтобы Вы не заканчиваете с утечкой памяти или указателем, который по ошибке освобожден дважды и может повредить целую "кучу".

Предпосылка и причины просты в понятии.

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

C++ не требует RAII, но все больше признается, что использование методы RAII произведет больше устойчивого кода.

причина, что RAII полезен в C++, состоит в том, что C++ внутренне справляется с созданием и разрушением переменных, как они вводят и оставляют объем, текут ли через нормальный код или посредством раскручивания стека, инициированного исключением. Это - бесплатный набор в C++.

Путем связи всей инициализации и очистки к этим механизмам, Вы обеспечены, тот C++ будет заботиться об этой работе для Вас также.

Разговор о RAII в C++ обычно приводит к обсуждению интеллектуальных указателей, потому что указатели особенно хрупки когда дело доходит до очистки. Когда управление памятью типа "куча" получило от malloc или новый, это обычно - обязанность программиста освободить или удалить ту память, прежде чем указатель будет уничтожен. Интеллектуальные указатели будут использовать философию RAII, чтобы гарантировать, что выделенные объекты "кучи" уничтожаются любое время, переменная указателя уничтожается.

Интеллектуальный указатель является изменением RAII. RAII означает, что приобретение ресурса является инициализацией. Интеллектуальный указатель получает ресурс (память) перед использованием и затем выбрасывает его автоматически в деструкторе. Две вещи происходят:

1. Мы выделяем память , прежде чем мы будем использовать ее, всегда, даже когда мы не чувствуем себя подобно ему - трудно сделать иначе с интеллектуальным указателем. Если этого не происходило, Вы попытаетесь получить доступ к ПУСТОЙ памяти, приводящей к (очень болезненному) катастрофическому отказу.
2. Мы освобождаем память , даже когда существует ошибка. Никакую память не оставляют, зависая.

, Например, другим примером является сетевой сокет RAII. В этом случае:

1. Мы открываемся сетевой сокет , прежде чем мы будем использовать его, всегда, даже когда мы не чувствуем себя подобно - трудно сделать это иначе с RAII. При попытке делать это без RAII, Вы могли бы открыть пустой сокет для, сказать соединение MSN. Тогда сообщение как "позволяет, делают оно сегодня вечером" не могло бы быть передано, пользователи не займутся сексом, и Вы могли бы рискнуть увольняться.
2. Мы закрываемся сетевой сокет , даже когда существует ошибка. Никакой сокет не оставляют, зависая, поскольку это могло бы предотвратить ответное сообщение, "уверенное плохой быть в нижней части" от того, чтобы наносить ответный удар отправителю.

Теперь, как Вы видите, RAII является очень полезным инструментом в большинстве случаев, поскольку он помогает людям заняться сексом.

источники C++ интеллектуальных указателей находятся в миллионах по всей сети включая ответы выше меня.

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

Просто пример, делающий его без SBRM:

void o_really() {
     resource * r = allocate_resource();
     try {
         // something, which could throw. ...
     } catch(...) {
         deallocate_resource(r);
         throw;
     }
     if(...) { return; } // oops, forgot to deallocate
     deallocate_resource(r);
}

, Как Вы видите, существует много способов, которыми мы можем получить pwned. Идея состоит в том, что мы инкапсулируем управление ресурсами в класс. Инициализация его объекта получает ресурс ("Приобретение Ресурса, Инициализация"). В то время, когда мы выходим из блока (область действия блока), ресурс освобожден снова.

struct resource_holder {
    resource_holder() {
        r = allocate_resource();
    }
    ~resource_holder() {
        deallocate_resource(r);
    }
    resource * r;
};

void o_really() {
     resource_holder r;
     // something, which could throw. ...
     if(...) { return; }
}

, Который хорош, если у Вас есть собственные классы, которые не являются только в целях выделения/освобождения ресурсов. Выделение просто было бы дополнительным беспокойством, чтобы сделать их задание. Но как только Вы просто хотите выделить/освободить ресурсы, вышеупомянутое становится неловким. Необходимо записать переносящийся класс для каждого вида ресурса, который Вы получаете. Для упрощения этого интеллектуальные указатели позволяют Вам автоматизировать тот процесс:

shared_ptr<Entry> create_entry(Parameters p) {
    shared_ptr<Entry> e(Entry::createEntry(p), &Entry::freeEntry);
    return e;
}

Обычно, интеллектуальные указатели являются тонкими обертками вокруг нового / удаляют, это просто, оказывается, звонит delete, когда ресурс, которым они владеют, выходит из объема. Некоторые интеллектуальные указатели, как shared_ptr позволяют Вам говорить им так называемое средство удаления, которое используется вместо delete. Это позволяет Вам, например, управлять дескрипторами окна, ресурсами регулярного выражения и другим произвольным материалом, пока Вы говорите shared_ptr о правильном средстве удаления.

существуют различные интеллектуальные указатели в различных целях:

unique_ptr

является интеллектуальным указателем, который владеет объектом исключительно. Это не находится в повышении, но это, вероятно, появится в следующем Стандарте C++. Это non-copyable, но поддерживает передача права собственности . Некоторый пример кода (следующий C++):

Код:

unique_ptr<plot_src> p(new plot_src); // now, p owns
unique_ptr<plot_src> u(move(p)); // now, u owns, p owns nothing.
unique_ptr<plot_src> v(u); // error, trying to copy u

vector<unique_ptr<plot_src>> pv; 
pv.emplace_back(new plot_src); 
pv.emplace_back(new plot_src);

В отличие от auto_ptr, unique_ptr может быть помещен в контейнер, потому что контейнеры будут в состоянии содержать non-copyable (но подвижный) типы, как потоки и unique_ptr также.

scoped_ptr

является интеллектуальным указателем повышения, который не copyable и не подвижен. Это - идеальная вещь, которая будет использоваться, когда Вы хотите удостовериться, что указатели удалены при выходе из объема.

Код:

void do_something() {
    scoped_ptr<pipe> sp(new pipe);
    // do something here...
} // when going out of scope, sp will delete the pointer automatically. 

shared_ptr

для общего владения. Для этого это и copyable и подвижно. Несколько экземпляров интеллектуального указателя могут владеть тем же ресурсом. Как только последний интеллектуальный указатель, владеющий ресурсом, выходит из объема, ресурс будет освобожден. Некоторый пример реального мира одного из моих проектов:

Код:

shared_ptr<plot_src> p(new plot_src(&fx));
plot1->add(p)->setColor("#00FF00");
plot2->add(p)->setColor("#FF0000");
// if p now goes out of scope, the src won't be freed, as both plot1 and 
// plot2 both still have references. 

, Как Вы видите, источник графика (функция fx) совместно используется, но у каждого есть отдельная запись, на которой мы выбираем цвет. Существует weak_ptr класс, который используется, когда код должен относиться к ресурсу, принадлежавшему интеллектуальному указателю, но не должен владеть ресурсом. Вместо того, чтобы передать необработанный указатель, необходимо тогда создать weak_ptr. Это выдаст исключение, когда это заметит, что Вы пытаетесь получить доступ к ресурсу weak_ptr путем доступа, даже при том, что нет никакого shared_ptr, больше владеющего ресурсом.

void foo()
{
   std::string bar;
   //
   // more code here
   //
}

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

Внутренне станд.:: строковые реализации часто используют ссылку считаемые указатели. Таким образом, внутренняя строка только должна быть скопирована когда одна из копий поменявших струн. Поэтому ссылка рассчитала, интеллектуальный указатель позволяет только скопировать что-то при необходимости.

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