Знакомимся с деструктором на примере создания объекта-массива
- Для понимания темы нужно знать:
- Одномерный статически-создаваемый массив. Задать количество элементов
- Функции в С++ для начинающих. Прототипы
- Указатели в C++ для начинающих. Поверхностное знакомство
- Конструктор Класса
- Определение методов класса вне класса
- Конструктор класса с параметрами. Передача в конструктор класса значений
Деструкторы имеют прямо противоположный смысл конструкторам. Конструкторы предназначены в помощь конструирования объектов, деструкторы предназначены в помощь зачистки объектов.
Если конструкторы выполняются каждый раз, когда создаются объекты класса, то деструктор некоторого объекта некоторого класса выполняется каждый раз, когда объект прекращает своё существование.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #1 Деструктор #include <iostream> using namespace std; class MyClass{ public: ~MyClass(){ cout << "destructor"; }; }; int main(){ { MyClass X; } //X прекратил своё существование cin.get(); { MyClass X; } //X прекратил своё существование cin.get(); } |
Обычные объекты, под которые не выделялось памяти, живут в своём блоке кода и, если они не static, не под влиянием new, а самые обычные, то вместе с завершением блока кода завершают своё существование. В листинге #1 два объявления завёрнуты каждый в свой блок, внутри одного живёт одно, внутри другого другое, а после подхода компилятора к завершающей блок части, включается деструктор.
Возможно, вам сложно понять, зачем нужны деструкторы. В С++ программисту позволено работать с памятью. Когда программист берёт управление памятью в свои руки, то для возможности существования объекта в памяти компьютера выделяется память, которую потом нужно не забывать очищать. Это хорошо знакомо тем, кто выделял память под массивы.
|
1 2 3 |
int *arr = new int[100]; //выделяется //какой-то код delete []arr; //очищается |
Когда код большой, тогда легко не уследить за delete, не написать в коде, чем допустить утечку памяти. Деструкторы помогают частично избавиться от уделения особого внимания выделению и зачистке. И выделение памяти и очистка памяти заворачиваются в один объект, порождаемый классом, и потом такой порождённый объект ведёт себя как если бы он был обычной переменной. Т. е. если внутри класса есть какая-то переменная, требующая выделения памяти, и в такой класс в конструктор запрограммировать выделение памяти, а в деструктор высвобождение, то порождаемый от класса объект будет самостоятельно выделять память той внутренней классу переменной (при объявлении объекта) и выполнять высвобождение памяти (при уничтожении объекта).
Классический пример: использование указателя в качестве массива. Когда требуется массив, число вмещаемых элементов которого задаётся при выполнении программы, а не во время компиляции, в стиле С++, тогда требуется использование пары new и []delete). Если эту пару завернуть в класс, выделяющую часть в конструктор, а разрушающую в деструктор, то станет легко создавать массив через объект класса, следить за выделением и высвобождением памяти не придётся.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//Листинг #2 Использование конструктора и деструктора #include <iostream> using namespace std; class MyArray{ int *ptr; //указатель, будет выполнять роль массива int size_; //число вмещаемых в массив элементов public: MyArray(); //Прототип конструктора по умолчанию MyArray(int value); //Прототип конструктора с параметром, принимает число, обозначающее вместимость массива ~MyArray(); //прототип деструктора }; MyArray::MyArray(){ ptr = 0; //костыль, чтобы []delete не применилось к указателю, под который не выделилось памяти. } MyArray::MyArray(int value){ size_ = value; //Запоминаем вошедшее в value значение как размер массива в переменную size класса ptr = new int[size_]; //выделяем память, согласно размеру } MyArray:: ~MyArray(){ //деструктор delete []ptr; //высвобождаем память } int main(){ MyArray arr1; //создали объект, этот объект представляет собой массив MyArray arr2(20); //создали объект, этот объект представляет собой массив из 20 элементов } |
- Деструктор по своей форме очень похож на конструктор, единственно отличие в синтаксисе — добавление значка тильды.
В листинге #2 мы фактически получили эквивалент массива, обернув составляющие, воспроизводящие массив, классом. Теперь можно создавать много объектов и не заботиться о выделении и очистке памяти. Эти заботы теперь берёт на себя объект, который выполняет роль нашего массива. Добавим в класс информационную часть. Будем заполнять массив и выводить данные массива на экран. Для этого встроим в класс два метода (метод заполнения массива и метод вывода массива на экран).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
//Листинг #3 Использование деструктора Создаём объект, подобный одномерному массиву #include <iostream> using namespace std; class MyArray{ int *ptr; //указатель, будет выполнять роль массива int size_; //число вмещаемых в массив элементов public: MyArray(); //Прототип конструктора по умолчанию MyArray(int value); //Прототип конструктора с параметром, принимает число, обозначающее вместимость массива ~MyArray(); //прототип деструктора /*МЕТОД ЗАПОЛНЕНИЯ МАССИВА*/ void fill(){ for (int i=0; i<size_; i++){ //С помощью цикла обхожу массив ptr[i] = i; //И заполняю массив значениями по порядку (0,1,2...) } } /*МЕТОД ВЫВОДА МАССИВА НА ЭКРАН*/ void print(){ for (int i=0; i<size_; i++){ //обычный цикл обхода массива cout << ptr[i] << ' '; //и вывод значений на экран } cout << '\n'; } }; MyArray::MyArray(){ ptr = 0; //костыль, чтобы []delete не применилось к указателю, под который не выделилось памяти. } MyArray::MyArray(int value){ size_ = value; //Запоминаем вошедшее в value значение как размер массива в переменную size класса ptr = new int[size_]; //выделяем память, согласно размеру } MyArray:: ~MyArray(){ //деструктор delete []ptr; //высвобождаем память } int main(){ MyArray arr1(5); //создали объект, этот объект представляет собой массив из 20 элементов MyArray arr2(6); //создали объект, этот объект представляет собой массив из 20 элементов MyArray arr3(7); //создали объект, этот объект представляет собой массив из 20 элементов arr1.fill(); //заполнили массивы arr2.fill(); arr3.fill(); cout << "arr1: "; arr1.print(); //выводим значения на экран cout << "arr2: "; arr2.print(); cout << "arr3: "; arr3.print(); //в любой момент можно использовать нужный объект cout << "arr1: "; arr1.print(); } |
Теперь заботы о выделении памяти и высвобождении больше на компиляторе, а программист может больше внимания уделять другим деталям проекта.
|
1 2 3 4 5 6 7 8 9 10 11 |
int main(){ int N = 0; cout << "input size arr: "; cin >> N; MyArray arr(N); //Теперь можно легко создавать одномерный массив, не используя константу времени компиляции и не втыкая в new/delete arr.fill(); arr.show(); } |
Единственное, нужно один раз описать, как выделять и как высвобождать память, дальше всё резко упрощается. Основное предназначение деструктора помогать разрушать объект, которому помогали конструироваться. В отличие от конструкторов, видов которых много, деструктор всего один. В приведённом примере у меня в конструкторе (который по умолчанию) указатель принудительно перенаправляется в ноль. Делается это для того, чтобы избежать []delete к указателю, не удостоившемуся выделения памяти. Не факт, что внутренняя для класса указательная переменная, которой памяти не выделяется, будет указывать на объект, память которому выделялась.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//Листинг #a1 #include <iostream> using namespace std; int main(){ int *p; int a = 10; p = &a; delete []p; //нельзя, потому что не было new[] Нельзя delete применять к a } |
Чтобы не получилась ситуация, как показана в листинге #a1, нужно delete использовать только в паре со new, исключением являетя применение delete к нулю. То, что пришлось это использовать — это издержка того, что если мы описываем любой конструктор класса, то обязательно описывать и конструктор класса по умолчанию. Этот конструктор по умолчанию мог бы нам помешать. Ведь мы привыкли объявлять переменные без использования круглых скобок, но если так объявлять объект класса, то запускается конструктор класса по умолчанию, а когда объект прекращает своё существование, тогда запускается деструктор. Коли нами в конструкторе по умолчанию не выделялось памяти, а в деструкторе обязательно сработает delete []ptr, то delete []ptr применится к учатку памяти, к которому ему может быть нельзя. Только из-за этого указательная переменная в конструкторе по умолчанию направлялась в ноль. Можно было выделить ей памяти, но выделение памяти операция долгая, поэтому вариант с перенаправлением в ноль предпочтительней.
Иногда нежелателен запуск конструктора по умолчанию. Например, в нашем случае могло быть желательно только создание массива с явным указанием элементов. Коли нам обязательно добавлять конструктор умолчания в класс, если мы внедряем в клас другие виды конструкторов, но срабатывание конструктора умолчания нам вообще не нужно и даже мешает, мы можем спрятать этот конструктор в секцию private
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
//Листинг #4 Прячем конструктор умолчания в секцию private #include <iostream> using namespace std; class MyArray{ int *ptr; //указатель, будет выполнять роль массива int size_; //число вмещаемых в массив элементов MyArray(); //Прототип конструктора по умолчанию, прячем в private public: MyArray(int value); //Прототип конструктора с параметром, принимает число, обозначающее вместимость массива ~MyArray(); //прототип деструктора /*МЕТОД ЗАПОЛНЕНИЯ МАССИВА*/ void fill(){ for (int i=0; i<size_; i++){ //С помощью цикла объожу массив ptr[i] = i; //И заполняю массив значениями по порядку (0,1,2...) } } /*МЕТОД ВЫВОДА МАССИВА НА ЭКРАН*/ void print(){ for (int i=0; i<size_; i++){ //обычный цикл обхода массива cout << ptr[i] << ' '; //и вывод значений на экран } cout << '\n'; } }; MyArray::MyArray(){} MyArray::MyArray(int value){ size_ = value; //Запоминаем вошедшее в value значение как размер массива в переменную size класса ptr = new int[size_]; //выделяем память, согласно размеру } MyArray:: ~MyArray(){ //деструктор delete []ptr; //высвобождаем память } int main(){ //MyArray arr; //Теперь так нельзя MyArray arr(10); //Зато так можно arr.fill(); arr.print(); } |
Коли так вышло, что конструктор умолчания ничего не должен был делать, то спрятать его в private более мудрое решение, чем просто занулить указатель. Но в идеале и спрятать, и занулить указатель. Таким образом можно предупредить возникновение ошибки и даже не знать, о том, что однажды ошибка дала бы о себе знать. Конечно, есть ситуации, когда конструктор умолчания нужен, и таких ситуаций много, просто в настоящем примере потребовалось его не использовать.
Если вы приноровитесь подсматривать как живут объекты, то сможете легче отслеживать и понимать, что такое жизнь переменных. И в конструктор и в деструктор легко внедрить информационную составляющую, а эта информационная составляющая может послужить чем-то вроде шпаргалки:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
//Листинг #5 Подсматриваем, когда работает конструктор, когда работает деструктор #include <iostream> using namespace std; class MyArray{ int *ptr; //указатель, будет выполнять роль массива int size_; //число вмещаемых в массив элементов public: MyArray(int value); //Прототип конструктора с параметром, принимает число, обозначающее вместимость массива ~MyArray(); //прототип деструктора /*МЕТОД ЗАПОЛНЕНИЯ МАССИВА*/ void fill(){ for (int i=0; i<size_; i++){ //С помощью цикла объожу массив ptr[i] = i; //И заполняю массив значениями по порядку (0,1,2...) } } /*МЕТОД ВЫВОДА МАССИВА НА ЭКРАН*/ void print(){ for (int i=0; i<size_; i++){ //обычный цикл обхода массива cout << ptr[i] << ' '; //и вывод значений на экран } cout << '\n'; } MyArray(); //Прототип конструктора по умолчанию, прячем в private }; MyArray::MyArray(){} MyArray::MyArray(int value){ size_ = value; //Запоминаем вошедшее в value значение как размер массива в переменную size класса ptr = new int[size_]; //выделяем память, согласно размеру cout << "object build\n"; //выводим информационную составляющую: объект был собран } MyArray:: ~MyArray(){ //деструктор delete []ptr; //высвобождаем память cout << "object destroyed\n"; //выводим информативную составляющую: объект уничтожен } int main(){ MyArray arr1(10); //выведется object build MyArray arr2(15); //выведется object build MyArray arr3(7); //выведется object build arr1.fill(); arr1.print(); arr2.fill(); arr2.print(); arr3.fill(); arr3.print(); /*Объекты больше не используются*/ //выведется object destroyed //первый деструктор отработал //выведется object destroyed //второ отработал //выведется object destroyed //третий отработал } |
К сожалению, не всё в моих силах. Вам лучше всего поиграть с использованием объекта и подсматриваем данных о его жизни (конструировании и уничтожении). Трудность может возникнуть именно с конструкторами, потому что в зависимости от ситуации может вызываться или один, или второй, или третий вид конструктора. Но какой из конструкторов будет вызван, можно судить по коду. До этого момента на сайте рассматривались конструктор по умолчанию (вызывается, если в месте объявления объекта объекту скобок не давать), конструктор копирования (вызывается, если при объявлении уходящим аргументом или при присваивании оказывается объект того же класса, что и объявляемый), конвертирующий конструктор (конструктор с одним или более параметрами), просто конструктор с параметрами (если запрещен конвертирующий).
Резюмируем:
- Обычно деструктор используется для "очистки", когда объект больше не нужен.
- Деструктор противоположность конструктору.
- Деструктор объявляется подобно конструктору умолчания, но с приставлением значка тильды ~.
- Деструктор не разделяется на виды, в отличие от конструкторов, и не может иметь параметров.
- Всегда (если не заставлять принудительно) деструктор вызывается автоматически, когда объект прекращает своё существование.
Один комментарий на «“Знакомимся с деструктором на примере создания объекта-массива”»
Добавить комментарий
Случайная книга в электронном формате
Спасибо за ваш труд!!!