Недавно у меня были некоторые ошибки (bad_alloc) из-за отсутствия деструктора.
В настоящее время у меня есть два класса, настроенных таким образом:
class ObjOne {
friend class ObjTwo;
public: //constructors and some other random methods
ObjOne(int n) {
}
ObjOne() {
}
private:
int currSize;
int size;
int *jon;
};class ObjTwo {
public: //constructors and some other methods
ObjTwo(ObjOne, int n) {} //
ObjTwo() {}
ObjTwo(const ObjTwo &source) { //copy constructor
num = source.num;
x = source.x;
myObjOne=source.myObjOne;
}
~ObjTwo() { //destructor
delete #
delete &x;
delete &myObjOne;
}private:
ObjOne myObjOne;
int num, x;
};
а вот и мой оператор = для ObjTwo
ObjTwo& ObjTwo::operator=(const ObjTwo& other) {
num = source.num;
x = source.x;
myObjOne=source.myObjOne;
return *this;
}
Во-первых, мои предположения были (пожалуйста, исправьте их, если они неверны):
ObjOne НЕ нуждается в деструкторе, так как это только примитивные типы, и когда компилятор будет использовать деструктор по умолчанию для его очистки.
ObjTwo нуждается в деструкторе, так как он содержит ObjOne
ObjTwo Destructor потребуется для освобождения памяти из x, num и myObjOne.
Я сделал несколько попыток для деструкторов с этим, однако я все еще сталкиваюсь с ошибками bad_alloc (при тестировании с огромными циклами и т. Д.) Или другими ошибками (с текущей она просто вылетает при вызове деструктора).
Любое руководство о том, что я делаю неправильно, приветствуется
РЕДАКТИРОВАТЬ:
У меня возникает исключение bad_alloc, когда я просто помещаю это в цикл:
ObjTwo b(//some parameters);
ObjTwo a(//some parameters);
for (int i=0; i<20000000; i+) {
bool x = (a == b);
}
и это перегружено == оператор
bool ObjTwo::operator==(const ObjTwo& other) {
ObjTwo temp = other;
for(int i=myObjOne.x; i>=0; i--) {
if(myObjOne.get(i)!=temp.myObjOne.get(i)) {
return false;
}
}
return true;
}
После некоторого чтения ошибки казалось, что она вызвана нехваткой памяти; что мой неработающий деструктор вызовет. В чем может быть проблема здесь?
а метод get просто возвращает jon [i];
Вам не нужно использовать delete
, Вам следует только delete
то, что вы ранее выделяли new
,
В ObjTwo
, участники myObjOne
, num
, а также x
определенно не должно быть delete
д. На самом деле, вы никогда не должны брать адрес члена и delete
Это. Члены уничтожаются автоматически при уничтожении объекта, членом которого они являются.
Рассмотрим, например, наличие члена, который был определен следующим образом:
int* p;
это p
это указатель на int
, Сам указатель будет уничтожен при уничтожении объекта, частью которого он является. Однако представьте, что в конструкторе вы динамически выделяете int
объект вроде так:
p = new int();
Теперь, потому что new
динамически размещать объекты, вам нужно будет delete
объект, на который указывает p
, Вы должны сделать это в деструкторе с delete p;
, Обратите внимание, что это не разрушает p
разрушает объект, на который указывает. поскольку p
является членом, вы не должны уничтожать его вручную.
ObjOne
МОЖЕТ нужен деструктор. Речь идет не о примитивных типах, а о таких вещах, как динамически выделяемая память (указатели). У вас есть int*
член, который может быть выделен динамически или, по крайней мере, быть указателем на динамическую память. Так что вам нужно будет использовать delete
или же delete[]
на этом.
Что вы делаете в ~ObjectTwo
смертельно! Вы пытаетесь удалить память из стека -> неопределенное поведение, но в большинстве случаев вылетает. Все ваши объекты / переменные размещены в стеке, поэтому вы не должны удалять их …