Почему при вызове деструктора не меняется переменная?

Question

[liver2009]

#include <iostream>
#include <string>
using namespace std;

class BaseCl {
protected:
    int index;

public:

};

class b : public BaseCl {
private:
    
    string* str;

public:
    b() {

        str = nullptr;
    }

    ~b() {

        cout << str << endl;

    }

    void setb(int i) {
        this->index = i;
        str = new string[2];
        str[0] = "str0 index of b object " + to_string(i);
        str[1] = "str1 index of b object " + to_string(i);
    }
};

class a {
private:
    b* bObj;
    int delete_counter = 0;
public:

    a() {
        bObj = nullptr;

    }

    a(int size) {
        bObj = new b[size];

        for (int i = 0; i < size; i++) {
            bObj[i].setb(i);
        }

        delete_counter++;
    }

    ~a() {
        if (delete_counter > 0) {
            delete[] bObj;
            delete_counter--;
        }
    }
};

int main()
{
    cout << "Hello World!\n";

    a* aobj1;
    aobj1 = new a;

    aobj1[0] = a(2);

    delete aobj1;
}

Прогонял сей код в отладчике. И не могу понять почему, когда у меня вызывается второй раз деструктор в классе а, то переменная delete_counter=1. Т.е. по окончанию работы деструктора класса а она становится равной нулю, однако при вызове деструктора второй раз она снова становится равной единице.

Подскажите, пожалуйста, в чем может быть причина, или что можно почитать на эту тему.

Comments

[Wataru]

Где вызывается второй раз деструктор? Где вы смотрите на значение переменной?

[Василий Дёмин]

А в c++ разве можно два раза деструктор вызвать? И какой смысл менять переменную объекта в деструкторе, если после его вызова объект перестанет существовать?

[liver2009]

Wataru, в отладчике VS там это видно все очень хорошо.

[liver2009]

Василий Дёмин, если сначала отрабатывает конструктор по умолчанию, а затем конструктор с параметром то, видимо, деструктор вызывается два раза.

[Adamos]

Есть ощущение, что ТС что-то прочитал про static, но забыл само это слово...

[Wataru]

liver2009, Ну вот вы по шагам распишите. Вот тут вызывается такой-то конструктор. Переменная стала такой. Вот тут присваивание вызывает конструктор с параметром. переменная стала вот такой. Вот тут что-то удаляется, вызывается вот то, перменная стала такой. А хотелось, чтобы она была вот такой.

Пока вообще не понятно, где она становится и что вы на самом деле ожидаете.

[Евгений Шатунов]

Василий Дёмин, да, легко, это приводит к UB.
Просто, подобно автору вопроса, пишем в два разных места один адрес объекта, а потом не задавая вопросов дважды удаляем этот объект из двух этих разных мест.
Итог: деструктор вызван два раза, второй раз - для неправильного адреса, по которому уже нет объекта.

[Евгений Шатунов]

liver2009, у тебя в коде тип a реализует схему владения памятью. Владение у тебя, согласно деструктору типа a и счетчику ссылок, реализовано совместное.
Но для поддержки схемы совместного владения ты не реализовал ни одного конструктора или оператора для копирования и перемещения ресурса, которым твой тип владеет. Такими конструкторами будут конструктор копирования и конструктор перемещения. А операторами - оператор копирования и оператор перемещения.

В целом, твоей задачей является просто последовать правилу 3/5/0, т.е. правилу пяти чтобы у тебя память ресурса не утекла. Еще для правильного подсчета ссылок тебе надо что-то сделать со своим счетчиком, пока что у тебя значение delete_counter для каждой инстанции a является уникальным, а должно быть уникальным для каждого уникального значения bObj. Да и в целом, счетчик сейчас работает неправильно. Он должен гарантировать удаление уникального bObj только один раз за все совместное владение.

Пока что, в твоем коде у тебя получается что в один момент времени, точно после отработки оператора копирования по умолчанию, у тебя и *aobj1, и локальный временный a(2), владеют одной памятью. Сразу после этого локальный временный a(2) эту самую память удаляет в своем деструкторе, а *aobj1 начинает ссылаться на мусор.
К моменту delete aobj1; ты получаешь UB, т.к. деструктор для памяти по указателю aobj1->bObj вызывается уже второй раз.

Answer 1

[Wataru]

Я так понимаю, у вас проблема со строчкой
aobj1[0] = a(2);

Тут вызывается конструктор для временного значения a. Потом оператор копирования из временной переменной в *aobj. Потом вызывается деструктор временного значения.

А потом где-то в конце произойдет и деструктор aobj.

У aobj delete_counter после этой строчки равен 1 (ведь он скопирован у временного значения, которое сделало delete_counter единицей в констукторе). В конце при вызове деструктора aobj там delete_counter будет 1 в начале.

Вы смотрите на адрес this в дебагере в деструкторе. Два вызваных деструктора будут для двух разных объектов (для временного значения и для aobj).

Если вы хотите какой-то счетчик ссылок делать, то вам надо переопределять операторы копирования и перемещения (а так же все возможные конструкторы). И там аккуратно изменять счетчик ссылок. И счетчик ссылок должен быть частью общего объекта - частью класса b, а не класса a.

Comments

[res2001]

Немного разжую:

aobj1 = new a; // создается объект в динамической памяти, вызывается конструктор по умолчанию

/* 1. создается временный объект и вызывается его конструктор с параметром (a(2)), 
   2. вызывается операция присваивания копированием по умолчанию для объекта *aobj1 и в этот объект побайтно копируется содержимое временного объекта. 
   3. Для временного объекта вызывается деструктор, так что память выделенная для bObj будет освобождена, что делает объект *aobj1 не корректным (это проявится при любом обращении к aobj1->bObj) */
aobj1[0] = a(2); 

delete aobj1; // вызывается деструктор *aobj1

[Евгений Шатунов]

res2001, можно поправлю? :)

в этот объект побайтно копируется содержимое временного объекта

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

[res2001]

Евгений Шатунов, Согласен. Но для встроенных типов (а в примере в классе используются только они) это то же самое, что и побайтовое копирование.

[Евгений Шатунов]

res2001, и не поспоришь ведь. Все верно. :)