memory leak?

[TechCrazy]

1 int longFunction() {
2 string x1 ("eee");
3 string x2 = x1;
4 x2 = "fff";

....

Please correct me if any of this is wrong:

At the end of line 3, x2 will have some memory M associated with it (on
the heap/ stack - depends on implementation of copy str of string.

What happens to M at the end of line 4? Apologize if this is a stupid
question.

[Torsten Mueller]

"TechCrazy" <Te*******@hotpop.com> schrieb:

1 int longFunction() {
2 string x1 ("eee");
3 string x2 = x1;
4 x2 = "fff";

What happens to M at the end of line 4? Apologize if this is a
stupid question.

If you mean std::string there is no memory leak. The class is
responsible for managing the memory needed by the internal buffer.

In this case the object x1 exists still at the end of line 4. You have
just two local string objects. Both of them will be deleted at the end
of the function.

T.M.

[vindhya]

x2 will have a new set of memory for new string.
Try to print the value of x1 and x2 after Line#4. you will find the
result.

[benben]

"TechCrazy" <Te*******@hotpop.com> wrote in message
news:11*********************@z14g2000cwz.googlegro ups.com...

1 int longFunction() {
2 string x1 ("eee");
3 string x2 = x1;
4 x2 = "fff";

....

Please correct me if any of this is wrong:

At the end of line 3, x2 will have some memory M associated with it (on
the heap/ stack - depends on implementation of copy str of string.

both x1 and x2 are allocated on the stack, although they may also manage
some of their contents on the heap. But don't bother with implementation
detail that you are not supposed to know.
What happens to M at the end of line 4? Apologize if this is a stupid
question.

This is a valid question!

Stack memory will persist untill the objects run out of scope (in this case,
untill the function returns.)

Regards,
Ben

[Karl Heinz Buchegger]

TechCrazy wrote:

1 int longFunction() {
2 string x1 ("eee");
3 string x2 = x1;
4 x2 = "fff";

....

Please correct me if any of this is wrong:

At the end of line 3, x2 will have some memory M associated with it (on
the heap/ stack - depends on implementation of copy str of string.
( assuming with 'string' you mean 'std::string' )

You are right: it depends on the actual implementation.
But conceptually you are wrong.
x2 has its own memory. And this memory is assigned the very same contents
as x1 gas. x2 and x1 contain the same string "eee". But other then that they
have nothing in common.

What happens to M at the end of line 4? Apologize if this is a stupid
question.

Nothing special. The content of x2 is changed to contain "fff".

Even *iff* your string class uses a form of "reference counted, copy on write"
memory management, all will be done under the hood, such that conceptually you
will note no difference to the above said: For the programmer each string
object holds its own memory, where it stores the characters.

--
Karl Heinz Buchegger
kb******@gascad.at

[benben]

"benben" <be******@hotmail.com> wrote in message
news:42***********************@news.optusnet.com.a u...

"TechCrazy" <Te*******@hotpop.com> wrote in message
news:11*********************@z14g2000cwz.googlegro ups.com...

1 int longFunction() {
2 string x1 ("eee");
3 string x2 = x1;
4 x2 = "fff";

....

More into detail:

After line 2, some memory m1 (of the size of sizeof(string)) is allocated
from the stack for x1; The object x1, during construction, might allocat
some memory M1 from elsewhere than the stack, most likely from the heap, of
size dependent on the implementation detail.

After line 3, some memory m2 (of the size of sizeof(string)) is allocated
from the stack for x2; Like wise, the object x2, during construction, might
allocat some memory M2 from elsewhere than the stack, most likely from the
heap, of size dependent on the implementation detail.

The memory blocks m1, M1, m2, M2 persist during the execution of subsequent
lines in the function.

When the objects run out of scope, i.e. when the function returns:

x2 is destroyed and m2 is freed. If "string" is a good implementation then
M2 is also freed during destruction of x2; then
x1 is destroyed and m1 is freed. Likewise M1 is also freed during
destruction of x1.

Regards,
Ben

[Bart]

TechCrazy wrote:

1 int longFunction() {
2 string x1 ("eee");
"eee" is allocated in static memory until the end of the program (has
static storage)
x1 is allocated on the stack (has automatic storage)
string's constructor is invoked
"eee" is copied to an internal buffer

Note: Only the string object is assigned on the stack. The internal
buffer may be allocated differently.
3 string x2 = x1;
x2 is allocated on the stack (has automatic storage)
x2 default constructor is invoked
string assigment operator is invoked
the _content_ of x1 is copied to x2
4 x2 = "fff";
"fff" is allocated in static memory (has static storage)
string's assignment operator is called
"fff" is copied to x2, replacing the _content_ of the internal
buffer
....

At the end of the current scope:

x2 destructor is invoked
internal buffer is released
x1 destructor is invoked
internal buffer is released

This is not a memory leak. Each object manages its own internal buffer
and is responsible for copying contents.

[Jonathan Mcdougall]

>> 3 string x2 = x1;

x2 is allocated on the stack (has automatic storage)
x2 default constructor is invoked
string assigment operator is invoked
the _content_ of x1 is copied to x2

No. The copy constructor is called. What the compiler really does is

string x2(x1);

The assignment operator is never called in initializations.
Jonathan

[Bart]

Jonathan Mcdougall wrote:

3 string x2 = x1;

x2 is allocated on the stack (has automatic storage)
x2 default constructor is invoked
string assigment operator is invoked
the _content_ of x1 is copied to x2

No. The copy constructor is called. What the compiler really does is

string x2(x1);

The assignment operator is never called in initializations.

Yeah, sorry about that. I know about it but my eyes were already
looking at the next statement while typing. ;)