reassigning value of a pointer

[bhalicki]

Hi all,

In the following code I am trying to change the contents of a string:

int main()
{
char *string="testing";
rename(string);

return 0;
}

void rename(char *s)
{
printf("Character 1: %c\n",*s);
*s='a';
printf("Character 1 now: %c\n",*c);
}

Anyway, I am sure this is possible but for some reason I'm getting
segmentation faults at line *s='a'; when I attempt to change the value
in which *s is currently pointing to, being the first character in the
string.

Any ideas?

Thanks in advance,

Ben.

[Walter Roberson]

In article <11**********************@g14g2000cwa.googlegroups .com>,
<bh******@dodo.com.au> wrote:

In the following code I am trying to change the contents of a string: int main()
{
char *string="testing";

The standard allows string literals to be stored in read-only memory.
An assignment of a string literal to a pointer sets the pointer value
to the address of that {possibly read-only} memory.

In particular, char *string="testing"; usually does not allocate some
memory somewhere and copy the string into it at runtime. That's
one of the possible behaviours, but it isn't the only possible
behaviour.

Another thing to note is that it is allowed for the compiler
to merge all string literals -- so for example if you also had

char *anotherstring="testing";

then anotherstring could end up as the same pointer value as
your string variable. Furthermore, if you had

char *thirdstring="just testing";

then string and anotherstring could end up pointing at the terminal
"testing" substring of the "just testing".

If you need a modifiable string, allocate the memory (somehow) and
copy the appropriate contents into it.
--
"It is important to remember that when it comes to law, computers
never make copies, only human beings make copies. Computers are given
commands, not permission. Only people can be given permission."
-- Brad Templeton

[bhalicki]

Thanks for that information Walter. I managed to get it working, by
allocating the memory then using strcpy to load the string.

Regards,

Ben.

[Martin Ambuhl]

bh******@dodo.com.au wrote:

Hi all,

In the following code I am trying to change the contents of a string:
Then don't use string literals.

int main()
{
char *string="testing";

If you want to change the string, don't make 'string' point to a literal
constant; use an array:
char string[] = "testing";

Always check the FAQ before posting. In this case, you might have found
<http://www.eskimo.com/~scs/C-faq/q1.32.html> useful.

[hemalatha.gopalakrishnan]

in the above program what is "c", not declared in the program, first u
declare that and assign a value and then print it ok. i think that
there is no problem in the line *s='a';
so try it and send me the result.

[pete]

Martin Ambuhl wrote:

Then don't use string literals. If you want to change the string,
don't make 'string' point to a literal constant;
There is no such thing as a "literal constant" in C.
char string[] = "testing";

You just used a string literal to initialize an array.

--
pete

[Richard Bos]

bh******@dodo.com.au wrote:

int main()
{
char *string="testing";
rename(string);

Your immediate problem is as others have explained it. However, you have
another bug: rename() is already a Standard function, and you cannot
redefine it, let alone redefine it with an incompatible declaration.

Richard

[David G. Hong]

It becomes a standard function iff (if and only if) you include
<stdio.h>. Although dubbed as *Standard* Input Ouput - not really a
standard. Any programmer could redefine functions already defined in
*Standard* headers. Other than that, what the original author intended
to do clearly shouldn't be named as rename(..); rather,
change_sptr(...); Or something simliar.

[pete]

David G. Hong wrote:

It becomes a standard function iff (if and only if) you include
<stdio.h>.

How do you figure that?

N869
7.1.3 Reserved identifiers
[#1]
-- All identifiers with external linkage in any of the
following subclauses (including the future library
directions) are always reserved for use as identifiers
with external linkage.

--
pete

[Flash Gordon]

David G. Hong wrote:

Provide context. This is possible and instructions were posted only
yesterday, so had you read the group before posting (you should always
read a few days posts before your first post to a group) you would have
know to do this and *how* to do it. It's something like pressing the
"options" button and using the reply button that provides.

It becomes a standard function iff (if and only if) you include
<stdio.h>. Although dubbed as *Standard* Input Ouput - not really a
standard. Any programmer could redefine functions already defined in
*Standard* headers.
Wrong. The standard does not allow you to redefine *any* of the standard
functions whether you include the relevant header or not. *Some*
implementations allow you to do this and define the behaviour, but it is
not portable.
Other than that, what the original author intended
to do clearly shouldn't be named as rename(..); rather,
change_sptr(...); Or something simliar.

Well, since you've not provided any context it is hard to tell what a
sensible name would be.
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.

[Lawrence Kirby]

On Wed, 28 Sep 2005 06:34:39 +0000, pete wrote:

Martin Ambuhl wrote:

Then don't use string literals.

If you want to change the string,
don't make 'string' point to a literal constant;

There is no such thing as a "literal constant" in C.

It is a resonable description of a string literal object.

char string[] = "testing";

You just used a string literal to initialize an array.

which solves the primary problem in the original code. I'm not clear what
point you are trying to make here.

Lawrence

[pete]

Lawrence Kirby wrote:

On Wed, 28 Sep 2005 06:34:39 +0000, pete wrote:

Martin Ambuhl wrote:

Then don't use string literals.

You just used a string literal

which solves the primary problem in the original code.
I'm not clear what
point you are trying to make here.

He said not to use string literals
and then he used one.

--
pete

[pete]

Lawrence Kirby wrote:

On Wed, 28 Sep 2005 06:34:39 +0000, pete wrote:

There is no such thing as a "literal constant" in C.

It is a resonable description of a string literal object.

The standard lists many types of constants.
No objects are constants.

As used in a pointer initialization,
a string literal converts to an "address constant",
which would have been a better term to use.

--
pete

[Default User]

bh******@dodo.com.au wrote:

Thanks for that information Walter. I managed to get it working, by
allocating the memory then using strcpy to load the string.

Please read my sig.

Brian

--
Please quote enough of the previous message for context. To do so from
Google, click "show options" and use the Reply shown in the expanded
header.

[Mark McIntyre]

On 28 Sep 2005 02:13:26 -0700, in comp.lang.c , "David G. Hong"
<ki****@gmail.com> wrote:

It becomes a standard function iff (if and only if) you include
<stdio.h>.
This is incorrect. What you're referring to is the fact that if you
don't include the header, the compiler may not complain about an
incompatible definition.
Although dubbed as *Standard* Input Ouput - not really a
standard.
Actually, they are - in order for a C compiler to be
Standard-compliant, it must provide these functions.
Any programmer could redefine functions already defined in
*Standard* headers.

No, this is forbidden.
--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-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 =----

[Emmanuel Delahaye]

bh******@dodo.com.au wrote on 28/09/05 :

In the following code I am trying to change the contents of a string:

int main()
{
char *string="testing";
This is not portable. The standard says that string literals are not
guaranteed to be mutable.

char const *string="testing";

is better and error prone.

rename(string);

return 0;
}

void rename(char *s)
'constness propagation' :

void rename(char const *s)
{
printf("Character 1: %c\n",*s);
*s='a';
compile error due to const. You are now warned that there is something
wrong in your design. Sure, because you are trying to modify a
read-only object.

To fix that, you must use an initiaized array of char :

char string[] = "testing";

and keep the rest of your original code ...
printf("Character 1 now: %c\n",*c);
.... well, almost... what is 'c' ? You meant 's', I guess...
}

Anyway, I am sure this is possible but for some reason I'm getting
segmentation faults at line *s='a'; when I attempt to change the value
in which *s is currently pointing to, being the first character in the
string.

Sure. Attempting to write to a string literal invokes an undefined
behaviour.

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"Clearly your code does not meet the original spec."
"You are sentenced to 30 lashes with a wet noodle."
-- Jerry Coffin in a.l.c.c++

[kar1107]

bh******@dodo.com.au wrote:

Hi all,

In the following code I am trying to change the contents of a string:

int main()
{
char *string="testing";
The above assignment loses the const qualifier. In case you
are using gcc, -Wwrite-strings will emit warnings. Use arrays if
you want to modify content.
cat str.c #include <stdio.h>
int main (void)
{
char *string = "testing";
printf("%s\n", string);
return 0;
}which gcc gcc: aliased to gcc -Wall -W -ansi -pedanticgcc str.c
./a.out testinggcc -Wwrite-strings str.c str.c: In function `main':
str.c:4: warning: initialization discards qualifiers from pointer
target type

Karthik
rename(string);

return 0;
}

[bhalicki]

he**********************@gmail.com wrote:

in the above program what is "c", not declared in the program, first u
declare that and assign a value and then print it ok. i think that
there is no problem in the line *s='a';
so try it and send me the result.

Sorry, my apologies, *c should have read *s. I still can't figure this
one. As far as I understand, *s is a pointer, which should point to a
memory location which currently holds the value 't' (first character in
string 'testing'). Without moving the pointer, I try to reassign this
to the value 'a', but it seg. faults. I have even tried allocating
memory with malloc/memset, but still the same result.

I didn't want to use an array as I wanted to dynamically allocate
memory based on string size (at runtime). I'm sure this has been done
before without arrays and it seems logical.

[Keith Thompson]

Mark McIntyre <ma**********@spamcop.net> writes:

On 28 Sep 2005 02:13:26 -0700, in comp.lang.c , "David G. Hong"
<ki****@gmail.com> wrote:

[...]

Although dubbed as *Standard* Input Ouput - not really a
standard.

Actually, they are - in order for a C compiler to be
Standard-compliant, it must provide these functions.

Assuming (as we usually do around here) a hosted implementation rather
than a freestanding (embedded) implementation.

And as long as I'm nitpicking, it's the implementation, not
necessarily the compiler, that provides the standard functions.

But of course your point is correct. Since the rename() function is
provided by <stdio.h>, "rename" is reserved for use as an identifier
with external linkage. You could provide a static function called
"rename", but it would only cause confusion.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Keith Thompson]

bh******@dodo.com.au writes:

he**********************@gmail.com wrote:

in the above program what is "c", not declared in the program, first u
declare that and assign a value and then print it ok. i think that
there is no problem in the line *s='a';
so try it and send me the result.

Sorry, my apologies, *c should have read *s. I still can't figure this
one. As far as I understand, *s is a pointer, which should point to a
memory location which currently holds the value 't' (first character in
string 'testing'). Without moving the pointer, I try to reassign this
to the value 'a', but it seg. faults. I have even tried allocating
memory with malloc/memset, but still the same result.

I didn't want to use an array as I wanted to dynamically allocate
memory based on string size (at runtime). I'm sure this has been done
before without arrays and it seems logical.

I don't understand. Just yesterday, you wrote:

] Thanks for that information Walter. I managed to get it working, by
] allocating the memory then using strcpy to load the string.

Your original code had several problems. It declared a function
called "rename", which conflicts with the standard function of that
name. It attempted to modify a string literal (a segmentation fault
is a likely symptom in that case). And it used the name "c" rather
than "s", implying that the code you posted wasn't the actual code you
had tried.

If you're still having problems after fixing all these issues, try
posting your code again. Copy-and-paste the *exact* code that you fed
to the compiler; if you re-enter it manually, we won't be able to
guess which errors are in the original code and which are new typos.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Flash Gordon]

ka*****@gmail.com wrote:

bh******@dodo.com.au wrote:

Hi all,

In the following code I am trying to change the contents of a string:

int main()
{
char *string="testing";

The above assignment loses the const qualifier.

No it doesn't. One of the quirks of the C language is that it is *not*
const qualified. Modifying string literals is undefined behaviour
(forbidden) because the standard explicitly states that it is and for no
other reason.
In case you
are using gcc, -Wwrite-strings will emit warnings. Use arrays if
you want to modify content.

This is correct.

cat str.c

#include <stdio.h>
int main (void)
{
char *string = "testing";
printf("%s\n", string);
return 0;
}

There is nothing wrong with the above code. The standard does not
require a diagnostic and it does not invoke undefined behaviour.

which gcc

gcc: aliased to gcc -Wall -W -ansi -pedantic

gcc str.c
./a.out

testing

gcc -Wwrite-strings str.c

str.c: In function `main':
str.c:4: warning: initialization discards qualifiers from pointer
target type

I agree that the warning is useful. Just not required by the standard
and not provided by all compilers.
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.