What is a memory leak

[shaun roe]

I'm reading about exception safety and wondering when I need to bother,
and when a program can crash without hogging some resource. If I am only
talking about memory allocated during a program, then I can see that

(dodgy top-of-head code follows)

int main{
while (true){
MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
}

return 0;
}
.........

will fill up memory until something breaks and it crashes, lets say on
the 1000th iteration

but what about:

int main(){

MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
exit(1);

}

Does it follow that I can only run this program 1000 times? Or are all
the resources released once it exits? If the exit is replaced by some
exception-generating code, is there any difference?

cheers

shaun

[Victor Bazarov]

shaun roe wrote:

I'm reading about exception safety and wondering when I need to
bother, and when a program can crash without hogging some resource.

Is this a well-masqueraded homework? Looks like it...

If I am only talking about memory allocated during a program, then I
can see that

(dodgy top-of-head code follows)

int main{
while (true){
MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
}

return 0;
}
........

will fill up memory until something breaks and it crashes, lets say on
the 1000th iteration

but what about:

int main(){

MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
exit(1);

}

Does it follow that I can only run this program 1000 times?

Usually not.

Or are all
the resources released once it exits? If the exit is replaced by some
exception-generating code, is there any difference?

It highly depends on the execution environment. Some free program
memory once program finishes and return it to the available memory,
some don't.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Jon Clements]

shaun roe wrote:

I'm reading about exception safety and wondering when I need to bother,
and when a program can crash without hogging some resource. If I am only
talking about memory allocated during a program, then I can see that

(dodgy top-of-head code follows)

int main{
while (true){
MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
}

Just a little bit of dodgy declaration of main :)

>
return 0;
}
........

The default behaviour of new is to throw a badalloc when memory
allocation fails. Therefore, return 0 will never happen, and your
program will exit with an unhandled exception. When it does that I
think the deconstructors for objects are called as part of the exit
handler (I could well be wrong). However, most likely your OS will
release resources acquired otherwise.

>
will fill up memory until something breaks and it crashes, lets say on
the 1000th iteration

but what about:

int main(){

MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
exit(1);

}

Does it follow that I can only run this program 1000 times? Or are all
the resources released once it exits? If the exit is replaced by some
exception-generating code, is there any difference?

Generally, you want to be in a position where your program releases
resources as it no longer requires them. However, on a return from
main, or exit() or unhandled exception, they are generally released by
the OS - if the program doesn't do that 'on it's way out...'

Jon.

[Kai-Uwe Bux]

shaun roe wrote:

I'm reading about exception safety and wondering when I need to bother,
and when a program can crash without hogging some resource. If I am only
talking about memory allocated during a program, then I can see that

(dodgy top-of-head code follows)

int main{
while (true){
MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
}

return 0;
}
........

will fill up memory until something breaks and it crashes, lets say on
the 1000th iteration

but what about:

int main(){

MemoryHoggingObject * myObjectPtr = new MemoryHoggingObject;
exit(1);

}

Does it follow that I can only run this program 1000 times?

No.

Or are all the resources released once it exits?

The C++ standard says nothing about obtaining nor returning memory to the
OS. It refrains (wisely?) from making such requirements about the support
offered by the computation environment. However, I do not know of any OS
that will not reclaim resources upon termination of a program.

If the exit is replaced by some exception-generating code, is there any
difference?

Not in terms of the standard. Even if you call delete() for all the pointers
you new()-ed in your program, there is no guarantee that memory will be
returned to the OS.
Best

Kai-Uwe Bux

[Gernot Frisch]

Which of these lines gives a _memory leak_ ;)

char* p1, *p2, *p3;
p1 = new char[5];
p2 = (char*) &p2;
p3 = (char*) "Hello";
delete p1[];
delete p2[];
delete p3[];

[Victor Bazarov]

Gernot Frisch wrote:

Which of these lines gives a _memory leak_ ;)

char* p1, *p2, *p3;
p1 = new char[5];
p2 = (char*) &p2;
p3 = (char*) "Hello";
delete p1[];
delete p2[];
delete p3[];

None. The program is ill-formed.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ron Natalie]

Gernot Frisch wrote:

Which of these lines gives a _memory leak_ ;)

char* p1, *p2, *p3;
p1 = new char[5];
p2 = (char*) &p2;
p3 = (char*) "Hello";
delete p1[];

ill-formed. but delete[] p1 would be fine.

delete p2[];

ill-formed, delete [] p2; would be illegal because the value
in p2 was not allocated by new.

delete p3[];

ill-formed. delete [] p3 would be illegal because the value
was not allocated by new.

None of these would cause a memory leak.

[Victor Bazarov]

Ron Natalie wrote:

Gernot Frisch wrote:

>Which of these lines gives a _memory leak_ ;)

char* p1, *p2, *p3;
p1 = new char[5];
p2 = (char*) &p2;
p3 = (char*) "Hello";
delete p1[];

ill-formed. but delete[] p1 would be fine.

> delete p2[];

ill-formed, delete [] p2; would be illegal because the value
in p2 was not allocated by new.

It's also illegal because the address of 'p2' stored in 'p2'
though a C-style cast (equivalent to 'reinterpret_cast' here)
is used in some way other than to convert back.

>

> delete p3[];

ill-formed. delete [] p3 would be illegal because the value
was not allocated by new.

None of these would cause a memory leak.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ron Natalie]

Victor Bazarov wrote:

Ron Natalie wrote:

>Gernot Frisch wrote:

>>Which of these lines gives a _memory leak_ ;)

char* p1, *p2, *p3;
p1 = new char[5];
p2 = (char*) &p2;
p3 = (char*) "Hello";
delete p1[];

ill-formed. but delete[] p1 would be fine.

>> delete p2[];

ill-formed, delete [] p2; would be illegal because the value
in p2 was not allocated by new.

It's also illegal because the address of 'p2' stored in 'p2'
though a C-style cast (equivalent to 'reinterpret_cast' here)
is used in some way other than to convert back.

Yep, I caught that too, too many things wrong.
Note that the following is a better demonstration of
that concept:

p2 = (char*) new char*[5];
delete [] p2;

[Kevin Handy]

Kai-Uwe Bux wrote:

>
The C++ standard says nothing about obtaining nor returning memory to the
OS. It refrains (wisely?) from making such requirements about the support
offered by the computation environment. However, I do not know of any OS
that will not reclaim resources upon termination of a program.

I believe Windows 3.* failed to reclaim memory.
At least that is what I was told by people who
wrote programs for it.

----== Posted via Newsfeeds.Com - Unlimited-Unrestricted-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[Victor Bazarov]

Kevin Handy wrote:

Kai-Uwe Bux wrote:

>>
The C++ standard says nothing about obtaining nor returning memory
to the OS. It refrains (wisely?) from making such requirements about
the support offered by the computation environment. However, I do
not know of any OS that will not reclaim resources upon termination
of a program.

I believe Windows 3.* failed to reclaim memory.
At least that is what I was told by people who
wrote programs for it.

I am not sure Windows 3.* qualify as real OSes... Do they? OT, of course.

[Kai-Uwe Bux]

Victor Bazarov wrote:

Kevin Handy wrote:

>Kai-Uwe Bux wrote:

>>>
The C++ standard says nothing about obtaining nor returning memory
to the OS. It refrains (wisely?) from making such requirements about
the support offered by the computation environment. However, I do
not know of any OS that will not reclaim resources upon termination
of a program.

I believe Windows 3.* failed to reclaim memory.
At least that is what I was told by people who
wrote programs for it.

I was a happy user of MS-DOS until Microsoft discontinued support. I never
had any trouble with DOS not reclaiming the little memory there was: and
not all my programs were clean (however, maybe by Modula-2 compiler
inserted some clean-up code behind my back).

I cannot say anything about Windows, though: I never used it.

I am not sure Windows 3.* qualify as real OSes... Do they? OT, of
course.

Really? If I recall correctly, the OS was MS-DOS and Windows 3.* was just a
DOS program.
Best

Kai-Uwe Bux

[Bo Persson]

"Kai-Uwe Bux" <jk********@gmx.netskrev i meddelandet
news:e9**********@murdoch.acc.Virginia.EDU...

Victor Bazarov wrote:

>Kevin Handy wrote:

>>Kai-Uwe Bux wrote:
The C++ standard says nothing about obtaining nor returning
memory
to the OS. It refrains (wisely?) from making such requirements
about
the support offered by the computation environment. However, I do
not know of any OS that will not reclaim resources upon
termination
of a program.

I believe Windows 3.* failed to reclaim memory.
At least that is what I was told by people who
wrote programs for it.

I was a happy user of MS-DOS until Microsoft discontinued support. I
never
had any trouble with DOS not reclaiming the little memory there was:
and
not all my programs were clean

That's because the DOS "memory management" worked backwards. :-)

The currently running program had access to all free memory by
default. (All memory actually, as it was unprotected).

To keep some part after the program terminated, it had to explicitly
register an address range as reserved. Otherwise the next program
would get exactly the same free memory. DOS didn't have to do
anything.

>(however, maybe by Modula-2 compiler
inserted some clean-up code behind my back).

Only by calling terminate instead of terminate-and-stay-resident.
Bo Persson