Thread: Classes, dynamic variables, and leaks.

Code:

class boop {
  int *a;
  int b;
public:
  boop() {
    a = new int;
  }
  ~boop() {
    delete a;
  }
};

...

boop b1;
boop *b2 = new boop;

Okay, when b1 is created, b1.a is allocated anonymous memory and b1.b is given memory from the stack. When b1 goes out of scope, b1.b is automatically destroyed because it is local to b1. b1.a's memory is release in the destructor that's called when b1 goes out of scope. All is well unless something freaky happens like a call to abort before b1's destructor can be called.

b2 is a pointer that's assigned anonymous memory. When that happens, the same deal as with b1 occurs, but this time, b2 has to be explicitly released for the destructor to be called and the memory for b2.a released.

>So it IS necessary for the constructor to initialize any dynamic variables internal to the class?
No, it's just convenient. That way you have the object starting out in a predictable state. If you want you can allocate anonymous memory elsewhere in the class definition, it doesn't matter as long as you don't use the pointer until it has memory assigned to it and you release the memory before the object is completely destroyed.

>Also, by the way, b1's *a isn't the same value as b2's *a is it?
Nope, b1 and b2 are two separate objects of the boop class. That means that they each have separate copies of all the variables. So b1.a and b2->a are two different pointers. Remember that the pointers themselves are regular variables that hold an address. Two pointers will be different, but may point to the same memory.

that's about right. Classes are basically just buffers of memory much like structs. when you delete that class, you delete that memory. The dynamic stuff is basically when some sort of pointer or handle lives inside that buffer so you need to obviously check your pointers.

edit:
wow too slow.

>but as shown they would be seperate?
Yes, you could make them point to the same location thus:

Code:

delete b1.a;
b1.a = b2->a;

Assuming the members were public instead of private of course.

>do you still need the * for b2->a
Yes, but the syntax would be *b2->a.

>the delete a; would indeed free up the memory, as opposed to just ending the function without the delete?
Correct. But in this case a is the member of a class, so change "ending the function" to "destroying the object without calling delete".