How to destruct instance in atexit() - c++

Question

I want to call destructor of an instance (proc) always before my program ends, especially after return 1 or exit() in main.
I found C++ function atexit(), but it requires pointer to void function with no argument, so the code below cannot be compiled. How I can solve it, please?
Destructor of my instance requires MySQL connection.
#include <WinSock.h>
#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <mysql.h>
#include <string>
// Declarations for Mysql DB
using namespace std;
class Process {
public:
~Process();
};
Process::~Process ()
{
// Interaction with DB
}
int main(void)
{
// Join to DB
atexit(proc.~Process); // Call desctructor of instance proc before program ends
Process proc;
// App code
return 0;
}

Answer 1

proc has automatic duration, i.e. when exiting main, it will be destroyed automatically (and the destructor invoked) - you don't need the atexit business..
Unless as #Rob mentions below, you call exit() in your code somewhere... if that's the case, then you'll have to allocate Process on the heap, provide a function that atexit can call which is aware of this instance, and delete it there...

Answer 2

Just make it a global std::auto_ptr<> or std::unique_ptr<>:
std::auto_ptr<Process> proc; // 1) initialized with NULL before main() is called
int main() {
proc.reset(new Process); // 2) re-initialized
}
// 3) proc destructor is called after main() exits

Answer 3

Use C++:
#include <memory>
std::unique_ptr<Process> g_proc;
int main()
{
g_proc.reset(new Process(some, runtime, params));
// all done!
}
Objects of static storage duration (e.g. globals, like our g_proc here) are destroyed after main exits, and the destructor of unique_ptr will take care of the object destruction.
Alternatively you can make g_proc a static variable inside main, though that's a bit unusual.

Answer 4

Change your program logic slightly to allocate your Process object dynamically:
Process *pProc;
void killProc() {
delete pProc;
}
int main(void)
{
// Join to DB
atexit(killProc); // Call desctructor of instance proc before program ends
pProc = new Process();
Process& proc = *pProc;
// App code
return 0;
}

Answer 5

As proc is not a pointer, it will be automatically deleted at the end of the main() function, and it's destructor will be called (before the memory is deallocated).
The atexit() function is not a C++ function, but is part of the standard C library.
If you need to call the destructor BEFORE the end of the main() function, you need to allocate the proc variable as a pointer.
You can also avoid the usage of global variables plus C functions by using an application class this way:
class Application
{
public:
Application() { proc = new Process(); /* other init code */ }
~Application() { delete proc; /* other clean-up code */ }
int run()
{
/* your application code goes here */
}
private:
Process *proc;
}
int main()
{
Application app;
int result = app.run();
/* Post clean-up code */
return result;
}
If you plan using C++11 can also rely on the 'unique_ptr' template. Avoid using 'auto_ptr' since it is deprecated.