Программирование – 2 курс осень 2020 – 9 занятие

Transcript

1. spbu.ru Динамическая память. Указатели Валерий Дмитриевич Олисеенко, Максим Викторович Абрамов vdo@dscs.pro, mva@dscs.pro
2. dscs.pro spbu.ru 2/16 dscs.pro Ссылка int main() { int a = 7; cout << a; // выводим значение переменной a cout << &a; // выводим адрес памяти переменной a cout << *&a; // выводим значение ячейки памяти переменной a return 0; } Ссылка = второе имя переменной
3. dscs.pro spbu.ru 3/16 dscs.pro Указатели *
4. dscs.pro spbu.ru 4/16 dscs.pro Как работают массивы в C++ int main() { int arr[10] = {0,1,2,3,4,5,6,7,8,9}; for (int i=0;i<10;i++) cout<<arr[i]<<" "; cout<<endl; int *ptr; ptr = arr; cout<<*(++ptr); return 0; } Имя массива = особая ссылка на первый элемент
5. dscs.pro spbu.ru 5/16 dscs.pro Непосредственное управление памятью int *pi = new int(1024); // pi указывает на объект со значением 1024 string *ps = new string (10, '9'); // *ps = "9999999999" vector<int> *pv - new vector<int>{0,1,2,3,4,5,6,7,8,9); // вектор на десять элементов со значениям и от 0 до 9 auto pi = new auto(obj); auto р2 = new auto{a,b,c}; // ошибка delete pi; int i, *pil = &i, *pi2 = nullptr; double *pd = new double(33), *pd2 = pd; delete i; // ошибка: i - не указатель delete pd; // ok delete pd2;// непредсказуемо: память, на которую указывает pd2,освобождена delete pi2;// ok: освобожден ненулевого указателя всегда допустимо
6. dscs.pro spbu.ru 6/16 dscs.pro Проблема указателей void doSomething() { int *ptr = new int; // утечка памяти } int main() { int *ptr = new int; *ptr = 8; delete ptr; // висячий указатель cout << *ptr; delete ptr; return 0; }
7. dscs.pro spbu.ru 7/16 dscs.pro Интеллектуальные указатели #incude <memory> unique_ptr <тип> имя(указатель_на_объект) shared_ptr <тип> имя(указатель_на_объект) weak_ptr <тип> имя(указатель_на_объект)
8. dscs.pro spbu.ru 8/16 dscs.pro Класс unique_ptr Указатель unique_ptr “владеет” объектом, на который он указывает. В отличие от указателя shared_ptr, только один указатель unique_ptr может одновременно указывать на данный объект. Объект, на который указывает указатель unique_ptr, удаляется при удалении указателя. unique_ptr<double> pi; // указатель unique_ ptr на тип double unique_ptr<int> р2 (new int(42));// р2 указывает на int со значением 42 unique_ptr pl(new string("Stegosaurus”)); unique_ptr p2 (pl); // ошибка: невозможно копирование unique_ptr unique_ptr рЗ; рЗ = р2 ; // ошибка: невозможно присвоение unique_ptr
9. dscs.pro spbu.ru 9/16 dscs.pro Класс unique_ptr // передает собственность от pi (указывающего на строку "Stegosaurus”) к р2 unique_ptr<string> р2 (pi.release()); //release() обнуляет pi unique_ptr<string> рЗ (new string("Trex")) ; // передает собственность от рЗ к р2 р2.reset(рЗ.release()); // resets освобождает память, на которую указывал указатель р2
10. dscs.pro spbu.ru 10/16 dscs.pro Класс shared_ptr Тип shared_ptr — это смарт-указатель в стандартной библиотеке C++, который предназначен для ситуаций, когда управлять временем существования объекта в памяти требуется нескольким владельцев. #incude <memory> shared_ptr<int> p1; shared_ptr<string> p2; shared_ptr<list<int>> р2;
11. dscs.pro spbu.ru 11/16 dscs.pro Класс shared_ptr class Item{ public: Item() { std::cout << "Item acquired\n"; } ~Item() { std::cout << "Item destroyed\n"; }}; int main(){ Item *item = new Item; shared_ptr<Item> ptr1(item); { shared_ptr<Item> ptr2(ptr1); cout << "Killing one shared pointer\n"; } cout << "Killing another shared pointer\n"; return 0;} Item acquired Killing one shared pointer Killing another shared pointer Item destroyed
12. dscs.pro spbu.ru 12/16 dscs.pro Класс shared_ptr class Item{ public: Item() { std::cout << "Item acquired\n"; } ~Item() { std::cout << "Item destroyed\n"; }}; int main(){ Item *item = new Item; shared_ptr<Item> ptr1(item); { shared_ptr<Item> ptr2(item); cout << "Killing one shared pointer\n"; } cout << "Killing another shared pointer\n"; return 0;} Item acquired Killing one shared pointer Item destroyed Killing another shared pointer Item destroyed
13. dscs.pro spbu.ru 13/16 dscs.pro make_shared() Правило: Всегда выполняйте копирование существующего shared_ptr, если вам нужно более одного shared_ptr, указывающего на один и тот же динамически выделенный ресурс. class Item{ public: Item() {cout << "Item acquired\n"; } ~Item() {cout << "Item destroyed\n"; }}; int main(){ auto ptr1 = make_shared<Item>(); { auto ptr2 = ptr1; cout << "Killing one shared pointer\n"; } cout << "Killing another shared pointer\n"; return 0; }
14. dscs.pro spbu.ru 14/16 dscs.pro Класс weak_ptr auto р = make_shared (42); weak_ptr wp(p); // wp слабосвязан с р; счетчик ссылок р неизменен Класс weak_ptr представляет интеллектуальный указатель, который не контролирует продолжительность существования объекта, на который он указывает. Он только указывает на объект, который контролирует указатель shared_ptr. Привязка указателя weak_ptr к указателю shared_ptr не изменяет счетчик ссылок этого указателя shared_ptr. Как только последний указатель shared_ptr на этот объект будет удален, удаляется и сам объект. Этот объект будет удален, даже если останется указатель weak_ptr на него. Имя weak_ptr отражает концепцию "слабого" совместного использования объекта.
15. dscs.pro spbu.ru 15/16 dscs.pro Класс allocator allocator alloc;// объект, способный резервировать строки auto const р = alloc.allocate(n);// резервирует n незаполненных строк auto q = р; // q указывает на следующий элемент после последнего созданного alloc.construct(q++); // *q - пустая строка alloc.construct(q++, 10 , 'c'); // *q - cccccccccc alloc.construct(q++, "hi"); // *q - hi! Правило: Удалять можно только те элементы, которые были фактически созданы. // освободить фактически зарезервированные строки while (q != р) alloc.destroy(— q); Правило: Как только элементы удалены, память можно повторно использовать для содержания других строк или возвратить их операционной системе. alloc.deallocate(р, n);
16. spbu.ru Динамическая память. Указатели Валерий Дмитриевич Олисеенко, Максим Викторович Абрамов vdo@dscs.pro, mva@dscs.pro