Question about abort(), assert(), exit(), what is best for shared_ptr?

[magneonx]

Hello, in my game I have this memory model by which I compose a grid and store the data structure Tile dynamically with shared_ptr in a 2d vector.

There are times that in my game there are certain routines that have to be done and if that routine fails. My game exits. I use exit() function to do this.

How can I guarantee that all resources are freed and released?

I haven't tried to read the C++11 manual for this, and even if I do, I might not understand it very well.
Which one should I use best for my situation?

Thanks

[OniLinkPlus]

exit() will likely work best, as it tries to exit as cleanly as possible. But I doubt you HAVE to abort the entire program. That seems... extremely draconian. Are you sure there isn't another way to handle any errors?

[magneonx]

The only other way I think of is to make sure all the routine finishes all. I have to guarantee that. I was just wondering. I just getting a little bit of conservative on this part of my code. Well, I think this is something I have to think about ... again.

[binary1248]

From C++ standard:

[[noreturn]] void abort(void) noexcept;
The function abort() has additional behavior in this International Standard:
— The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling functions passed to atexit() (3.6.3).

The function exit() has additional behavior in this International Standard:
— First, objects with thread storage duration and associated with the current thread are destroyed. Next, objects with static storage duration are destroyed and functions registered by calling atexit are called. See 3.6.3 for the order of destructions and calls. (Automatic objects are not destroyed as a result of calling exit().) If control leaves a registered function called by exit because the function does not provide a handler for a thrown exception, std::terminate() shall be called (15.5.1).
— Next, all open C streams (as mediated by the function signatures declared in <cstdio>) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling tmpfile() are removed.
— Finally, control is returned to the host environment. If status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.

From C standard:

Synopsis
#include <assert.h>
void assert(scalar expression);
Description
The assert macro puts diagnostic tests into programs; it expands to a void expression. When it is executed, if expression (which shall have a scalar type) is false (that is, compares equal to 0), the assert macro writes information about the particular call that failed (including the text of the argument, the name of the source file, the source line number, and the name of the enclosing function — the latter are respectively the values of the preprocessing macros __FILE__ and __LINE__ and of the identifier __func__) on the standard error stream in an implementation-defined format. It then calls the abort function.
Returns
The assert macro returns no value.

Since none of these functions destroys automatic objects, std::shared_ptrs will always leak when terminating your application using them. Exiting your application using these functions is not a healthy practice anyway, and I would recommend looking for another way to terminate your application cleanly instead of relying on exit().

[OniLinkPlus]

binary, I was under the impression that exit() calls the destructors to all currently created objects. In fact, that seems to be the first bullet point for exit(). And I was also under the impression that std::shared_ptr cleans up the dynamically allocated memory in the destructor when it's the last shared pointer to that memory. So shouldn't exit() clean up the pointers?

[binary1248]

Automatic objects are not destroyed as a result of calling exit().

Automatic meaning automatic lifetime i.e. all variables declared within a block of code and end up on the stack as opposed to free store. Because local variables aren't destroyed, any std::shared_ptr that exists as a local variable or part of another object that exists solely on the stack will leak since their destructors will not be called by exit(). The only objects that are destroyed are those with thread storage duration i.e. sf::ThreadLocalPtr and objects with static storage duration i.e. static variables and globals. exit() and abort() can be seen as anti-RAII and are just relics from C times that really have nothing to look for in modern C++ code.

[Nexus]

Hello, in my game I have this memory model by which I compose a grid and store the data structure Tile dynamically with shared_ptr in a 2d vector.

Why do you need std::shared_ptr<T>, as opposed to T or std::unique_ptr<T>?

There are times that in my game there are certain routines that have to be done and if that routine fails. My game exits. I use exit() function to do this.

How can I guarantee that all resources are freed and released?

By not using std::exit() (remember, all C++ standard library functions are in namespace std, even if compilers aren't very strict here).

You have to propagate the error back to main() properly. Either by multiple return paths or -- in exceptional cases -- using exceptions.