C++ Pointers and String Literals – Comprehensive Guide

c++pointersstring-literals

Many a times I have seen the following statements:

char* ch = "Hello"
cout<<ch;

The output I get is "Hello". I know that ch points to the first character of the string "Hello" and that "Hello" is a string literal and stored in read only memory. Since, ch stores the address of the first character in the string literal, so shouldn't the statement,

cout<<ch;

give the output "the address of a character" because, it is a pointer variable? Instead it prints the string literal itself.
Moreover, if I write this,

ch++;
cout<<ch;

It gives the output, "ello". And similarly, it happens with more consecutive ch++ statements too.

can anybody tell me, why does it happen?
Btw, I have seen other questions related to string literals, but all of them address the issue of "Why can't we do something like *ch='a'?
EDIT : I also want to ask this in reference to C, it happens in C too, if I type,

printf("%s",ch);

Why?

Best Answer

There's overloaded version of operator<<

ostream& operator<< (ostream& , const char* );

This overload is called whenever you use something like:-

char *p = "Hello";
cout << p;

This overload defines how to print that string rather than print the address. However, if you want to print the address, you can use,

cout << (void*) p;

as this would call another overload which just prints the address to stream:-

ostream& operator<< (ostream& , void* );

Related Solutions

C++ – Where Are String Literals Stored and Can They Be Modified?

Now strPtr and strArray are considered to be string literals.

No, they aren't. String literals are the things you see in your code. For example, the "Hello". strPtr is a pointer to the literal (which is now compiled in the executable). Note that it should be const char *; you cannot legally remove the const per the C standard and expect defined behavior when using it. strArray is an array containing a copy of the literal (compiled in the execuable).

Both the above statements should be illegal. compiler should throw errors in both cases.

No, it shouldn't. The two statements are completely legal. Due to circumstance, the first one is undefined. It would be an error if they were pointers to const chars, though.

As far as I know, string literals may be defined the same way as other literals and constants. However, there are differences:

// These copy from ROM to RAM at run-time:
char myString[] = "hello";
const int myInt = 42;
float myFloats[] = { 3.1, 4.1, 5.9 };

// These copy a pointer to some data in ROM at run-time:
const char *myString2 = "hello";
const float *myFloats2 = { 3.1, 4.1, 5.9 };

char *myString3 = "hello";  // Legal, but...
myString3[0] = 'j';         // Undefined behavior!  (Most likely segfaults.)

My use of ROM and RAM here are general. If the platform is only RAM (e.g. most Nintendo DS programs) then const data may be in RAM. Writes are still undefined, though. The location of const data shouldn't matter for a normal C++ programmer.

C++ Pointers and Strings – Comprehensive Guide

It seems like you understand what C-style strings are, but to summarize, they are just arrays of characters in memory, by convention terminated by a nul character \0. Usually they are referenced via a char* pointing to the first letter in the string. When they are printed, typically the characters of the string are printed starting from the first, and printing (or copying, etc.) stops when the \0 terminator is reached.

An std::string is a class that (typically) wraps a C-style string. This means that a std::string object (typically) has a private C-style string that is used to implement its functionality. The function std::string::c_str() returns a pointer to this underlying C-style string.

Let's suppose that char *str; points to a C-style string. If you attempt to run cout << *str << endl;, you noticed that only the first character is printed. That is because of C++'s function overloading. The data type of *str is char, so the char version of cout is called and faithfully prints the single character *str. For compatibility with C-style strings, the version of cout that takes a char* as an argument treats the pointer as a C-style string for printing purposes. If you cout an int*, for example, the underlying int will not be printed.

Edit: Another comment:

The reason that your attempt to dereference an std::string object failed is that, indeed, it is not a pointer. You could dereference the return value of std::string::c_str(), and you would get back the first char of the string.

Best Answer

Related Solutions

C++ – Where Are String Literals Stored and Can They Be Modified?

C++ Pointers and Strings – Comprehensive Guide

Related Question