Integer Constants

An integer constant can be expressed as an ordinary decimal numeral, or as a numeral in octal or hexadecimal notation. You must specify the intended notation by a prefix.

A decimal constant begins with a nonzero digit. For example, 255 is the decimal constant for the base-10 value 255.

A number that begins with a leading zero is interpreted as an octal constant. Octal (or base eight) notation uses only the digits from 0 to 7. For example, 047 is a valid octal constant representing 4 × 8 + 7, and is equivalent with the decimal constant 39. The decimal constant 255 is equal to the octal constant 0377.

A hexadecimal constant begins with the prefix 0x or 0X. The hexadecimal digits A to F can be upper- or lowercase. For example, 0xff, 0Xff, 0xFF, and 0XFF represent the same hexadecimal constant, which is equivalent to the decimal constant 255.

Because the integer constants you define will eventually be used in expressions and declarations, their type is important. The type of a constant is determined at the same time as its value is defined. Integer constants such as the examples just mentioned usually have the type int. However, if the value of an integer constant is outside the range of the type int, then it must have a bigger type. In this case, the compiler assigns it the first type in a hierarchy that is large enough to represent the value. For decimal constants, the type hierarchy is:

int, long, long long

For octal and hexadecimal constants, the type hierarchy is:

int, unsigned int, long, unsigned long, long long, unsigned long long

For example, on a 16-bit system, the decimal constant 50000 has the type long, as the greatest possible int value is 32,767, or 2¹⁵ − 1.

You can also influence the types of constants in your programs explicitly by using suffixes. A constant with the suffix l or L has the type long (or a larger type if necessary, in accordance with the hierarchies just mentioned). Similarly, a constant with the suffix ll or LL has at least the type long long. The suffix u or U can be used to ensure that the constant has an unsigned type. The long and unsigned suffixes can be combined. Table 3-1 gives a few examples.

Floating-Point Constants

Floating-point constants can be written either in decimal or in hexadecimal notation. These notations are described in the next two sections.

float  f_var = 123.456F;              // Initialize a float variable.

long double ld_var = f_var * 987E7L;  // Initialize a long double
                                      // variable with the product of
                                      // a multiplication performed
                                      // with long double precision.

Character Constants

A character constant consists of one or more characters enclosed in single quotation marks. Here are some examples:

'a'   'XY'   '0'   '*'

All the characters of the source character set are permissible in character constants, except the single quotation mark ', the backslash \, and the newline character. To represent these characters, you must use escape sequences:

'\''   '\\'   '\n'

In the fifth translation phase (see “How the C Compiler Works”), characters and escape sequences in character constants are converted into the corresponding characters of the execution character set. All the escape sequences that are permitted in character constants are described in “Escape Sequences”.

Wide-character constants are character constants defined with one of the prefixes L, u, or U. They have a different type and value range from character constants defined without a prefix.

#include <stdio.h>
int c = 0;

/* ... */

c = getchar();                          // Read a character.
if ( c != EOF && c > '0' && c < '6' )   // Compare input to character
                                        // constants.
{
  /* This block is executed if the user entered a digit from 1 to 5. */
}

int c = '\xA3';                       // Symbol for pounds sterling
printf("Character: %c     Code: %d\n", c, c);

Character: £     Code: -93

String Literals

A string literal consists of a sequence of characters (and/or escape sequences) enclosed in double quotation marks. For example:

"Hello world!\n"

The individual characters of a string literal are governed by the same rules described for the values of characters in character constants. String literals may contain all the multibyte characters of the source character set. The only exceptions are the double quotation mark ", the backslash \, and the newline character, which must be represented by escape sequences. For example, each backslash character in Windows directory paths must be written as \\. The following printf statement first produces an alert tone, and then indicates a documentation directory in quotation marks, substituting the string literal addressed by the pointer argument doc_path for the conversion specification %s:

char doc_path[128] = ".\\share\\doc";    // That is, ".\share\doc"
printf("\aSee the documentation in the directory \"%s\"\n", doc_path);

A string literal is a static array of char that contains character codes followed by a string terminator, the null character \0 (see also Chapter 8). The empty string "" occupies exactly one byte in memory, which holds the terminating null character. Characters that cannot be represented in one byte are stored as multibyte characters.

As illustrated in the previous example, you can use a string literal to initialize a char array. A string literal can also be used to initialize a pointer to char:

char *pStr = "Hello, world!";     // pStr points to the first
                                  // character, 'H'

In such an initializer, the string literal represents the address of its first element, just as an array name would.

In Example 3-1, the array error_msg contains three pointers to char, each of which is assigned the address of the first character of a string literal.

#include <stdlib.h>
#include <stdio.h>
void error_exit(unsigned int error_n)  // Print a last error message
{                                      // and exit the program.
  char * error_msg[] = { "Unknown error code.\n",
                         "Insufficient memory.\n",
                         "Illegal memory access.\n" };
  unsigned int arr_len = sizeof(error_msg)/sizeof(char *);

  if ( error_n >= arr_len )
     error_n = 0;
  fputs( error_msg[error_n], stderr );
  exit(1);
}

The C11 standard provides a new prefix, u8, which allows you to define a UTF-8 string literal. The multibyte characters in the char array defined by a UTF-8 string literal are encoded in UTF-8. A string literal of the form u8"…" is thus no different from a string literal without a prefix if the implementation’s default encoding for multibyte characters is UTF-8.

Like wide-character constants, you can also specify string literals as strings of wide characters by using one of the prefixes L, u, or U. In this way, you define what is called a wide-string literal, which yields an array of wide characters ending with a character with the value 0. The prefix determines the array elements’ type.

A wide-string literal is defined using the prefix L:

L"Here's a wide-string literal."

This expression defines a static null-terminated array of elements of the type wchar_t. The array is initialized by converting the multibyte characters in the string literal to wide characters in the same way as the standard function mbstowcs() (“multibyte string to wide-character string”) would do.

The prefixes u and U, introduced in C11, yield a static array of wide characters of the type char16_t or char32_t. The multibyte characters in these wide-string literals are implicitly converted to wide characters by successive calls to the function mbrtoc16() or mbrtoc32().

If a multibyte character or an escape sequence in a string literal is not representable in the execution character set, the value of the string literal is not specified—that is, it depends on the compiler.

In the following example, \u03b1 is the universal name for the character α, and wprintf() is the wide-character version of the printf function, which formats and prints a string of wide characters:

double angle_alpha = 90.0/3;
wprintf( L"Angle \u03b1 measures %lf degrees.\n", angle_alpha );

The compiler’s preprocessor concatenates any adjacent string literals—that is, those that are separated only by whitespace—into a single string. As the following example illustrates, this concatenation also makes it simple to break up a string into several lines for readability:

#define PRG_NAME "EasyLine"
char msg[ ] = "The installation of " PRG_NAME
              " is now complete.";

If any of the string literals involved has a prefix, then the resulting string is treated as a string literal with that prefix. Whether string literals with different prefixes can be concatenated depends on the compiler.

Another way to break a string literal into several lines is to end a line with a backslash, as in this example:

char info[ ] =
"This is a string literal broken up into\
  several source code lines.\nNow one more line:\n\
 that's enough, the string ends here.";

The string continues at the beginning of the next line: any spaces at the left margin, such as the space before several in the preceding example, are part of the string literal. Furthermore, the string literal defined here contains exactly two newline characters: one immediately before Now, and one immediately before that's; in other words, only the two that are explicitly written as \n.

The compiler interprets escape sequences before concatenating adjacent strings (see “The C Compiler’s Translation Phases”). As a result, the following two string literals form one wide-character string that begins with the two characters '\xA7' and '2':

L"\xA7" L"2 et cetera"

However, if the string is written in one piece as L"\xA72 et cetera", then the first character in the string is the wide character '\xA72'.

Although C does not strictly prohibit modifying string literals, you should not attempt to do so. In the following example, the second statement is an attempt to replace the first character of a string:

char *p = "house";         // Initialize a pointer to char.
*p = 'm';                  // This is *not* a good idea!

This statement is not portable, and causes a runtime error on some systems. For one thing, the compiler, treating the string literal as a constant, may place it in read-only memory, in which case the attempted write operation causes a fault. For another, if two or more identical string literals are used in the program, the compiler may store them at the same location, so that modifying one causes unexpected results when you access another.

However, if you use a string literal to initialize an array variable, you can then modify the contents of the array:

char s[] = "house";      // Initialize an array of char.
s[0] = 'm';              // Now the array contains the string "mouse".

In the same way, arrays whose elements have the type wchar_t, char16_t, or char32_t can be initialized using an appropriate wide-string literal.