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.

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


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 at the C99 language level.

IBM extension The Pascal string form of a string literal is also accepted, provided that you compile with the -qmacpstr option.

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";

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 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.

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"