zl2k wrote:
hi,
When I considered about preventing memory leaking, the method came up
to my mind is using boost smart pointer if possible (use stl::vector
instead of type[], use smart pointer whenever declare an instance of
class). With the container of STL, this may often result in a vector of
smart pointers, or a smart pointer of STL container. Am I making things
too complicated or this is an usual implementation? Thanks in advance.
zl2k
Are you making an over-complication? It depends. Memory management is a
complex problem and there isn't a single simple solution that addresses
every aspect.
You don't have to use a smart pointer to create every object. If the
object life time is scope-controlled, use a local variable:
void log_event(const std::string& path, event e)
{
ofstream output(path); // scope-controlled
output << e;
}
If the ownership of the object is well defined, use an auto_ptr (which
is not a honest-to-God smart pointer:)
std::auto_ptr<xml_doc> load_xml_doc(const std::string& path)
{
std::auto_ptr<xml_doc> pdoc(new xml_doc);
pdoc->load_document(path);
return pdoc; // transfer of ownership
}
If you don't need polymorphism or shallow copy, use a container of that
type instead of one of pointers to that type.
template <typename T>
class matrix
{
std::deque<T> storage;
// not std::deque<shared_ptr<T> > storage;
// ...
};
And last but not least, if the class should behave like a value type,
make it so. This is typically done by encapsulating the smart pointer:
class string
{
struct storage_type
{
std::vector<char> characters;
// ...
};
shared_ptr<storage_type> storage;
// ...
}
string operator+ (const string& a, const string& b)
{
// use of string is as intuitive value types
string c = a;
c += b;
return c;
}
Regards,
Ben
