String literals

A string literal contains a sequence of characters or escape sequences enclosed in double quotation mark symbols. A string literal with the prefix L is a wide string literal. A string literal without the prefix L is an ordinary or narrow string literal.

C only The type of a narrow string literal is array of char. The type of a wide string literal is array of wchar_t. C only ends

C++ only begins The type of a narrow string literal is array of const char. The type of a wide string literal is array of const wchar_t. Both types have static storage duration. C++ only ends


String literal syntax

             .---------------------.      
             V                     |      
>>-+---+--"----+-character-------+-+--"------------------------><
   '-L-'       '-escape_sequence-'

Multiple spaces contained within a string literal are retained.

Use the escape sequence \n to represent a new-line character as part of the string. Use the escape sequence \\ to represent a backslash character as part of the string. You can represent a single quotation mark symbol either by itself or with the escape sequence \'. You must use the escape sequence \" to represent a double quotation mark.

Outside of the basic source character set, the universal character names for letters and digits are allowed in C++ and at the C99 language level. C++ only In C++, you must compile with the -qlanglvl=ucs option for universal character name support. C++ only ends

IBM extension begins The Pascal string form of a string literal is also accepted when you compile with the -qmacpstr option. IBM extension ends

See the following examples of string literals:

char titles[ ] = "Handel's \"Water Music\""; 
char *temp_string = "abc" "def" "ghi";    // *temp_string = "abcdefghi\0" 
wchar_t *wide_string = L"longstring";

This example illustrates escape sequences in string literals:

#include <iostream> using namespace std;

int main () {
       char *s ="Hi there! \n";       
    		cout << s;
       char *p = "The backslash character \\.";
       cout << p << endl;
       char *q = "The double quotation mark \".\n";
       cout << q ;
 }

This program produces the following output:

Hi there! The backslash character \. The double quotation mark ".

To continue a string on the next line, use the line continuation character (\ symbol) followed by optional whitespace and a new-line character (required). For example:

char *mail_addr = "Last Name    First Name    MI   Street Address \
       893    City     Province   Postal code ";

Note: When a string literal appears more than once in the program source, how that string is stored depends on whether strings are read-only or writable. By default, the compiler considers strings to be read-only. XL C/C++ might allocate only one location for a read-only string; all occurrences refer to that one location. However, that area of storage is potentially write-protected. If strings are writable, then each occurrence of the string has a separate, distinct storage location that is always modifiable. You can use the #pragma strings directive or the -qro compiler option to change the default storage for string literals.

String concatenation

Another way to continue a string is to have two or more consecutive strings. Adjacent string literals can be concatenated to produce a single string. For example:

"hello " "there"    //equivalent to "hello there" 
"hello" "there"     //equivalent to "hellothere"

Characters in concatenated strings remain distinct. For example, the strings "\xab" and "3" are concatenated to form "\xab3". However, the characters \xab and 3 remain distinct and are not merged to form the hexadecimal character \xab3 .

If a wide string literal and a narrow string literal are adjacent, as in the following example:

"hello " L"there"

the result is a wide string literal.

Note:

In C99, narrow strings can be concatenated with wide string literals. C only ends

In C++11, the changes to string literal concatenation in the C99 preprocessor are adopted to provide a common preprocessor interface for C and C++ compilers. Narrow strings can be concatenated with wide string literals in C++11. For more information, see C99 preprocessor features adopted in C++11 (C++11). C++11 ends

Following any concatenation, '\0' of type char is appended at the end of each string. For a wide string literal, '\0' of type wchar_t is appended. By convention, programs recognize the end of a string by finding the null character. For example:

char *first = "Hello ";            //stored as "Hello \0"
char *second = "there";            //stored as "there\0"
char *third = "Hello " "there";    //stored as "Hello there\0"

Voice your opinion on getting help information

Ask IBM compiler experts a technical question in the IBM XL compilers forum