which one requires less memory?

[khan]

Since we did not want to make an error in counting of bytes, we used
the code

char *p;
...
p = malloc(strlen(" hello")+1);
strcpy(p,"hello ");

instead of the intended

char *p;
...
p = malloc(6);
strcpy(p,"hello ");
i want to compare the memory requirements of each version: which one
requires less memory?

[Ian Collins]

khan wrote:

Since we did not want to make an error in counting of bytes, we used
the code

char *p;
...
p = malloc(strlen(" hello")+1);
strcpy(p,"hello ");

instead of the intended

char *p;
...
p = malloc(6);
strcpy(p,"hello ");
i want to compare the memory requirements of each version: which one
requires less memory?

Did you compare strlen("hello") +1 to 6?

--
Ian Collins.

[khan]

Yes..
Both evaluates to 6 ...but does these two programs internally use same
amount of memory?

[Ian Collins]

khan wrote:

Yes..
Both evaluates to 6 ...but does these two programs internally use same
amount of memory?

Please retain enough context for your post to make sense.

Of course they do, they a both malloc(6).

--
Ian Collins.

[Richard Tobin]

In article <5o************ @mid.individual .net>,
Ian Collins <ia******@hotma il.comwrote:

>Both evaluates to 6 ...but does these two programs internally use same
amount of memory?

>Of course they do, they a both malloc(6).

But the one with strlen("hello") might have an extra copy of the
string literal, though one would hope not.

Using sizeof("hello") would be more natural in this case.

-- Richard

--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[santosh]

khan wrote:

Since we did not want to make an error in counting of bytes, we used
the code

char *p;
...
p = malloc(strlen(" hello")+1);
strcpy(p,"hello ");

instead of the intended

char *p;
...
p = malloc(6);
strcpy(p,"hello ");
i want to compare the memory requirements of each version: which one
requires less memory?

A good compiler should consume equal memory for both versions.

[vipvipvipvipvip.ru]

On Oct 30, 10:55 am, rich...@cogsci. ed.ac.uk (Richard Tobin) wrote:

But the one with strlen("hello") might have an extra copy of the
string literal, though one would hope not.

String literals have no scope and no duplicates exist.
Use sizeof "hello", and please check the return value before you do
anything

char *p = malloc(sizeof "hello");
if(p) strcpy(p, "hello");
free(p);

You could also use asprintf or the non-standard strdup.

char *p;
if(asprintf(&p, "hello") == -1) perror("asprint f");
else free(p);

char *p = strdup("hello") ;
free(p);

If you simply want a mutable string, you can use this c99 feature

char *p = (char[]){ "hello" };

or enable some compiler extension that allows string literals to be
modified (not recommended)

[James Kuyper]

vi************* ***@gmail.com wrote:

On Oct 30, 10:55 am, rich...@cogsci. ed.ac.uk (Richard Tobin) wrote:

>But the one with strlen("hello") might have an extra copy of the
string literal, though one would hope not.

String literals have no scope and no duplicates exist.

The first part of that statement is true, though it's relevance is
unclear. The second part is desirable, but not guaranteed by the
standard. 6.4.5p6 says that "It is unspecified whether these arrays are
distinct": if you use the same string literal twice, it might or might
not result in the creation of two distinct arrays of char being created.

[vipvipvipvipvip.ru]

On Oct 30, 1:48 pm, James Kuyper <jameskuy...@ve rizon.netwrote:

The first part of that statement is true, though it's relevance is
unclear. The second part is desirable, but not guaranteed by the
standard. 6.4.5p6 says that "It is unspecified whether these arrays are
distinct": if you use the same string literal twice, it might or might
not result in the creation of two distinct arrays of char being created.

That means "hello" != "hello" might evaluate to true, which is..
irritating.
These std commies sometimes leave too much freedom in the
implementation.

[Chris Dollin]

vi************* ***@gmail.com wrote:

On Oct 30, 1:48 pm, James Kuyper <jameskuy...@ve rizon.netwrote:

>The first part of that statement is true, though it's relevance is
unclear. The second part is desirable, but not guaranteed by the
standard. 6.4.5p6 says that "It is unspecified whether these arrays are
distinct": if you use the same string literal twice, it might or might
not result in the creation of two distinct arrays of char being created.

That means "hello" != "hello" might evaluate to true, which is..
irritating.

But rarely relevant; if you want to compare strings, compare them by
content, or implement your own interning machinery.

These std commies sometimes leave too much freedom in the implementation.

I find your choice of adjectives troubling, especially since in this
instance it's nowhere near "too much freedom".

--
Chris "duplicate removal not universally available" Dollin

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