This is the whole point. The only way to guarantee that applications close down in any kind of orderly fashion is to close them down in the way that they expect.
TerminateProcess is obviously out because it kills a process so indiscriminately that it has no chance to finish what it is currently doing let alone clean up.
But what about PostQuitMessage? At first glance this may seem acceptable because you are telling the application that it is quitting. However if you dig into the Window procedure then you will start figuring out why it is a bad idea.
Take the average window procedure. This is what defines the behaviour of the window, and Windows calls this whenever anything happens.
LRESULT CALLBACK WindowProc(HWND wnd, UINT msg, WPARAM w, LPARAM l)
{
switch(msg)
{
//other messages here, the contents are unimportant
case WM_CLOSE:
//do document cleanup here
DestroyWindow(wnd);
return 0;
case WM_DESTROY:
//do window cleanup here
PostQuitMessage(0);
return 0;
//maybe other messages here, the contents are unimportant
}
return 0;
};
Notice that glossing over the other stuff, the way that these three highlighted messages interact with each other? The WM_CLOSE message is originally sent/posted to the window somehow. Maybe using the x button in the top right or maybe through some other
means. In response to this the application starts the cleanup. This is where I start doing the automatic saving of any documents open, or prompting the user if they want to save their work.
The next thing that this does is call DestroyWindow, which eventually sends WM_DESTROY. This is where I normally clean up the window related data structures. For example, if I'm using Direct2D to draw and DirectWrite for text then I clean up the objects
here. Then it calls PostQuitMessage.
So you are starting with the very final step an application should do. It is also the very last thing an application does itself after it has cleaned up everything. So what you really need to do is start off the whole WM_CLOSE chain. The other thing that
you really should do is not even touch TerminateProcess. In your code you should wipe away all traces of this and figure out how to close the application without it.
This is a signature. Any samples given are not meant to have error checking or show best practices. They are meant to just illustrate a point. I may also give inefficient code or introduce some problems to discourage copy/paste coding. This is because
the major point of my posts is to aid in the learning process.
