Re: Cleanup Technique

Hi All,

Often in C++ code I find myself having to allocate character arrays to
pass back to callers for error codes, or as topic/data in message
passing/observer type scenarios (When having them on the heap is
necessary to avoid them going out of scope before something else, like
another thread, has had a chance to process them). What I wanted was a
neat way to keep track of these allocations within the class, and
clean them all up nicely, without too much overhead.

What I hit upon is based on the following ideas:
1. std::string is just 'better' than char*, so use it!
2. std::vector, in its destructor, will attempt to destroy each object
within it.

So what I did was to declare a vector of std::strings inside
'SomeClass' - a class which needs to keep track of a lot of strings it
creates during its adventures:

class SomeClass
{
...
private:
    std::vector<std::string> m_stringvector;
...
}

And then, in the body of some method in SomeClass:

std::string* s1 = new std::string();
std::string* s2 = new std::string();
//do something with s1 and s2 - i.e. set them and pass them back to a
function
//now add them to the class vector to keep track of them:
m_stringvector.push_back(*s1);
m_stringvector.push_back(*s2);