Hi, never bothered much with memory management in C++ except when it was already in the code. I simply write my variables array etc without worrying about all that deallocating allocating stuff. I'm having a little bit of an issue understanding when it is necessary and when it is not. Now supposedly smart pointers are supposed to a handy blanket solution to C++ memory issues so that you don't have worry about anything else besides them right? Can somebody point me to some easy to understand samples of smart pointers specifically aimed toward someone who's trying to understand when they're necessary?
memory management examples?
Smart pointers aren't a magical fix all solution.
Common advice is to use stack allocation where you can, and where it makes sense. Only do heap allocation when it will be useful(i.e. you need to destroy and create things often or with strange lifetime that couldn't be controlled easily through function or object scoping.)
Smart pointers are basically just a simple object wrapped around "c-style" pointers that controls the lifetime of the memory automagically. For example a reference counted pointer like shared_ptr essentially just keeps track of how many references are live to the allocated memory, then just calls delete when the last reference dies.
They're mainly just considered good practice because they're a minor performance cost in order to more or less automate management of the objects for you. Though there are considerations still like making sure each reference can be destroyed and you aren't allocating bulk amounts of smart pointers in a tight loop(or something like that, which might have a visible performance impact.)
Common advice is to use stack allocation where you can, and where it makes sense. Only do heap allocation when it will be useful(i.e. you need to destroy and create things often or with strange lifetime that couldn't be controlled easily through function or object scoping.)
Smart pointers are basically just a simple object wrapped around "c-style" pointers that controls the lifetime of the memory automagically. For example a reference counted pointer like shared_ptr essentially just keeps track of how many references are live to the allocated memory, then just calls delete when the last reference dies.
They're mainly just considered good practice because they're a minor performance cost in order to more or less automate management of the objects for you. Though there are considerations still like making sure each reference can be destroyed and you aren't allocating bulk amounts of smart pointers in a tight loop(or something like that, which might have a visible performance impact.)
Common advice is to use stack allocation where you can, and where it makes sense. Only do heap allocation when it will be useful(i.e. you need to destroy and create things often or with strange lifetime that couldn't be controlled easily through function or object scoping.)
When you need to create and destroy things often you will want to stay away from the heap as dynamic memory allocation is generally slow. Keeping an array arround of live and dead objects is generally faster, especially when reusing the dead objects again.
See "Working with Dynamic Memory in C++":
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
