Simple C program performing unexpectedly

I think you're declaring that the variable remain constant or so, if you wanted to set it up as a pointer, the initialization would look like this:

char *str = "Hello";

I haven't written C in about 3 months, but I believe this is how you set it up.  I'm not sure setting it to a pointer like that will work or not, so you might need to malloc before you assign value(s) to the string.

The difference between your and mine, if you can't tell, is that your asterisk is by the char and mine is by the str.  They mean two different things.

Well, when you declare your string as char* str = "Hello"; you don't perform any memory allocation, all you do is to point your variable to a constant array of characters in memory ("Hello"). This is why you get segmentation fault when trying to strcpy it. I didn't tested the program with str[], but you should make your code look like this:

#define A_BIG_VALUE 100
int main() {
   char* str;
   str  = (char *) malloc(A_BIG_VALUE); // for example, or char str[A_BIG_VALUE].
   strcpt(str,"Hello");
   printf("Before strcpy str is %s\n", str);
   strcpy(str, "Hi");
   printf("After strcpy str is %s\n", str);
   return 0;
}

char *str = "Hello";
char* str = "Hello";
char    *       str    =     "Hello"       ;

Are all identical.

There's only a difference between

char *a,*b;
and
char* a,b;

because the '*' really lives with the 'a' and not the 'char'
so the first one means
char *a;
char *b;
whereas the second means
char *a;
char b;

The reason your original fails, is that char *str = "Hello"; makes 'str' point to the string. Fine. But, because you're setting it to a fixed value, that string lives in a particular 'fixed' bit of memory that the compiler has prepared for you. You're not allowed to change it. Depending on the implementation, the strcpy() might fail, or you find it fails later. You're not allowed to overwrite the memory that str points to. If you want to strcpy(str,...) you need to allocate some new memory for it somewhere, using malloc()

So, you'd have to do

   char* str = "Hello";
   printf("Before strcpy str is %s\n", str);
   str = (char*) malloc( 3 );    // 2 characters in 'Hi' + 1 for the NULL
   strcpy(str, "Hi");
   printf("After strcpy str is %s\n", str);
   free(str);

Free() is required else you'll leak the memory you malloced. You don't free the original (from str = "Hello"), because that's in the 'fixed' memory area.

When "malloc"ing, I wouldn't recommend using a big value if you know exactly how long your longest string will be.  Give yourself some headroom, but don't waste memory by allocating a big slot for something as small as Hello or Hi.  If Hello is going to be your longest, for instance, mallocing 8 bytes should be more than enough, each character being 1 byte, plus some headroom.  

Hi all,
 robert_marquardt's comment was brief and explaining. Actually I was not expecting this output. Now I understand that in case of an array char str[] = "Hello", the string literal and the variable str are both created on stack and both can be modifies using any means. But if the initilization is done with char* str = "Hello", there is no memory allocation for str and so strcpy fails. Correct me if I am wrong.
But I don't understand one thing. str points to the first byte where the first charecter 'H' is stored. When I print str, it prints successfully. That means the area where "Hello" is stored is in my access and so I don't get any segmentation fault while reading the contents of that memory location. Buyt I don't understand one thing. Whay can't I write to that momery location. One more thing. Consider this piece of code.

int main() {
   char str[] = "Hello";
   printf("Before strcpy str is %s\n", str);
   printf("%s, %p, %p\n", str, str, &str);
   strcpy(str, "Hi");
   printf("After strcpy str is %s\n", str);
   return 0;
}

while printing addresses, the thing that amazed me is str and &str both give the same thing. And I don't understand this. PLease help me.

char *str = "Test"; declares a variable str of type pointer and a anonymous static constant array (the string literal) and makes the pointer point to it.
char str[] = "Test"; only declares a variable of char array and initializes it with the string literal. There is no constant array anymore.

The ccrucial point is that the anonymous constant array for the string literal is placed in a read only memory area.
This allows the compiler to eliminate duplicate strings. You can make this area writable and supress the elimination of duplicate strings with compiler options.
The crash comes from strcpy writing to write protected memory.

I have got a lot of funda from robert_marquardt 's comment, but I have still not received the answer of the second question. Why do str and &str print the same value? Is it printf that is doing something or anything else. Can someone of you explain?

Thanks a lot

Well, str is an array. In C, simply mentioning the name of the array like 'str', without any brackets,  means getting the address of the array. As you surely know, & is the address-of operator, so it is logical that it does the same thing.

Well, I think there is a confusion here. the name of the array i.e. str contains the first element of the memory space where the string "Hello" resides. It means the value of str will be XYZ where 'H' resides at the address XYZ. Upto here I think I am correct. Now &str should give the address of str i.e. where str resides. I think these 2 things should be different. We consider an example scenario.

Lets say the memory is assigned as follows:-

0x00001 contains 'H'
0x00002 contains 'e'
...
...
0x00005 contains 'o'
0x00006 contains '\0'

str is somewhere say at 0x00011.
So, the content of str is the address of 'H' i.e.
str=0x00001

and &str contains the address of str i.e.
&str=0x00011

So, the 2 values should be different. Please correct me if I am wrong. And can you explain me things with the scenario presented above. I think I am just near to the solution :-)

Thanks a lot again

The behaviour you are expecting can be generated as follows:

char *strptr = str;
printf("%p %p\n", strptr, &strptr);

This does what you expect it to do because C treats a pointer as a variable in its own right, the semantics for an array are subtly different.