Challenging query regarding pointer

[karthik537]

In the below code...

 

void main()
{
     char *p="Hello";
     scanf("%s",p);
     printf("%s",p);
}

It is confirm that the first statment, the String Literal "Hello" goes in to read only data segment(.rodata).

My doubt is when we enter a string in second statementi.e scanf, the entered string will store in which segment? is it stack or data.....???

Please reply asap....

[laserlight]

That results in undefined behaviour. The code attempts to modify a string literal. To help avoid such mistakes, p should be declared const char* not char* since it points to a string literal.

By the way, use int main instead of void main, and return 0 if you want to be compatible with the 1990 edition of the C standard.

[karthik537]

Hi laserlight.....I didn't asked you what happend to pointer p....I am asking you if we enter a string through scanf...where the entered string goes?.......(in stack or data segment)

[vart]

it goes into the read-only arey causing the seg fault

[laserlight]

I didn't asked you what happend to pointer p

I did not tell you what happened to p either. I just told you that undefined behaviour is involved. Effectively, you asked a wrong question.

I am asking you if we enter a string through scanf...where the entered string goes?.......(in stack or data segment)

It goes to wherever the destination string has space allocated... but since there is undefined behaviour in this case, it depends on the implementation.

[matsp]

All local variables and parameters of a function are declared in a part of memory called
the stack......

On the other hand, global variables and dynamically allocated memory comes from a
different part of memory called the heap.

Hope u understood this

I hope not - as it's wrong - and not the question .

Global variables are in the data section. Local variables are indeed in the stack section. Heap section is used when malloc() is called - that is, when dynamically allocated memory is used.

As to the original question: Laserlight is right - it is undefined. The C standard doesn't clearly say how string literals are stored - as long as they are stored somewhere and work as the standard describes, it is entirely possible for the compiler to store them in any memory it likes - it can be writable, and it can be read-only memory.

The reason the C standard doesn't specify how the string literal should be stored is that it would prevent a C compiler from being implemented on a machine that can't provide read-only memory for string literals - such as many small embedded systems or DOS-based PC's.

In a modern OS, using a modern compiler, such as Windows or Linux with gcc(-mingw), the string literal will be stored in read-only memory, and an attemp to actually enter something into that memory will cause the application to have a access violation/segmentation fault.

Of course, it is BETTER if the compiler can provide protection. If we assume the above code doesn't crash, what happens if we do:

void main()
{
     char *p="Hello";
     char *q = "World\n");
     scanf("%s",p);
     printf("%s %s",p, q);
}

and then enter "LongWord"?
Most likely, part of "World" would be overwritten! That's really not good, right?

--
Mats

[itCbitC]

In the below code...

 

void main()
{
     char *p="Hello";
     scanf("%s",p);
     printf("%s",p);
}

It is confirm that the first statment, the String Literal "Hello" goes in to read only data segment(.rodata)...

fact that a "string literal" is aka a "string constant" may have something to do with it.

[root4]

one way to 'fix' this problem is to tell the compiler to declare string litterals as 'const char*' (-Wwrite-strings with gcc, plus -Werror) which will prevent a statement like char*p="blah".

[kermit]

You know it is interesting that if I declare p like so:

const char *p="Hello";

And do

gcc -Wwrite-strings -Werror -o seg seg.c

I get no warnings at all. If I use -Wall, I get a warning. From the gcc man page:

-Wwrite-strings
When compiling C, give string constants the type const char[length] so
that copying the address of one into a non-const char * pointer will get a
warning; when compiling , warn about the deprecated conversion from string
constants to char *. These warnings will help you find at compile time
code that can try to write into a string constant, but only if you have
been very careful about using const in declarations and prototypes.
Otherwise, it will just be a nuisance; this is why we did not make -Wall
request these warnings.

[audinue]

By the way, use int main instead of void main, and return 0 if you want to be compatible with the 1990 edition of the C standard.

I see this code just works fine with most C compiler

func() {
  //...
}

main() {
  //...
}

[root4]

I get no warnings at all. If I use -Wall, I get a warning

If you add 'const', before, you get no warning from -Wwrite-strings, as expected (you get one if there is no const). With -Wall, what warning do you get?

I see this code just works fine with most C compiler

You shoud pay more attention when someone speaks of undefined/unspecified or implementation-defined behavior in this board.

[kermit]

If you add 'const', before, you get no warning from -Wwrite-strings, as expected (you get one if there is no const). With -Wall, what warning do you get?

With -Wall, I get this:

seg.c: In function ‘main’:
seg.c:6: warning: writing into constant object (argument 2)

and the code looks like this:

#include <stdio.h>

int main(void)
{
     const char *p="Hello";
     scanf("%s",p);
     printf("%s",p);

     return 0;
}

I removed the const part of the declaration, and got this:

kermit@fastbox ~/cprogs/board $ gcc -Wwrite-strings -o seg seg.c
seg.c: In function ‘main’:
seg.c:5: warning: initialization discards qualifiers from pointer target type

However, when I use -Wall with the const removed, I get no warning at all..

[root4]

the warning you get with -Wall concerns the scanf line (you're trying to modify a const-qualified object), the warning you get with -Wwrite-strings concerns the assignment (like char* p="hello" which is invalid with -Wwrite-strings and should be const char*), these are two differents things and the compiler behavior is the one expected (at least the one I expect).

[kermit]

Oh I get it now. Thanks

[laserlight]

I see this code just works fine with most C compiler

That relies on the deprecated feature of int being the default return type.