C++ Destructors , dynamic allocation

Question

I have recently had some errors (bad_alloc) due to my lack of a destructor.

I currently have two classes, set up in this way:

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;
};

and here is my operator= for ObjTwo

ObjTwo& ObjTwo::operator=(const ObjTwo& other) {
    num = source.num;
    x = source.x;
    myObjOne=source.myObjOne;
    return *this;
}

Firstly, my assumptions were (Please correct these if it is incorrect):

ObjOne does NOT need a destructor, as it is only primitive types, and when the compiler will use the default destructor to clean it up. ObjTwo DOES need a destructor, as it contains ObjOne ObjTwo Destructor will need to deallocate memory from x,num and myObjOne.

I have made a few attempts at destructors with this, however I still run into bad_alloc errors (when testing with huge loops etc.) or other errors (with the current one it just crashes when destructor is called).

Any guidance on what I am doing wrong is appreciated

EDIT: I have a bad_alloc exception being thrown when I simply put this in a loop:

ObjTwo b(//some parameters);
ObjTwo a(//some parameters);
for (int i=0; i<20000000; i+) {
    bool x = (a == b);
}

and this is overloaded == operator

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;
}

After some reading on the error it seemed that it was caused to due running out of memory; which my unfunctioning destructor would cause. What could be the problem here?

and the get method simply returns jon[i];

Answer 1

You do not need any of your uses of delete. You should only delete something that you have previously allocated with new.

In ObjTwo, the members myObjOne, num, and x definitely should not be deleted. In fact, you should never take the address of a member and delete it. Members are destroyed automatically when the object they are a member of is destroyed.

Consider, for example, having a member which was defined like this:

int* p;

This p is a pointer to int. The pointer itself will be destroyed when the object it is part of is destroyed. However, imagine that in the constructor you dynamically allocate an int object like so:

p = new int();

Now, because new dynamically allocate objects, you will need to delete the object pointed to by p. You should do this in the destructor with delete p;. Note that this isn't destroying p, it's destroying the object it points out. Since p is a member, you should not destroy it manually.

Answer 2

ObjOne MIGHT need a destructor. This is not about primitive types, but about things like dynamically allocated memory (pointers). You have an int* member, which might be allocated dynamically or at least be a pointer to dynamic memory. So you will need to use delete or delete[] on this one.
What you are doing in ~ObjectTwo is fatal! You are trying to delete memory from the stack -> undefined behavior but will mostly crash. All of your objects/variables are stack-allocated, so you must not delete them...