Thread: Destructor not being Called

Hi,

Pseudocode of architecture:

Code:

class class2 {
    private:
        float* class_array;
    public:
        class2() { class_array = new float[10]; }
        ~class2() { delete [] class_array; }
}
class class1 {
    private:
        class2 my_class;
        int* unimportant_array;
    public:
        class1() {
            unimportant_array = new int[4];
        }
        ~class1() {
            delete [] unimportant_array;
        }
}
int main() {
    //...
    class1* var = new class1();
    //...
    delete var;
    //...
}

For some reason, I'm getting a memory leak. Using breakpoints, I've determined that the destructor of "class2" isn't called, and therefore "class_array" isn't getting delete-ed. But, when "class1" is destructed, shouldn't "my_class" also be destructed? Ideas?

Thanks,
Ian

Well, alrighty. I'm gonna post the minimum required to understand the code. Here goes.

glLibView.h/glLibView.cpp:

Code:

class glLibInternal_glLibView {
	private:
		glLibMathMatrix<float>* _matrix;
	public:
		//...
		
	public:
		glLibInternal_glLibView(void);
		glLibInternal_glLibView(int r[4], float near_value, float far_value);
		~glLibInternal_glLibView(void);
	private:
		void glLibInternal_copy_from( const glLibInternal_glLibView* copy);
	//...
};
glLibInternal_glLibView::glLibInternal_glLibView(void) {
	_matrix = new glLibMathMatrix<float>(4,4);
}
glLibInternal_glLibView::glLibInternal_glLibView(int r[4], float near_value, float far_value) {
	_matrix = new glLibMathMatrix<float>(4,4);
	//...
}
void glLibInternal_glLibView::glLibInternal_copy_from( const glLibInternal_glLibView* copy ) {
	glLibMathMatrix<float>::copy(_matrix,copy->_matrix);
	//...
}
glLibInternal_glLibView::~glLibInternal_glLibView(void) {
	delete _matrix;
}


class glLibView2D : public glLibInternal_glLibView {
	//...
};
glLibView2D::glLibView2D(void) : glLibInternal_glLibView() {}


class glLibView3D : public glLibInternal_glLibView {
	//...
};
glLibView3D::glLibView3D(void) : glLibInternal_glLibView() {}


class glLibViewISO : public glLibInternal_glLibView {
	//...
};
glLibViewISO::glLibViewISO(void) : glLibInternal_glLibView() {}

_matrix is the leaking variable.

tutorial.h:

Code:

class tutorial {
	public:
		//...
		glLibClock* clock;
	//...

	public:
		tutorial(void) {
			clock = new glLibClock(20);
			//...
		}
		~tutorial(void) {
			delete clock;
		}
		//...
};

ext_ray_trace.h:

Code:

class tutorial__ext_ray_trace : public tutorial {
	public:
		glLibView3D View3D;
		//...

	public:
		tutorial__ext_ray_trace(void) {}
		//...
};

tutorial__ext_ray_trace has an implicit destructor. View3D's destructor is not being called, and so View3D._matrix is leaking.

Tutorials.cpp:

Code:

void RunTutorial(tutorial* t) {
	//do some stuff to run t
	delete t;
	//...
}
int GetInput(void) {
	SDL_Event event;
	while (SDL_PollEvent(&event)) {
		switch (event.type) {
			case SDL_KEYDOWN:
				switch (event.key.keysym.sym) {
					//...
					case SDLK_k: RunTutorial(new tutorial__ext_ray_trace()); break;
				}
			//...
		}
	}
	return -1;
}
int main(int argc, char **argv) {
	//...
	while (true) {
		status = GetInput();
		//...
	}
	//...
}

The full sources of these files is can be found here.

Thanks,
Ian

And if it's not that then my bet is that it's failure to follow the rule of three.

Code:

void RunTutorial(tutorial* t) {
	//do some stuff to run t
	delete t;
	//...
}

To delete object of tutorial__ext_ray_trace correctly, you should declare the destructor of class tutorial as a virtual destructor.