Destructor called immediately after constructor

Question

I'm trying to create a Window class but for some reason a simple definition of a Window object is followed by calling it's destructor immediatly after.

The Window class' header has the following constructors and copy control defined:-

Window();
Window(int);
Window(const char* title);
Window(string title);
Window(const char* title, int x, int y, int width, int height);
Window(string title, int x, int y, int width, int height);
Window(const Window &window);
Window& operator=(const Window &window);
~Window();

The associated code for these functions is as follows:-

Window::Window()
{
  Window(default_title, default_width, default_height, default_xpos, default_ypos);
}

Window::Window(int)
:title_(default_title),
size_({ default_width, default_height }),
position_({ default_xpos, default_ypos })
{
  context_ = glutCreateWindow(title_.c_str());
  setposition(position_);
  setsize(size_);
  glutSetWindow(context_);
}

Window::Window(string title)
:Window(title, default_width, default_height, default_xpos, default_ypos)
{ }

Window::Window(const char* title)
{
  string t(title);
  Window(t, default_width, default_height, default_xpos, default_ypos);
}


Window::Window(const char* title, int x, int y, int width, int height)
{
  string t(title);
  Window(t, width, height, x, y);
}

Window::Window(string title, int x, int y, int width, int height)
:title_(title),
size_({ width, height }),
position_({ x, y })
{
  context_ = glutCreateWindow(title.c_str());
  refresh();
  setcallbacks();
  glutSetWindow(context_);
}

Window::Window(const Window &window)
:title_(window.title_),
size_(window.size_),
position_(window.position_)
{
  context_ = glutCreateWindow(title_.c_str());
  refresh();
  glutSetWindow(context_);
}

Window& Window::operator= (const Window &window)
{
  title_ = window.title_;
  size_ = window.size_;
  position_ = window.position_;
  context_ = window.context_;
  refresh();
  glutSetWindow(context_);
  return *this;
}

Window::~Window()
{
  glutDestroyWindow(context_);
}

None of the other functions used in the above code such as refresh() and setcallbacks() directly altar the class but instead call glut functions. If you think they're relevant I'll include them.

The problematic line is shown below, called as part of the main function:-

Window win("blah");

I've tried several configurations of this including the empty constructor, the full constructor and assignment but none seem to work. As far as I can tell, the constructor runs and initializes all the variables as expected then inexplicably calls the destructor when it advances to the next statement in the main function.

Well if you have called `Window win("blah");` without using it withing the actual scope, next step is that the destructor is called as expected. — πάντα ῥεῖ, Jul 26 '14 at 19:06

score 6 · Accepted Answer · answered Jul 26 '14 at 19:03

6

It is because you cannot call a constructor like this :

Window::Window(const char* title, int x, int y, int width, int height)
{
  string t(title);
  Window(t, width, height, x, y); // this create a temporary Window then destroy it
}

Instead do this :

Window::Window(const char* title, int x, int y, int width, int height)
    : Window( string(t), width, height, x, y)
{}

answered Jul 26 '14 at 19:03

galop1n

8,573
22
36

3

It should be noted however that this is possible only from C++11 onward. – Matteo Italia Jul 26 '14 at 19:07
1

Yes but i checked first and the question is tagged c++11, so… – galop1n Jul 26 '14 at 19:08
That seems to have worked, thank you. Just to clarify, was the problem calling the Window constructor from within another constructor? EDIT: missed the comment, it was. – James Richmond Jul 26 '14 at 19:09
I agree with @MatteoItalia delegated constructors are supported from C++11 and onward. You should also give the classic solution with initializer list as an alternative. – 101010 Jul 26 '14 at 19:09
@galop1n: of course, in facts I upvoted your answer anyway. It was just for completeness sake and for clarity for future visitors. :) – Matteo Italia Jul 26 '14 at 19:19

score 0 · Answer 2 · edited May 23 '17 at 12:27

To understand why your code doesn't work as you want it to, you need to know how constructor calls work.

In your default constructor, for exemple, you call another constructor that will create a Window object. But this new object is restrained to the default constructor scope ! So when you leave this scope (when the default constructor call ends), the object is destroyed by calling its destructor.

You can observe this because in the following constructor, you create a glut window (context_) and set it :

Window(string title, int x, int y, int width, int height)

Then, in the destructor, you destroy this glut window. Notice that you only called the destructor of the temporary object restrained to the default constructor scope ! The original call to the default constructor still creates a Window (an empty one) that stays in another scope.

To solve this and do what you originally wanted to do, you need to use constructor delegation (C++11 only). You do it by calling another constructor in the constructor initialization list like that :

Window::Window(/* some arguments */)
    : Window(/* other arguments (other constructor) */) {
    // other stuff
}

Also notice that you can use default parameters. Exemple here :

Window(string title = default_title,
       int x = default_xpos, int y = default_ypos,
       int width = default_width, int height = default_height);

And I think that you swapped the coordinates with the dimensions in your calls.

Destructor called immediately after constructor

2 Answers2