why is this assignment correct ?

[sumit1680]

Hi all,

recently i tried the following peice of code in gcc

int main ()
{
char *ptr = "possible";
printf("%s",ptr);
return (0);
}

the output was :
possible

now how was this done? i did not assign memory to ptr ! please
explain...

sumit

 

[Nagaraj]

Hi sumit.
The Pointers are special type of variables. Compilers allocates some
memory for it in a particular address space so even though you dont
assign any address if can contain values.
as int a=20;
here you dont assign any memory for 'a' compiler does it. similarly
char *ptr ;
is assigned a address. Remember The Pointers are special type of
variables so like variables they also need some space in memory.
in your case char* ptr ; is a pointer which points to char type of
values and can hold char values in a particular memory space which is
assigned by compilers.
I think i am right to best of my knowledge, but still i have doubt,
which you posted. if find more info please send me.
regards
Nagaraj

 

[bjtuwanglei]

A char pointer can be used for character string.

You can understand as you use malloc() to assign memory yo it.

 

[Marc Thrun]

Hi all,

recently i tried the following peice of code in gcc

int main ()
{
char *ptr = "possible";
printf("%s",ptr);
return (0);
}

the output was :
possible

now how was this done? i did not assign memory to ptr ! please
explain...

sumit

The compiler allocates the memory used by the string literal "possible",
which is a plain character array. If you now assign this array to a
variable of type pointer-to-char, it decomposes to a pointer. Your
pointer ptr now points to the first element of the string literal and
can be used in the printf() call (where the array would be decomposed as
well).

Marc Thrun

PS: Feel free to correct me if I'm wrong

 

[Kleuskes & Moos]

Hi all,

recently i tried the following peice of code in gcc

int main ()
{
char *ptr = "possible";

ptr now points to a constant string, to wit "possible". Memory for it
is allocated by the compiler, you don't need to allocate memory
for it manually.

printf("%s",ptr);
return (0);
}

the output was :
possible

I would have been suprised if it wasn't.

now how was this done? i did not assign memory to ptr !
please explain...

There's little to explain.

 

[Emmanuel Delahaye]

(e-mail address removed) a écrit :

int main ()
{
char *ptr = "possible";

"possible" is a string literal. It's a non modifiable static object with
an address and a permanent lifetime.

This object is actually an array of char initialized with a sequence of
characters terminated by a 0.

{'p','o','s','s','i','b','l','e',0}

Like any array, its address is the same value and type that the address
of the first element of this array, making the assignement to a pointer
to char possible.

Note that the pointed object being not mutable, it is recommended to
define the pointer with the const qualifier:

char const *ptr = "possible";

Note also that these are valid too:

char *ptr;
<...>
ptr = "possible";

char *ptr = NULL;
<...>
ptr = "possible";

char *ptr = "???";

now how was this done? i did not assign memory to ptr !

This is misleading. You don't "assign memory to ptr". You assign an
address to a pointer. This address can be the one of any kind of object
(pointer to an object) or function (pointer to a function).

 

[arun]

the name itself of a character array gives its base address.
i.e suppose char name[]="arun";then the variable 'name' gives the
address of name[0] .here by initialising a pointer 'content' as
'possible' u r basically defining a character array itself.so its just
like using a normal character array.

 

[Jack Klein]

ptr now points to a constant string, to wit "possible". Memory for it
is allocated by the compiler, you don't need to allocate memory
for it manually.

The C standard specifies that the type of a string literal is "array
of char" and most specifically not "array of const char". Attempting
to modify a string literal in C produces undefined behavior, but this
is not because the string literal has the "array of const char", but
because the C standard specifically states that it causes undefined
behavior.

 

[raghu]

Hi all,

recently i tried the following peice of code in gcc

int main ()
{
char *ptr = "possible";
printf("%s",ptr);
return (0);
}

the output was :
possible

now how was this done? i did not assign memory to ptr ! please
explain...

sumit

I think the question sumit is asking is.........
usually pointer points to the address of a variable i.e int i =9; int
*ptr; ptr=&i(here we assigned the address); printf("%d",*ptr); gives
output : 9

In the same way in the sumit program we hav not at all assigned the
pointer the address of a variable,then how come the output is "
possible".

even i have a doubt in this.pls help

 

[slebetman]

I think the question sumit is asking is.........
usually pointer points to the address of a variable i.e int i =9; int
*ptr; ptr=&i(here we assigned the address); printf("%d",*ptr); gives
output : 9

In the same way in the sumit program we hav not at all assigned the
pointer the address of a variable,then how come the output is "
possible".

even i have a doubt in this.pls help

Why do you think it is not assigned an address? Where do you think the
string "possible" is stored.. on paper? Of course the string "possible"
is stored somewhere in memory. Exactly where depends on OS, CPU,
compiler etc.. etc... But when you type:

char *ptr = "possible";

The pointer ptr is pointing to where the string possible is stored
(actually where the first byte is stored). What's so hard to
understand.

A few things to note. String literals are read-only (don't remember the
correct C term). You are not supposed to write to a string literal. So:

x = *ptr;
y = ptr[3];

are legal, but:

*ptr = 'X';
ptr[3] = 'Y';

are not legal.

The second thing to remember is that although ptr points to where the
string "possible" is stored it is a regualr char pointer and may point
to anything else. But when you do this, remember to have something else
point to the string literal or you'll never be able to point anything
to it ever again. For example:

char *ptr = "possible";
ptr = some_other_byte_array;
/* at this point, nothing can point to the string "possible" */