Memory leaking..

[gNash]

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * strclear(const char *str)
{
char *string;
string=(char *)malloc(strlen(str)+1);
strcpy(string,str);
return string;
}
int main()
{
char *str="Five pineapples";
char *string;
string=strclear(str);
printf ("The string is %s\n",string);
free(string);
return 0;
}

Please refer above program for my question..

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

3. Could you any one please tell me how can i free the memory which
has been allocated dynamically by another function. without using any
globel variable?

Please help me ..
Thanks in advance,
Ganesh

[Ian Collins]

gNash wrote:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * strclear(const char *str)
{
char *string;
string=(char *)malloc(strlen(str)+1);

Please drop the cast and you may as well initialise string where it is
declared.

strcpy(string,str);
return string;
}
int main()
{
char *str="Five pineapples";
char *string;
string=strclear(str);
printf ("The string is %s\n",string);
free(string);
return 0;
}

Please refer above program for my question..

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

No.

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

It is freed.

--
Ian Collins.

[Richard Heathfield]

gNash said:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * strclear(const char *str)
{
char *string;
string=(char *)malloc(strlen(str)+1);
strcpy(string,str);
return string;
}

Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */
}
return string;
}

[1] - str followed by a-z is "reserved for external use" by the
implementation, so don't use it in your own function names.
[2] - nesting the strlen in the malloc is fine, but if you choose to go the
memcpy route (see [5]), you'll want to cache this value.
[3] - no need to cast the return value of malloc, although *in this case*
your cast did no actual damage concealment, since you remembered to
#include <stdlib.h>, so no harm done on this occasion.
[4] - malloc can fail. Check that it doesn't before trusting the result.
[5] - if logic were any guide, it would make sense for memcpy to perform
the copy faster than strcpy. In practice, it seems to depend on the
implementation and to some extent on the length of the string. So this and
the preparatory step [2], above, are the bits that I'm simply mentioning
for consideration, rather than positively recommending.

int main()
{
char *str="Five pineapples";
char *string;
string=strclear(str);

See [1] above.

printf ("The string is %s\n",string);

Check for NULL:

if(string != NULL)
{
printf("The string is %s\n", string);
free(string);
}

<snip>

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

The program you showed has no leak.

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

The program has no mechanism to detect whether that claim is correct.

3. Could you any one please tell me how can i free the memory which
has been allocated dynamically by another function. without using any
globel variable?

You already know how to do it. You've already done it. If valgrind is
behaving as you say on the program you show, then valgrind is wrong or
your implementation is sub-optimal.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[gNash]

On Nov 15, 12:04 pm, Ian Collins <[e-mail]:

gNash wrote:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * strclear(const char *str)
{
char *string;
string=(char *)malloc(strlen(str)+1);

Please drop the cast and you may as well initialise string where it is
declared.

strcpy(string,str);
return string;
}

int main()
{
char *str="Five pineapples";
char *string;
string=strclear(str);
printf ("The string is %s\n",string);
free(string);
return 0;
}

Please refer above program for my question..

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

No.

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

It is freed.

--
Ian Collins.

Thankyou Ian Collins.. but i not getting message from valgrind as "all
heap memory are freed " it is saying "16 bytes are still reachable "
what it mean?

Please explain me..

[Ian Collins]

gNash wrote:

On Nov 15, 12:04 pm, Ian Collins <[e-mail]:

>--
Ian Collins.

*Please* don't quote signatures.

>
Thankyou Ian Collins.. but i not getting message from valgrind as "all
heap memory are freed " it is saying "16 bytes are still reachable "
what it mean?

Please explain me..

I've no idea, never having used valgrind. All I can say is it is wrong.

--
Ian Collins.

[gNash]

On Nov 15, 12:14 pm, Richard Heathfield <[e-mail]:

gNash said:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char * strclear(const char *str)
{
char *string;
string=(char *)malloc(strlen(str)+1);
strcpy(string,str);
return string;
}

Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */
}
return string;

}

[1] - str followed by a-z is "reserved for external use" by the
implementation, so don't use it in your own function names.
[2] - nesting the strlen in the malloc is fine, but if you choose to go the
memcpy route (see [5]), you'll want to cache this value.
[3] - no need to cast the return value of malloc, although *in this case*
your cast did no actual damage concealment, since you remembered to
#include <stdlib.h>, so no harm done on this occasion.
[4] - malloc can fail. Check that it doesn't before trusting the result.
[5] - if logic were any guide, it would make sense for memcpy to perform
the copy faster than strcpy. In practice, it seems to depend on the
implementation and to some extent on the length of the string. So this and
the preparatory step [2], above, are the bits that I'm simply mentioning
for consideration, rather than positively recommending.

int main()
{
char *str="Five pineapples";
char *string;
string=strclear(str);

See [1] above.

printf ("The string is %s\n",string);

Check for NULL:

if(string != NULL)
{
printf("The string is %s\n", string);
free(string);

}

<snip>

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

The program you showed has no leak.

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

The program has no mechanism to detect whether that claim is correct.

3. Could you any one please tell me how can i free the memory which
has been allocated dynamically by another function. without using any
globel variable?

You already know how to do it. You've already done it. If valgrind is
behaving as you say on the program you show, then valgrind is wrong or
your implementation is sub-optimal.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

thanks a lot Mr. Richared Heathfield. thanks for your information for
[1] too.

[Nick Keighley]

Richard Heathfield wrote:

<snip>

Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */

where does string get terminated?

}
return string;
}

<snip>

If I want to copy a string I use strcpy(). That way I avoid failing to
put the nul terminator in...
--
Nick Keighley

[Mark Bluemel]

Nick Keighley wrote:

Richard Heathfield wrote:

<snip>

>Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */

where does string get terminated?

What is the value of len?

[Nick Keighley]

Mark Bluemel wrote:

Nick Keighley wrote:

Richard Heathfield wrote:

<snip>

Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */

where does string get terminated?

What is the value of len?

brain fart. it wasn't the value of len that fooled me,
I failed to realise that its copying an already correctly
terminated string.

And I realised that about 1ns *after* I hit the post button.

<mumbleI *still* think strcpy() is better </mumble>
--
Nick Keighley

[Chris Dollin]

Nick Keighley wrote:

Richard Heathfield wrote:

<snip>

>Better (or at least different!):

char *clearstr(const char *str) /* [1] */
{
size_t len = strlen(str) + 1; /* [2] */
char *string = malloc(len); /* [3] */
if(string != NULL) /* [4] */
{
memcpy(string, str, len); /* [5] */

where does string get terminated?

In the `memcpy`, which copies `len` bytes, where `len` is /one more than/
the length of the string and hence includes the nul byte. This is also
why the `malloc` allocates enough space for the entire terminated string.

--
Chris "make room! make room!" Dollin

Hewlett-Packard Limited Cain Road, Bracknell, registered no:
registered office: Berks RG12 1HN 690597 England

[Chris Dollin]

Nick Keighley wrote:

And I realised that about 1ns *after* I hit the post button.

Ha! I realise things like that /as I press the button/!

I win! Wait ... that's a good thing, right? (fx:post) Oops.

--
Chris "really really /really/ fast heartbeat" Dollin

Hewlett-Packard Limited registered office: Cain Road, Bracknell,
registered no: 690597 England Berks RG12 1HN

[dSpam]

On 15 Nov., 08:20, Ian Collins <[e-mail]:

gNash wrote:

what it mean?

I've no idea, never having used valgrind. All I can say is it is wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

[Ben Bacarisse]

gNash <ga**********@gmail.comwrites:

<snip program>

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

No, and if I copy, compile and run your code on my system, valgrind
says:

==7667== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 11 from 1)
==7667== malloc/free: in use at exit: 0 bytes in 0 blocks.
==7667== malloc/free: 1 allocs, 1 frees, 16 bytes allocated.
==7667== For counts of detected errors, rerun with: -v
==7667== All heap blocks were freed -- no leaks are possible.

so you are chasing a phantom problem. There is none.

--
Ben.

[Richard]

"dS***@arcor.de" <dS***@arcor.dewrites:

On 15 Nov., 08:20, Ian Collins <[e-mail]:

>gNash wrote:

what it mean?

I've no idea, never having used valgrind. All I can say is it is wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

He was referring to the non pertinent parts of the program being "wrong"
- well not standard C. The cast did nothing wrong with regard to the
rest of the program. The moving of the malloc to the declaration line
was equally as non contributory to the question but simply made for
tighter cleaner code.

[Kenneth Brody]

gNash wrote:

>
On Nov 15, 12:04 pm, Ian Collins <[e-mail]:

gNash wrote:

[... snip code ...]

Please refer above program for my question..

1. When i run with valgrid i got message as "16 byts in 1 block still
reachable". I think memory is leaking in the program. Am i right?

No.

2. Since i assign value of heap memory starting address and calling
free it is not freed.. why?

It is freed.

Thankyou Ian Collins.. but i not getting message from valgrind as "all
heap memory are freed " it is saying "16 bytes are still reachable "
what it mean?

Please explain me..

I've never used valgrind, but...

The code you posted frees everything that it mallocs.

Is it possible that the runtime startup code allocated something
that wasn't freed, and it's this block that's being reported?

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Jack Klein]

On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "dS***@arcor.de"
<dS***@arcor.dewrote in comp.lang.c:

On 15 Nov., 08:20, Ian Collins <[e-mail]:

gNash wrote:

what it mean?

I've no idea, never having used valgrind. All I can say is it is wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can. As far as the C language is concerned, and that's the
only thing that counts here, free() was properly called on a pointer
returned from malloc(). Since the free() function cannot fail if
called correctly, as it is in this case, the memory was freed.

Neither Ian nor I have to know much about valgrind, the Magna Carta,
or a Comcast commercial featuring the Slowskys, to state that if they
say this memory was not freed, the are wrong.

The memory was freed in the only context that matters in this group.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[Pietro Cerutti]

Richard Heathfield wrote:

[5] - if logic were any guide, it would make sense for memcpy to perform
the copy faster than strcpy.

Which logic would say so?
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp

[Richard Heathfield]

Pietro Cerutti <gahr_AT_gahr_DOT_ch_DO_NOT_SPAMsaid:

Richard Heathfield wrote:

>[5] - if logic were any guide, it would make sense for memcpy to perform
the copy faster than strcpy.

Which logic would say so?

With memcpy, you know the length in advance, so you can perform
optimisations such as copying four, eight, or even more bytes at a time,
whereas with strcpy that's a lot harder because you have to check for the
null terminator all the time. So you'd *expect* memcpy to be faster. In
practice, it need not be, and sometimes isn't.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Philip Potter]

Jack Klein wrote:

On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "dS***@arcor.de"
<dS***@arcor.dewrote in comp.lang.c:

>On 15 Nov., 08:20, Ian Collins <[e-mail]:

>>gNash wrote:
what it mean?
I've no idea, never having used valgrind. All I can say is it is wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can. As far as the C language is concerned, and that's the
only thing that counts here, free() was properly called on a pointer
returned from malloc(). Since the free() function cannot fail if
called correctly, as it is in this case, the memory was freed.

Neither Ian nor I have to know much about valgrind, the Magna Carta,
or a Comcast commercial featuring the Slowskys, to state that if they
say this memory was not freed, the are wrong.

The memory was freed in the only context that matters in this group.

But it didn't say it wasn't freed, it said it was "still reachable".
That means "No memory leak" in valgrind terms.

--
Philip Potter pgp <atdoc.ic.ac.uk

[dSpam]

On 16 Nov., 04:44, Jack Klein <[e-mail]:

On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "[e-mail]"
<[e-mail] in comp.lang.c:

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can. As far as the C language is concerned, ...

May I suggest that you think this over? I maintain that my statement
above is true in every context, be it the C language or anything else.

[Richard Heathfield]

Jack Klein said:

On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "dS***@arcor.de"
<dS***@arcor.dewrote in comp.lang.c:

>On 15 Nov., 08:20, Ian Collins <[e-mail]:

gNash wrote:
what it mean?

I've no idea, never having used valgrind. All I can say is it is
wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can.

No, he can't.

As far as the C language is concerned, and that's the
only thing that counts here, free() was properly called on a pointer
returned from malloc(). Since the free() function cannot fail if
called correctly, as it is in this case, the memory was freed.

Indeed.

Neither Ian nor I have to know much about valgrind, the Magna Carta,
or a Comcast commercial featuring the Slowskys, to state that if they
say this memory was not freed, the are wrong.

So what you're really saying is that, if you *do* know what something
means, you can know that it is wrong.

The memory was freed in the only context that matters in this group.

Nobody disputes that (AFAIK!).

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Chris Dollin]

dS***@arcor.de wrote:

On 16 Nov., 04:44, Jack Klein <[e-mail]:

>On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "[e-mail]"
<[e-mail] in comp.lang.c:

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can. As far as the C language is concerned, ...

May I suggest that you think this over? I maintain that my statement
above is true in every context, be it the C language or anything else.

You can know that what something /says/ is false, but have independent
evidence that the said thing is [taken to be] true. From this you may
conclude that it doesn't mean what it says, and so you've no idea what
it means. But you do know that what it says is wrong.

--
Chris "the application to standards is obvious" Dollin

Hewlett-Packard Limited Cain Road, Bracknell, registered no:
registered office: Berks RG12 1HN 690597 England

[Tor Rustad]

Richard Heathfield wrote:

Jack Klein said:

[...]

>The memory was freed in the only context that matters in this group.

Nobody disputes that (AFAIK!).

Why, isn't static storage duration of string literals relevant?

Methinks valgrind reported this:

char *str="Five pineapples";

--
Tor <bw****@wvtqvm.vw | tr i-za-h a-z>

[J. J. Farrell]

Jack Klein wrote:

On Thu, 15 Nov 2007 01:58:44 -0800 (PST), "dS***@arcor.de"
<dS***@arcor.dewrote in comp.lang.c:

>On 15 Nov., 08:20, Ian Collins <[e-mail]:

>>gNash wrote:
what it mean?
I've no idea, never having used valgrind. All I can say is it is wrong.

If you've no idea what something means, you cannot know that it is
wrong. (But of course you can say it regardless.)

Yes, he can. As far as the C language is concerned, and that's the
only thing that counts here, free() was properly called on a pointer
returned from malloc(). Since the free() function cannot fail if
called correctly, as it is in this case, the memory was freed.

Neither Ian nor I have to know much about valgrind, the Magna Carta,
or a Comcast commercial featuring the Slowskys, to state that if they
say this memory was not freed, the are wrong.

Something of a straw man, Jack. Whoever said that the memory was not
freed? Valgrind reportedly said "16 byts (sic) in 1 block still
reachable". Does that have anything to do with memory being freed? I
don't know. I have no idea what it means. I don't know whether or not it
is wrong, since I don't know what it is trying to say. Ian appears to be
in much the same position as me, since when asked what it means he said
"I've no idea, never having used valgrind". However, he went on to say
that the message was wrong. Since he does not know what the message
means he cannot know it is wrong, and is wrong to say that it is wrong.
For all that you, I, or Ian know, it might be Valgrind's obscure way of
saying "all memory allocated by malloc() has been correctly freed".

The memory was freed in the only context that matters in this group.

The OP's question may be off-topic, but that doesn't impinge on whether
or not the message was wrong; it impinges on our ability to say whether
or not the message was wrong.