Reset a string?

[spike]

How do i reset a string?
I just want to empty it som that it does not contain any characters

Say it contains "hello world" at the time...
I want it to contain "". Nothing that is..

Thanx

[Adrian de los Santos]

On 2004-03-05 15:46:32 -0600, Eric Sosman <Er*********@su n.com> said:

be careful with char pointers like that.. it's not portable.
you have no garanties you'll be able to modify it like you did..
the compiler may put "hello" in readonly memory..

Even if no read-only memory is involved you can find
yourself in trouble. For example,

char *str = "hello";
str[0] = '\0';
puts ("Some rhymes: bellow, fellow, Jell-O, and hello");

may well produce the output

Some rhymes: bellow, fellow, Jell-O, and =
More than one compiler performs the optimization that
produces this effect when abused by incorrect code.

Intresting.. very intresting, but why the compiler do this ?

Thanks.

[Martin Dickopp]

Tor Husabø <to***@student. hf.uio.no> writes:

Maybe I should blame the fact that the two declarations below are equal?
Maybe it's more confusing than really helpful to differentiate in this way?
void func1(int a[]); /* argument is pointer to array */
No, a pointer to an array cannot be used as an argument here, but a
pointer the first element of an array can.
void func2(int *a); /* argument is pointer to a single int */

Both declarations are equivalent. In both cases, `a' is pointer to an
object of type `int'. Whether this object is a single `int' or the first
element of an array makes no difference as far as the declaration is
concerned.

Martin
--
,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
/ ,- ) http://www.zero-based.org/ ((_/)o o(\_))
\ `-' `-'(. .)`-'
`-. Debian, a variant of the GNU operating system. \_/

[J. J. Farrell]

"Adrian de los Santos" <de*********@de mon.com.mx> wrote in message news:c2******** *****@ID-86516.news.uni-berlin.de...

On 2004-03-05 15:46:32 -0600, Eric Sosman <Er*********@su n.com> said:

Even if no read-only memory is involved you can find
yourself in trouble. For example,

char *str = "hello";
str[0] = '\0';
puts ("Some rhymes: bellow, fellow, Jell-O, and hello");

may well produce the output

Some rhymes: bellow, fellow, Jell-O, and
More than one compiler performs the optimization that
produces this effect when abused by incorrect code.

Intresting.. very intresting, but why the compiler do this ?

Because attempting to modify a string literal constant
results in undefined behaviour, and the compiler can do
what it wants. Since the writer of the code is not allowed
to invoke undefined behaviour if he wants predictable
results, the compiler can assume that he doesn't do so.
Hence the compiler can assume that the string literal
"hello" will never be modified, and hence it can optimise
memory usage by re-using the string "hello" that occurs
at the end of the bigger string. If the coder does risk
his life and sanity by modifying the string literal, in
this implementation he modifies others at the same time.

[CBFalconer]

Tor Husabø wrote:

Tor Husabø wrote:

spike wrote:
.... snip ...
char *str = "hello";
str[0] = '\0'; /* put a null terminator at the beginning */

.... snip ...
Maybe I should blame the fact that the two declarations below
are equal? Maybe it's more confusing than really helpful to
differentiate in this way?
void func1(int a[]); /* argument is pointer to array */
void func2(int *a); /* argument is pointer to a single int */

I guess this could be what had me fooled for a moment.

If the original declaration is of the (correct) form:

const char *str = "hello";

then the other misusages should get flagged at compile time.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Adrian de los Santos]

On 2004-03-06 06:14:19 -0600, "J. J. Farrell" <jj*@bcs.org.uk > said:

"Adrian de los Santos" <de*********@de mon.com.mx> wrote in message
news:c2******** *****@ID-86516.news.uni-berlin.de...

On 2004-03-05 15:46:32 -0600, Eric Sosman <Er*********@su n.com> said:

Even if no read-only memory is involved you can find
yourself in trouble. For example,

char *str = "hello";
str[0] = '\0';
puts ("Some rhymes: bellow, fellow, Jell-O, and hello");

may well produce the output

Some rhymes: bellow, fellow, Jell-O, and
More than one compiler performs the optimization that
produces this effect when abused by incorrect code.

Intresting.. very intresting, but why the compiler do this ?

Because attempting to modify a string literal constant
results in undefined behaviour

fist pardon me please for my poor knowledge of this topics.

As far as i understand

char *str="hello";

- will create a pointer to a char str
- will store "hello" on the memory
- will store the address of memory where "hello" starts in the str variable.

Am i right ?

So why *str becomes a constant ?
because it was assigned a rvalue at initialization ? (="hello")

Thanks for your kind explanation.

[Tor Husabø]

Martin Dickopp wrote:

Tor Husabø <to***@student. hf.uio.no> writes:

Maybe I should blame the fact that the two declarations below are equal?
Maybe it's more confusing than really helpful to differentiate in this way?
void func1(int a[]); /* argument is pointer to array */

No, a pointer to an array cannot be used as an argument here, but a
pointer the first element of an array can.

Okay, maybe it's the wrong term here.

void func2(int *a); /* argument is pointer to a single int */

Both declarations are equivalent. In both cases, `a' is pointer to an
object of type `int'. Whether this object is a single `int' or the first
element of an array makes no difference as far as the declaration is
concerned.

That's my point, exactly. Allowing this to be written in both ways is a
bit confusing, since the char* and char[] notations have different
meanings in other contexts, but here they are equivalent. The
comments int the code are supposed to say what the perceived
difference is, it's only for documentation purposes.

Guess you didn't read my post properly (and I wasn't making myself
very clear, either).

Tor

[Tor Husabø]

Adrian de los Santos wrote:

As far as i understand

char *str="hello";

- will create a pointer to a char str
- will store "hello" on the memory
- will store the address of memory where "hello" starts in the str
variable.

Am i right ?

So why *str becomes a constant ?
because it was assigned a rvalue at initialization ? (="hello")

char *str does not become a constant! It's "hello" that is "constant"
(in the sense that modifying it is has undefined behavior, even
if it might work on your implementation) .

This is allowed, however:

char other_string[] = "goodbye";
char *str="hello";
str = other_string;

now str points to "goodbye", and "hello" is just wasted memory, since
you dont have the address anymore.

Read all about it here: http://www.eskimo.com/~scs/C-faq/q1.32.html

[Tor Husabø]

Tor Husabø wrote:

Adrian de los Santos wrote:

As far as i understand

char *str="hello";

- will create a pointer to a char str
- will store "hello" on the memory
- will store the address of memory where "hello" starts in the str
variable.

Am i right ?

So why *str becomes a constant ?
because it was assigned a rvalue at initialization ? (="hello")

char *str does not become a constant! It's "hello" that is "constant"
(in the sense that modifying it is has undefined behavior, even
if it might work on your implementation) .

This is allowed, however:

char other_string[] = "goodbye";
char *str="hello";
str = other_string;

now str points to "goodbye", and "hello" is just wasted memory, since
you dont have the address anymore.

Read all about it here: http://www.eskimo.com/~scs/C-faq/q1.32.html

Sorry, this one got posted at the wrong place in the thread...

[Tor Husabø]

Adrian de los Santos wrote:

As far as i understand

char *str="hello";

- will create a pointer to a char str
- will store "hello" on the memory
- will store the address of memory where "hello" starts in the str variable.
Am i right ?

So why *str becomes a constant ?
because it was assigned a rvalue at initialization ? (="hello")

char *str does not become a constant! It's "hello" that is "constant"
(in the sense that modifying it is has undefined behavior, even
if it might work on your implementation) .

This is allowed, however:

char other_string[] = "goodbye";
char *str="hello";
str = other_string;

now str points to "goodbye", and "hello" is just wasted memory, since
you dont have the address anymore.

Read all about it here: http://www.eskimo.com/~scs/C-faq/q1.32.html

Tor

[Tor Husabø]

Tor Husabø wrote:

Adrian de los Santos wrote:

> As far as i understand
>
> char *str="hello";
>
> - will create a pointer to a char str
> - will store "hello" on the memory
> - will store the address of memory where "hello" starts in the str

variable.

>
> Am i right ?
>
> So why *str becomes a constant ?
> because it was assigned a rvalue at initialization ? (="hello")

char *str does not become a constant! It's "hello" that is "constant"
(in the sense that modifying it is has undefined behavior, even
if it might work on your implementation) .

This is allowed, however:

char other_string[] = "goodbye";
char *str="hello";
str = other_string;

now str points to "goodbye", and "hello" is just wasted memory, since
you dont have the address anymore.

Read all about it here: http://www.eskimo.com/~scs/C-faq/q1.32.html

Tor

Oops, did it again :/