Okay, surely in your constructor/destructor/overridden = operator you can deallocate the memory as you go?
Wherever the myObject object comes from, it must have an area of view (even if it's the lifetime of the program) at which point it's destroyed and you can run your free functions on the necessary areas of allocated memory.
If the toString function returns a pointer to a char* from the myObject private variables, then the memory is later deallocated by the myObject destructor. If it creates a local variable and passes that back then the memory is already deallocated the second the toString function ends. You then have a string inside the String object you were writing to but that's deallocated by it's own destructor.
Where's the problem, unless I've missed the point.

Ok, I'm sorry my last post was confusing. I didn't quite understand what you said, but hopefully this will clarify things. Take this pseudocode example:

class String {private:  /* Pointer to the null-terminated     string. */  char *stringData;public:  /* Makes a copy of source, points     stringData to it. */  String(const char *source);  /* Frees stringData, if it's non-null. */  ~String();  /* Prints stringData to the screen. */  printMe();};String Test() {  String temp("hello.");  // Do some stuff with temp here.  return temp;}void main() {  Test().printMe();}

Now, the problem with this is that temp's destructor will be called when the Test() function exits, thereby destroying the stringData, so when Test().printMe() is called in the main() function, the stringData of the String object has been freed already. I suppose I could make my own copy constructor for the String class that does a deep copy of the object instead of a shallow copy, but this means the entire stringData would have to be copied when Test() returns temp, which would slow things down. I suppose I could just do that, but is there any easier way to do this (that doesn't involve copying the entire string with the copy constructor) that I'm missing?

So your trying to pass back a local variable which is a class, which is destroyed on exit from the function Test.
Okay, surely if you want to print the string you merely put the variable in the main function or have the printMe call in the Test function. What you appear to be doing is the equivilant of creating a local struct or array and trying to pass it back through the return value.
This is a dangerous practice, which normally works because the area of memory is freed but not overwritten in the following steps between you returning and trying to use it.
So, unless your destructor physically changes the memory address you're returning, then it should still contain the correct info to be printed.
Not guaranteed though and a better way would be to have Test using a String* temp and using
temp = new String("hello.")
returning that and deleting it later, perhaps with a printMeAndDelete function.
I don't see the need to do what you're trying to do, but then I can't see an answer either.
If I knew why you were trying to do it that might make it easier to understand.

I have often had the same problem. What I ended up doing was making an array of global values that have their pointers returned with the function, so that when it ends, the value is still there. All the function needs to do is figure out which one is free for use and use it.

Another more dangerous (most likely suicidal) practice would be to gave a single global pointer that points to a new string each time the function returns. As long as you hang on to the pointer before it is overwritten with the next new call, you will be fine. If you don't hang onto it and don't delete it, you will end up with a pretty bad memory leak.

I don't know if it has any bearing on the more recent posts, but in the first post of this thread, it seemed to me like you wanted a way to parse and combine strings. To parse them, you can use a header I wrote, and to combine strings, use sprintf(). It can be found in either stdio.h or stdlib.h, I don't remember which. If you want the string parsing / wordcounting / chatterbot making header file, go to my website at: www.trak.to/rdp

All I can say is: exactly on the money. A copy constructor that really makes a second copy of the character data will work fine. If you need a light-weight string class, I can send you one. Just email me.

- Splat

Wouldn't the standard template library (STL)

#include

allow you to work with strings in C++ and handle memory allocation and deallocation ?

There is no need for a copy constructor. Replace the line

String temp("hello");

with

String *temp = new String("hello");

using new means that it is created on the heap. As such will not get deleted on exit of the function. This in itself is bad practice as you will have to expicitly call delete at some point in your program. You can get around this by creating a smart pointer class (i.e. a wrapper for standard pointers which will monitor all pointers and will dealocate memory off the heap when the program terminates). SP`s are simpleish to code, its just a case of overloading * and -> then making sure you monitor all new, copy and equateing operators and dealocate them.

giz a email if you want to know more!

hamfdeath@yahoo.com