CareerCup

Yes these two pointers are equal , check the address of pointers with &p value after typecasting char pointer to void *...

I think these days compiler does the optimization while compiling.

#include <iostream>
int main()
{
        char * p="i am the one";
        char * q="i am the one";

        if (p==q)
                std::cout << "Pointer has same address";
        else
                std::cout << "Pointer has same Different address";
}

result is "Pointer has same address".

No they are not equal. The content at the location are equal but as such they are actually two distinct strings in different memory locations.

"havfun" is static resource.
so, two pointers have same value.

Well the pointers are equal because they both are pointing to the same string. The above code can also be written as
char *p = "hello";
char * q = p;
Now this is clear that both p and q are "equal". But they both are at different memory locations and there address would be different. This is because the same memory location cannot be allocated to two members.

In C,C++,JAVA, strings are immutable (not d array of characters). This means a string once created cannot be modified. Only flushing d buffer can remove it. Next point is when a string is created it is stored in buffer. Next time again when new string is created, it checked whether it is present in buffer or not?? if present tht address is assigned, otherwise new address stores new string n this new address is assigned. Hope tht helps

p and q will be same, because if we look at a process's memory, there is an area where all the global variables and constants are stored for that process, and "havfun" falls in this category, therefore p and q are having value.

P and q are two different pointers pointing at two different locations and these locations have the same value.

Because p and q are not initialized the memory locations pointed by p and q might the same. Clearly this code is not safe.

Yes address will be the same, because both the character pointer are pointer to the string which is immutable, hence for optimization purposes stored in String Pool.

String literals are stored in the read-only area of the data segment. So it makes no sense to make 2 different copies of the same string, as u cannot edit them anyway. Hence, these two pointers will point to the same location in memory.
You can always assign different values to the pointers, but you cannot change the value.
e.g. you cannot do p[2]='a';