1.1 Example: Recursive Fibonacci

To introduce the most basic features of C, let’s look at code for a simple mathematical function that does calculations on integers. This function calculates the nth number in the Fibonacci series, in which each number is the sum of the previous two: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ….

int
fib (int n)
{
  if (n <= 2)  /* This avoids infinite recursion.  */
    return 1;
  else
    return fib (n - 1) + fib (n - 2);
}

This very simple program illustrates several features of C:

• A function definition, whose first two lines constitute the function header. See Function Definitions.
• A function parameter n, referred to as the variable n inside the function body. See Function Parameter Variables. A function definition uses parameters to refer to the argument values provided in a call to that function.
• Arithmetic. C programs add with ‘+’ and subtract with ‘-’. See Arithmetic.
• Numeric comparisons. The operator ‘<=’ tests for “less than or equal.” See Numeric Comparisons.
• Integer constants written in base 10. See Integer Constants.
• A function call. The function call fib (n - 1) calls the function fib, passing as its argument the value n - 1. See Function Calls.
• A comment, which starts with ‘/*’ and ends with ‘*/’. The comment has no effect on the execution of the program. Its purpose is to provide explanations to people reading the source code. Including comments in the code is tremendously important—they provide background information so others can understand the code more quickly. See Comments.

  In this manual, we present comment text in the variable-width typeface used for the text of the chapters, not in the fixed-width typeface used for the rest of the code. That is to make comments easier to read. This distinction of typeface does not exist in a real file of C source code.

• Two kinds of statements, the return statement and the if…else statement. See Statements.
• Recursion. The function fib calls itself; that is called a recursive call. These are valid in C, and quite common.

  The fib function would not be useful if it didn’t return. Thus, recursive definitions, to be of any use, must avoid infinite recursion.

  This function definition prevents infinite recursion by specially handling the case where n is two or less. Thus the maximum depth of recursive calls is less than n.

• Function Header
• Function Body

int
fib (int n)

1.2 The Stack, And Stack Overflow

Recursion has a drawback: there are limits to how many nested levels of function calls a program can make. In C, each function call allocates a block of memory which it uses until the call returns. C allocates these blocks consecutively within a large area of memory known as the stack, so we refer to the blocks as stack frames.

The size of the stack is limited; if the program tries to use too much, that causes the program to fail because the stack is full. This is called stack overflow.

Stack overflow on GNU/Linux typically manifests itself as the signal named SIGSEGV, also known as a “segmentation fault.” By default, this signal terminates the program immediately, rather than letting the program try to recover, or reach an expected ending point. (We commonly say in this case that the program “crashes”). See Signals.

It is inconvenient to observe a crash by passing too large an argument to recursive Fibonacci, because the program would run a long time before it crashes. This algorithm is simple but ridiculously slow: in calculating fib (n), the number of (recursive) calls fib (1) or fib (2) that it makes equals the final result.

However, you can observe stack overflow very quickly if you use this function instead:

int
fill_stack (int n)
{
  if (n <= 1)  /* This limits the depth of recursion.  */
    return 1;
  else
    return fill_stack (n - 1);
}

Under gNewSense GNU/Linux on the Lemote Yeeloong, without optimization and using the default configuration, an experiment showed there is enough stack space to do 261906 nested calls to that function. One more, and the stack overflows and the program crashes. On another platform, with a different configuration, or with a different function, the limit might be bigger or smaller.

1.3 Example: Iterative Fibonacci

Here’s a much faster algorithm for computing the same Fibonacci series. It is faster for two reasons. First, it uses iteration (that is, repetition or looping) rather than recursion, so it doesn’t take time for a large number of function calls. But mainly, it is faster because the number of repetitions is small—only n.

int
fib (int n)
{
  int last = 1;   /* Initial value is fib (1).  */
  int prev = 0;   /* Initial value controls fib (2).  */
  int i;

  for (i = 1; i < n; ++i)
    /* If n is 1 or less, the loop runs zero times,  */
    /* since i < n is false the first time.  */
    {
      /* Now last is fib (i)
         and prev is fib (i - 1).  */
      /* Compute fib (i + 1).  */
      int next = prev + last;
      /* Shift the values down.  */
      prev = last;
      last = next;
      /* Now last is fib (i + 1)
         and prev is fib (i).
         But that won’t stay true for long,
         because we are about to increment i.  */
    }

  return last;
}

This definition computes fib (n) in a time proportional to n. The comments in the definition explain how it works: it advances through the series, always keeps the last two values in last and prev, and adds them to get the next value.

Here are the additional C features that this definition uses:

Internal blocks

Within a function, wherever a statement is called for, you can write a block. It looks like { … } and contains zero or more statements and declarations. (You can also use additional blocks as statements in a block.)

The function body also counts as a block, which is why it can contain statements and declarations.

See Blocks.

Declarations of local variables

This function body contains declarations as well as statements. There are three declarations directly in the function body, as well as a fourth declaration in an internal block. Each starts with int because it declares a variable whose type is integer. One declaration can declare several variables, but each of these declarations is simple and declares just one variable.

Variables declared inside a block (either a function body or an internal block) are local variables. These variables exist only within that block; their names are not defined outside the block, and exiting the block deallocates their storage. This example declares four local variables: last, prev, i, and next.

The most basic local variable declaration looks like this:

type variablename;

For instance,

int i;

declares the local variable i as an integer. See Variable Declarations.

Initializers

When you declare a variable, you can also specify its initial value, like this:

type variablename = value;

For instance,

int last = 1;

declares the local variable last as an integer (type int) and starts it off with the value 1. See Initializers.

Assignment

Assignment: a specific kind of expression, written with the ‘=’ operator, that stores a new value in a variable or other place. Thus,

variable = value

is an expression that computes value and stores the value in variable. See Assignment Expressions.

Expression statements

An expression statement is an expression followed by a semicolon. That computes the value of the expression, then ignores the value.

An expression statement is useful when the expression changes some data or has other side effects—for instance, with function calls, or with assignments as in this example. See Expression Statement.

Using an expression with no side effects in an expression statement is pointless except in very special cases. For instance, the expression statement x; would examine the value of x and ignore it. That is not useful.

Increment operator

The increment operator is ‘++’. ++i is an expression that is short for i = i + 1. See Increment and Decrement Operators.

for statements

A for statement is a clean way of executing a statement repeatedly—a loop (see Loop Statements). Specifically,

for (i = 1; i < n; ++i)
  body

means to start by doing i = 1 (set i to one) to prepare for the loop. The loop itself consists of

• Testing i < n and exiting the loop if that’s false.
• Executing body.
• Advancing the loop (executing ++i, which increments i).

The net result is to execute body with 1 in i, then with 2 in i, and so on, stopping just before the repetition where i would equal n. If n is less than 1, the loop will execute the body zero times.

The body of the for statement must be one and only one statement. You can’t write two statements in a row there; if you try to, only the first of them will be treated as part of the loop.

The way to put multiple statements in such a place is to group them with a block, and that’s what we do in this example.

2.1 Complete Program Example

Here is the complete program that uses the simple, recursive version of the fib function (see Example: Recursive Fibonacci):

#include <stdio.h>

int
fib (int n)
{
  if (n <= 2)  /* This avoids infinite recursion.  */
    return 1;
  else
    return fib (n - 1) + fib (n - 2);
}

int
main (void)
{
  printf ("Fibonacci series item %d is %d\n",
          20, fib (20));
  return 0;
}

This program prints a message that shows the value of fib (20).

Now for an explanation of what that code means.

2.2 Complete Program Explanation

Here’s the explanation of the code of the example in the previous section.

This sample program prints a message that shows the value of fib (20), and exits with code 0 (which stands for successful execution).

Every C program is started by running the function named main. Therefore, the example program defines a function named main to provide a way to start it. Whatever that function does is what the program does. See The main Function.

The main function is the first one called when the program runs, but it doesn’t come first in the example code. The order of the function definitions in the source code makes no difference to the program’s meaning.

The initial call to main always passes certain arguments, but main does not have to pay attention to them. To ignore those arguments, define main with void as the parameter list. (void as a function’s parameter list normally means “call with no arguments,” but main is a special case.)

The function main returns 0 because that is the conventional way for main to indicate successful execution. It could instead return a positive integer to indicate failure, and some utility programs have specific conventions for the meaning of certain numeric failure codes. See Returning Values from main.

The simplest way to print text in C is by calling the printf function, so here we explain very briefly what that function does. For a full explanation of printf and the other standard I/O functions, see The GNU C Library in The GNU C Library Reference Manual.

The first argument to printf is a string constant (see String Constants) that is a template for output. The function printf copies most of that string directly as output, including the newline character at the end of the string, which is written as ‘\n’. The output goes to the program’s standard output destination, which in the usual case is the terminal.

‘%’ in the template introduces a code that substitutes other text into the output. Specifically, ‘%d’ means to take the next argument to printf and substitute it into the text as a decimal number. (The argument for ‘%d’ must be of type int; if it isn’t, printf will malfunction.) So the output is a line that looks like this:

Fibonacci series item 20 is 6765

This program does not contain a definition for printf because it is defined by the C library, which makes it available in all C programs. However, each program does need to declare printf so it will be called correctly. The #include line takes care of that; it includes a header file called stdio.h into the program’s code. That file is provided by the operating system and it contains declarations for the many standard input/output functions in the C library, one of which is printf.

Don’t worry about header files for now; we’ll explain them later in Header Files.

The first argument of printf does not have to be a string constant; it can be any string (see Strings). However, using a constant is the most common case.

2.3 Complete Program, Line by Line

Here’s the same example, explained line by line. Beginners, do you find this helpful or not? Would you prefer a different layout for the example? Please tell rms@gnu.org.

#include <stdio.h>      /* Include declaration of usual */
                        /*   I/O functions such as printf.  */
                        /* Most programs need these.  */

int                     /* This function returns an int.  */
fib (int n)             /* Its name is fib;  */
                        /*   its argument is called n.  */
{                       /* Start of function body.  */
  /* This stops the recursion from being infinite.  */
  if (n <= 2)           /* If n is 1 or 2,  */
    return 1;           /*   make fib return 1.  */
  else                  /* otherwise, add the two previous  */
                        /* Fibonacci numbers.  */
    return fib (n - 1) + fib (n - 2);
}

int                     /* This function returns an int.  */
main (void)             /* Start here; ignore arguments.  */
{                       /* Print message with numbers in it.  */
  printf ("Fibonacci series item %d is %d\n",
          20, fib (20));
  return 0;             /* Terminate program, report success.  */
}

2.4 Compiling the Example Program

To run a C program requires converting the source code into an executable file. This is called compiling the program, and the command to do that using GNU C is gcc.

This example program consists of a single source file. If we call that file fib1.c, the complete command to compile it is this:

gcc -g -O -o fib1 fib1.c

Here, -g says to generate debugging information, -O says to optimize at the basic level, and -o fib1 says to put the executable program in the file fib1.

To run the program, use its file name as a shell command. For instance,

./fib1

However, unless you are sure the program is correct, you should expect to need to debug it. So use this command,

gdb fib1

which starts the GDB debugger (see A Sample GDB Session in Debugging with GDB) so you can run and debug the executable program fib1.

Richard Stallman’s advice, from personal experience, is to turn to the debugger as soon as you can reproduce the problem. Don’t try to avoid it by using other methods instead—occasionally they are shortcuts, but usually they waste an unbounded amount of time. With the debugger, you will surely find the bug in a reasonable time; overall, you will get your work done faster. The sooner you get serious and start the debugger, the sooner you are likely to find the bug.

See Compilation, for an introduction to compiling more complex programs which consist of more than one source file.

4.1 An Example with Non-Integer Numbers

Here’s a function that operates on and returns floating point numbers that don’t have to be integers. Floating point represents a number as a fraction together with a power of 2. (For more detail, see Floating-Point Data Types.) This example calculates the average of three floating point numbers that are passed to it as arguments:

double
average_of_three (double a, double b, double c)
{
  return (a + b + c) / 3;
}

The values of the parameter a, b and c do not have to be integers, and even when they happen to be integers, most likely their average is not an integer.

double is the usual data type in C for calculations on floating-point numbers.

To print a double with printf, we must use ‘%f’ instead of ‘%d’:

printf ("Average is %f\n",
        average_of_three (1.1, 9.8, 3.62));

The code that calls printf must pass a double for printing with ‘%f’ and an int for printing with ‘%d’. If the argument has the wrong type, printf will produce meaningless output.

Here’s a complete program that computes the average of three specific numbers and prints the result:

double
average_of_three (double a, double b, double c)
{
  return (a + b + c) / 3;
}

int
main (void)
{
    printf ("Average is %f\n",
            average_of_three (1.1, 9.8, 3.62));
    return 0;
}

From now on we will not present examples of calls to main. Instead we encourage you to write them for yourself when you want to test executing some code.

4.2 An Example with Arrays

A function to take the average of three numbers is very specific and limited. A more general function would take the average of any number of numbers. That requires passing the numbers in an array. An array is an object in memory that contains a series of values of the same data type. This chapter presents the basic concepts and use of arrays through an example; for the full explanation, see Arrays.

Here’s a function definition to take the average of several floating-point numbers, passed as type double. The first parameter, length, specifies how many numbers are passed. The second parameter, input_data, is an array that holds those numbers.

double
avg_of_double (int length, double input_data[])
{
  double sum = 0;
  int i;

  for (i = 0; i < length; i++)
    sum = sum + input_data[i];

  return sum / length;
}

This introduces the expression to refer to an element of an array: input_data[i] means the element at index i in input_data. The index of the element can be any expression with an integer value; in this case, the expression is i. See Accessing Array Elements.

The lowest valid index in an array is 0, not 1, and the highest valid index is one less than the number of elements. (This is known as zero-origin indexing.)

This example also introduces the way to declare that a function parameter is an array. Such declarations are modeled after the syntax for an element of the array. Just as double foo declares that foo is of type double, double input_data[] declares that each element of input_data is of type double. Therefore, input_data itself has type “array of double.”

When declaring an array parameter, it’s not necessary to say how long the array is. In this case, the parameter input_data has no length information. That’s why the function needs another parameter, length, for the caller to provide that information to the function avg_of_double.

4.3 Calling the Array Example

To call the function avg_of_double requires making an array and then passing it as an argument. Here is an example.

{
  /* The array of values to average.  */
  double nums_to_average[5];
  /* The average, once we compute it.  */
  double average;

  /* Fill in elements of nums_to_average.  */

  nums_to_average[0] = 58.7;
  nums_to_average[1] = 5.1;
  nums_to_average[2] = 7.7;
  nums_to_average[3] = 105.2;
  nums_to_average[4] = -3.14159;

  average = avg_of_double (5, nums_to_average);

  /* …now make use of average… */
}

This shows an array subscripting expression again, this time on the left side of an assignment, storing a value into an element of an array.

It also shows how to declare a local variable that is an array: double nums_to_average[5];. Since this declaration allocates the space for the array, it needs to know the array’s length. You can specify the length with any expression whose value is an integer, but in this declaration the length is a constant, the integer 5.

The name of the array, when used by itself as an expression, stands for the address of the array’s data, and that’s what gets passed to the function avg_of_double in avg_of_double (5, nums_to_average).

We can make the code easier to maintain by avoiding the need to write 5, the array length, when calling avg_of_double. That way, if we change the array to include more elements, we won’t have to change that call. One way to do this is with the sizeof operator:

  average = avg_of_double ((sizeof (nums_to_average)
                            / sizeof (nums_to_average[0])),
                           nums_to_average);

This computes the number of elements in nums_to_average by dividing its total size by the size of one element. See Type Size, for more details of using sizeof.

We don’t show in this example what happens after storing the result of avg_of_double in the variable average. Presumably more code would follow that uses that result somehow. (Why compute the average and not use it?) But that isn’t part of this topic.

4.4 Variations for Array Example

The code to call avg_of_double has two declarations that start with the same data type:

  /* The array of values to average.  */
  double nums_to_average[5];
  /* The average, once we compute it.  */
  double average;

In C, you can combine the two, like this:

  double nums_to_average[5], average;

This declares nums_to_average so each of its elements is a double, and average so that it simply is a double.

However, while you can combine them, that doesn’t mean you should. If it is useful to write comments about the variables, and usually it is, then it’s clearer to keep the declarations separate so you can put a comment on each one. That also helps with using textual tools to find occurrences of a variable in source files.

We set all of the elements of the array nums_to_average with assignments, but it is more convenient to use an initializer in the declaration:

{
  /* The array of values to average.  */
  double nums_to_average[]
    = { 58.7, 5.1, 7.7, 105.2, -3.14159 };

  /* The average, once we compute it.  */
  average = avg_of_double ((sizeof (nums_to_average)
                            / sizeof (nums_to_average[0])),
                           nums_to_average);

  /* …now make use of average… */
}

The array initializer is a comma-separated list of values, delimited by braces. See Initializers.

Note that the declaration does not specify a size for nums_to_average, so the size is determined from the initializer. There are five values in the initializer, so nums_to_average gets length 5. If we add another element to the initializer, nums_to_average will have six elements.

Because the code computes the number of elements from the size of the array, using sizeof, the program will operate on all the elements in the initializer, regardless of how many those are.

5.1 Write Programs in English!

In principle, you can write the function and variable names in a program, and the comments, in any human language. C allows any kinds of Unicode characters in comments, and you can put them into identifiers with a special prefix (see Unicode Character Codes). However, to enable programmers in all countries to understand and develop the program, it is best under today’s circumstances to write all identifiers and comments in English.

English is the common language of programmers; in all countries, programmers generally learn English. If names and comments in a program are written in English, most programmers in Bangladesh, Belgium, Bolivia, Brazil, Bulgaria and Burundi can understand them. In all those countries, most programmers can speak English, or at least read it, but they do not read each other’s languages at all. In India, with so many languages, two programmers may have no common language other than English.

If you don’t feel confident in writing English, do the best you can, and follow each English comment with a version in a language you write better; add a note asking others to translate that to English. Someone will eventually do that.

The program’s user interface is a different matter. We don’t need to choose one language for that; it is easy to support multiple languages and let each user choose the language for display. This requires writing the program to support localization of its interface. (The gettext package exists to support this; see The GNU C Library in The GNU C Library Reference Manual.) Then a community-based translation effort can provide support for all the languages users want to use.

5.2 Characters

GNU C source files are usually written in the ASCII character set, which was defined in the 1960s for English. However, they can also include Unicode characters represented in the UTF-8 multibyte encoding. This makes it possible to represent accented letters such as ‘á’, as well as other scripts such as Arabic, Chinese, Cyrillic, Hebrew, Japanese, and Korean.¹

In C source code, non-ASCII characters are valid in comments, in wide character constants (see Wide Character Constants), and in string constants (see String Constants).

Another way to specify non-ASCII characters in constants (character or string) and identifiers is with an escape sequence starting with backslash, specifying the intended Unicode character. (See Unicode Character Codes.) This specifies non-ASCII characters without putting a real non-ASCII character in the source file itself.

C accepts two-character aliases called digraphs for certain characters. See Digraphs.

5.3 Whitespace

Whitespace means characters that exist in a file but appear blank in a printed listing of a file (or traditionally did appear blank, several decades ago). The C language requires whitespace in order to separate two consecutive identifiers, or to separate an identifier from a numeric constant. Other than that, and a few special situations described later, whitespace is optional; you can put it in when you wish, to make the code easier to read.

Space and tab in C code are treated as whitespace characters. So are line breaks. You can represent a line break with the newline character (also called linefeed or LF), CR (carriage return), or the CRLF sequence (two characters: carriage return followed by a newline character).

The formfeed character, Control-L, was traditionally used to divide a file into pages. It is still used this way in source code, and the tools that generate nice printouts of source code still start a new page after each “formfeed” character. Dividing code into pages separated by formfeed characters is a good way to break it up into comprehensible pieces and show other programmers where they start and end.

The vertical tab character, Control-K, was traditionally used to make printing advance down to the next section of a page. We know of no particular reason to use it in source code, but it is still accepted as whitespace in C.

Comments are also syntactically equivalent to whitespace.

5.4 Comments

A comment encapsulates text that has no effect on the program’s execution or meaning.

The purpose of comments is to explain the code to people that read it. Writing good comments for your code is tremendously important—they should provide background information that helps programmers understand the reasons why the code is written the way it is. You, returning to the code six months from now, will need the help of these comments to remember why you wrote it this way.

Outdated comments that become incorrect are counterproductive, so part of the software developer’s responsibility is to update comments as needed to correspond with changes to the program code.

C allows two kinds of comment syntax, the traditional style and the C++ style. A traditional C comment starts with ‘/*’ and ends with ‘*/’. For instance,

/* This is a comment in traditional C syntax. */

A traditional comment can contain ‘/*’, but these delimiters do not nest as pairs. The first ‘*/’ ends the comment regardless of whether it contains ‘/*’ sequences.

/* This /* is a comment */ But this is not! */

A line comment starts with ‘//’ and ends at the end of the line. For instance,

// This is a comment in C++ style.

Line comments do nest, in effect, because ‘//’ inside a line comment is part of that comment:

// this whole line is // one comment
This is code, not comment.

It is safe to put line comments inside block comments, or vice versa.

/* traditional comment
   // contains line comment
   more traditional comment
 */ text here is not a comment

// line comment /* contains traditional comment */

But beware of commenting out one end of a traditional comment with a line comment. The delimiter ‘/*’ doesn’t start a comment if it occurs inside an already-started comment.

 // line comment  /* That would ordinarily begin a block comment.
    Oops! The line comment has ended;
    this isn't a comment any more.  */

Comments are not recognized within string constants. "/* blah */" is the string constant ‘/* blah */’, not an empty string.

In this manual we show the text in comments in a variable-width font, for readability, but this font distinction does not exist in source files.

A comment is syntactically equivalent to whitespace, so it always separates tokens. Thus,

  int/* comment */foo;
is equivalent to
  int foo;

but clean code always uses real whitespace to separate the comment visually from surrounding code.

5.5 Identifiers

An identifier (name) in C is a sequence of letters and digits, as well as ‘_’, that does not start with a digit. Most compilers also allow ‘$’. An identifier can be as long as you like; for example,

int anti_dis_establishment_arian_ism;

Letters in identifiers are case-sensitive in C; thus, a and A are two different identifiers.

Identifiers in C are used as variable names, function names, typedef names, enumeration constants, type tags, field names, and labels. Certain identifiers in C are keywords, which means they have specific syntactic meanings. Keywords in C are reserved words, meaning you cannot use them in any other way. For instance, you can’t define a variable or function named return or if.

You can also include other characters, even non-ASCII characters, in identifiers by writing their Unicode character names, which start with ‘\u’ or ‘\U’, in the identifier name. See Unicode Character Codes. However, it is usually a bad idea to use non-ASCII characters in identifiers, and when the names are written in English, they never need non-ASCII characters. See Write Programs in English!.

As stated above, whitespace is required to separate two consecutive identifiers, or to separate an identifier from a preceding or following numeric constant.

5.6 Operators and Punctuation

Here we describe the lexical syntax of operators and punctuation in C. The specific operators of C and their meanings are presented in subsequent chapters.

Most operators in C consist of one or two characters that can’t be used in identifiers. The characters used for operators in C are ‘!~^&|*/%+-=<>,.?:’.

Some operators are a single character. For instance, ‘-’ is the operator for negation (with one operand) and the operator for subtraction (with two operands).

Some operators are two characters. For example, ‘++’ is the increment operator. Recognition of multicharacter operators works by grouping together as many consecutive characters as can constitute one operator.

For instance, the character sequence ‘++’ is always interpreted as the increment operator; therefore, if we want to write two consecutive instances of the operator ‘+’, we must separate them with a space so that they do not combine as one token. Applying the same rule, a+++++b is always tokenized as a++ ++ + b, not as a++ + ++b, even though the latter could be part of a valid C program and the former could not (since a++ is not an lvalue and thus can’t be the operand of ++).

A few C operators are keywords rather than special characters. They include sizeof (see Type Size) and _Alignof (see Type Alignment).

The characters ‘;{}[]()’ are used for punctuation and grouping. Semicolon (‘;’) ends a statement. Braces (‘{’ and ‘}’) begin and end a block at the statement level (see Blocks), and surround the initializer (see Initializers) for a variable with multiple elements or fields (such as arrays or structures).

Square brackets (‘[’ and ‘]’) do array indexing, as in array[5].

Parentheses are used in expressions for explicit nesting of expressions (see Basic Arithmetic), around the parameter declarations in a function declaration or definition, and around the arguments in a function call, as in printf ("Foo %d\n", i) (see Function Calls). Several kinds of statements also use parentheses as part of their syntax—for instance, if statements, for statements, while statements, and switch statements. See if Statement, and following sections.

Parentheses are also required around the operand of the operator keywords sizeof and _Alignof when the operand is a data type rather than a value. See Type Size.

5.7 Line Continuation

The sequence of a backslash and a newline is ignored absolutely anywhere in a C program. This makes it possible to split a single source line into multiple lines in the source file. GNU C tolerates and ignores other whitespace between the backslash and the newline. In particular, it always ignores a CR (carriage return) character there, in case some text editor decided to end the line with the CRLF sequence.

The main use of line continuation in C is for macro definitions that would be inconveniently long for a single line (see Macros).

It is possible to continue a line comment onto another line with backslash-newline. You can put backslash-newline in the middle of an identifier, even a keyword, or an operator. You can even split ‘/*’, ‘*/’, and ‘//’ onto multiple lines with backslash-newline. Here’s an ugly example:

/\
*
*/ fo\
o +\
= 1\
0;

That’s equivalent to ‘/* */ foo += 10;’.

Don’t do those things in real programs, since they make code hard to read.

Note: For the sake of using certain tools on the source code, it is wise to end every source file with a newline character which is not preceded by a backslash, so that it really ends the last line.

6.1 Basic Arithmetic

Basic arithmetic in C is done with the usual binary operators of algebra: addition (‘+’), subtraction (‘-’), multiplication (‘*’) and division (‘/’). The unary operator ‘-’ is used to change the sign of a number. The unary + operator also exists; it yields its operand unaltered.

‘/’ is the division operator, but dividing integers may not give the result you expect. Its value is an integer, which is not equal to the mathematical quotient when that is a fraction. Use ‘%’ to get the corresponding integer remainder when necessary. See Division and Remainder. Floating point division yields value as close as possible to the mathematical quotient.

These operators use algebraic syntax with the usual algebraic precedence rule (see Binary Operator Grammar) that multiplication and division are done before addition and subtraction, but you can use parentheses to explicitly specify how the operators nest. They are left-associative (see Associativity and Ordering). Thus,

-a + b - c + d * e / f

is equivalent to

(((-a) + b) - c) + ((d * e) / f)

6.2 Integer Arithmetic

Each of the basic arithmetic operations in C has two variants for integers: signed and unsigned. The choice is determined by the data types of their operands.

Each integer data type in C is either signed or unsigned. A signed type can hold a range of positive and negative numbers, with zero near the middle of the range. An unsigned type can hold only nonnegative numbers; its range starts with zero and runs upward.

The most basic integer types are int, which normally can hold numbers from -2,147,483,648 to 2,147,483,647, and unsigned int, which normally can hold numbers from 0 to 4,294,967,295. (This assumes int is 32 bits wide, always true for GNU C on real computers but not always on embedded controllers.) See Integer Data Types, for full information about integer types.

When a basic arithmetic operation is given two signed operands, it does signed arithmetic. Given two unsigned operands, it does unsigned arithmetic.

If one operand is unsigned int and the other is int, the operator treats them both as unsigned. More generally, the common type of the operands determines whether the operation is signed or not. See Common Type.

Printing the results of unsigned arithmetic with printf using ‘%d’ can produce surprising results for values far away from zero. Even though the rules above say that the computation was done with unsigned arithmetic, the printed result may appear to be signed!

The explanation is that the bit pattern resulting from addition, subtraction or multiplication is actually the same for signed and unsigned operations. The difference is only in the data type of the result, which affects the interpretation of the result bit pattern, and whether the arithmetic operation can overflow (see the next section).

But ‘%d’ doesn’t know its argument’s data type. It sees only the value’s bit pattern, and it is defined to interpret that as signed int. To print it as unsigned requires using ‘%u’ instead of ‘%d’. See The GNU C Library in The GNU C Library Reference Manual.

Arithmetic in C never operates directly on narrow integer types (those with fewer bits than int; Narrow Integers). Instead it “promotes” them to int. See Operand Promotions.

6.3 Integer Overflow

When the mathematical value of an arithmetic operation doesn’t fit in the range of the data type in use, that’s called overflow. When it happens in integer arithmetic, it is integer overflow.

Integer overflow happens only in arithmetic operations. Type conversion operations, by definition, do not cause overflow, not even when the result can’t fit in its new type. See Conversion among Integer Types.

Signed numbers use two’s-complement representation, in which the most negative number lacks a positive counterpart (see Integers in Depth). Thus, the unary ‘-’ operator on a signed integer can overflow.

• Overflow with Unsigned Integers
• Overflow with Signed Integers

unsigned int x = 1;
unsigned int y;

y = -x;

unsigned int z;

z = y + y;

int i;
…
if (i < i + 1)
  x = 5;

6.4 Mixed-Mode Arithmetic

Mixing integers and floating-point numbers in a basic arithmetic operation converts the integers automatically to floating point. In most cases, this gives exactly the desired results. But sometimes it matters precisely where the conversion occurs.

If i and j are integers, (i + j) * 2.0 adds them as an integer, then converts the sum to floating point for the multiplication. If the addition causes an overflow, that is not equivalent to converting each integer to floating point and then adding the two floating point numbers. You can get the latter result by explicitly converting the integers, as in ((double) i + (double) j) * 2.0. See Explicit Type Conversion.

Adding or multiplying several values, including some integers and some floating point, performs the operations left to right. Thus, 3.0 + i + j converts i to floating point, then adds 3.0, then converts j to floating point and adds that. You can specify a different order using parentheses: 3.0 + (i + j) adds i and j first and then adds that sum (converted to floating point) to 3.0. In this respect, C differs from other languages, such as Fortran.

6.5 Division and Remainder

Division of integers in C rounds the result to an integer. The result is always rounded towards zero.

 16 / 3  ⇒ 5
-16 / 3  ⇒ -5
 16 / -3 ⇒ -5
-16 / -3 ⇒ 5

To get the corresponding remainder, use the ‘%’ operator:

 16 % 3  ⇒ 1
-16 % 3  ⇒ -1
 16 % -3 ⇒ 1
-16 % -3 ⇒ -1

‘%’ has the same operator precedence as ‘/’ and ‘*’.

From the rounded quotient and the remainder, you can reconstruct the dividend, like this:

int
original_dividend (int divisor, int quotient, int remainder)
{
  return divisor * quotient + remainder;
}

To do unrounded division, use floating point. If only one operand is floating point, ‘/’ converts the other operand to floating point.

16.0 / 3   ⇒ 5.333333333333333
16   / 3.0 ⇒ 5.333333333333333
16.0 / 3.0 ⇒ 5.333333333333333
16   / 3   ⇒ 5

The remainder operator ‘%’ is not allowed for floating-point operands, because it is not needed. The concept of remainder makes sense for integers because the result of division of integers has to be an integer. For floating point, the result of division is a floating-point number, in other words a fraction, which will differ from the exact result only by a very small amount.

There are functions in the standard C library to calculate remainders from integral-values division of floating-point numbers. See The GNU C Library in The GNU C Library Reference Manual.

Integer division overflows in one specific case: dividing the smallest negative value for the data type (see Maximum and Minimum Values) by -1. That’s because the correct result, which is the corresponding positive number, does not fit (see Integer Overflow) in the same number of bits. On some computers now in use, this always causes a signal SIGFPE (see Signals), the same behavior that the option -ftrapv specifies (see Overflow with Signed Integers).

Division by zero leads to unpredictable results—depending on the type of computer, it might cause a signal SIGFPE, or it might produce a numeric result.

Watch out: Make sure the program does not divide by zero. If you can’t prove that the divisor is not zero, test whether it is zero, and skip the division if so.

6.6 Numeric Comparisons

There are two kinds of comparison operators: equality and ordering. Equality comparisons test whether two expressions have the same value. The result is a truth value: a number that is 1 for “true” and 0 for “false.”

a == b   /* Test for equal.  */
a != b   /* Test for not equal.  */

The equality comparison is written == because plain = is the assignment operator.

Ordering comparisons test which operand is greater or less. Their results are truth values. These are the ordering comparisons of C:

a < b   /* Test for less-than.  */
a > b   /* Test for greater-than.  */
a <= b  /* Test for less-than-or-equal.  */
a >= b  /* Test for greater-than-or-equal.  */

For any integers a and b, exactly one of the comparisons a < b, a == b and a > b is true, just as in mathematics. However, if a and b are special floating point values (not ordinary numbers), all three can be false. See Special Floating-Point Values, and Invalid Optimizations.

6.7 Shift Operations

Shifting an integer means moving the bit values to the left or right within the bits of the data type. Shifting is defined only for integers. Here’s the way to write it:

/* Left shift.  */
5 << 2 ⇒ 20

/* Right shift.  */
5 >> 2 ⇒ 1

The left operand is the value to be shifted, and the right operand says how many bits to shift it (the shift count). The left operand is promoted (see Operand Promotions), so shifting never operates on a narrow integer type; it’s always either int or wider. The result of the shift operation has the same type as the promoted left operand.

• Shifting Makes New Bits
• Caveats for Shift Operations
• Shift Hacks

5 << 3     is equivalent to   5 * 2*2*2
-10 << 4   is equivalent to   -10 * 2*2*2*2

(unsigned) 19 >> 2 ⇒ 4
(unsigned) 20 >> 2 ⇒ 5
(unsigned) 21 >> 2 ⇒ 5

a + (b << 5)   /* Shift first, then add.  */
(a + b) << 5   /* Add first, then shift.  */

unsigned int d = 12;
unsigned int m = 6;
unsigned int y = 1983;
unsigned int date = ((y << 4) + m) << 5) + d;

d = date % 32;
m = (date >> 5) % 16;
y = date >> 9;

6.8 Bitwise Operations

Bitwise operators operate on integers, treating each bit independently. They are not allowed for floating-point types.

The examples in this section use binary constants, starting with ‘0b’ (see Integer Constants). They stand for 32-bit integers of type int.

~a

Unary operator for bitwise negation; this changes each bit of a from 1 to 0 or from 0 to 1.

~0b10101000 ⇒ 0b11111111111111111111111101010111
~0 ⇒ 0b11111111111111111111111111111111
~0b11111111111111111111111111111111 ⇒ 0
~ (-1) ⇒ 0

It is useful to remember that ~x + 1 equals -x, for integers, and ~x equals -x - 1. The last example above shows this with -1 as x.

a & b

Binary operator for bitwise “and” or “conjunction.” Each bit in the result is 1 if that bit is 1 in both a and b.

0b10101010 & 0b11001100 ⇒ 0b10001000

a | b

Binary operator for bitwise “or” (“inclusive or” or “disjunction”). Each bit in the result is 1 if that bit is 1 in either a or b.

0b10101010 | 0b11001100 ⇒ 0b11101110

a ^ b

Binary operator for bitwise “xor” (“exclusive or”). Each bit in the result is 1 if that bit is 1 in exactly one of a and b.

0b10101010 ^ 0b11001100 ⇒ 0b01100110

To understand the effect of these operators on signed integers, keep in mind that all modern computers use two’s-complement representation (see Integer Representations) for negative integers. This means that the highest bit of the number indicates the sign; it is 1 for a negative number and 0 for a positive number. In a negative number, the value in the other bits increases as the number gets closer to zero, so that 0b111…111 is -1 and 0b100…000 is the most negative possible integer.

Warning: C defines a precedence ordering for the bitwise binary operators, but you should never rely on it. You should never rely on how bitwise binary operators relate in precedence to the arithmetic and shift binary operators. Other programmers don’t remember this precedence ordering, so always use parentheses to explicitly specify the nesting.

For example, suppose offset is an integer that specifies the offset within shared memory of a table, except that its bottom few bits (LOWBITS says how many) are special flags. Here’s how to get just that offset and add it to the base address.

shared_mem_base + (offset & (-1 << LOWBITS))

Thanks to the outer set of parentheses, we don’t need to know whether ‘&’ has higher precedence than ‘+’. Thanks to the inner set, we don’t need to know whether ‘&’ has higher precedence than ‘<<’. But we can rely on all unary operators to have higher precedence than any binary operator, so we don’t need parentheses around the left operand of ‘<<’.

7.1 Simple Assignment

A simple assignment expression computes the value of the right operand and stores it into the lvalue on the left. Here is a simple assignment expression that stores 5 in i:

i = 5

We say that this is an assignment to the variable i and that it assigns i the value 5. It has no semicolon because it is an expression (so it has a value). Adding a semicolon at the end would make it a statement (see Expression Statement).

Here is another example of a simple assignment expression. Its operands are not simple, but the kind of assignment done here is simple assignment.

x[foo ()] = y + 6

A simple assignment with two different numeric data types converts the right operand value to the lvalue’s type, if possible. It can convert any numeric type to any other numeric type.

Simple assignment is also allowed on some non-numeric types: pointers (see Pointers), structures (see Structure Assignment), and unions (see Unions).

Warning: Assignment is not allowed on arrays because there are no array values in C; C variables can be arrays, but these arrays cannot be manipulated as wholes. See Limitations of C Arrays.

See Assignment Type Conversions, for the complete rules about data types used in assignments.

7.2 Lvalues

An expression that identifies a memory space that holds a value is called an lvalue, because it is a location that can hold a value.

The standard kinds of lvalues are:

• A variable.
• A pointer-dereference expression (see Dereferencing Pointers) using unary ‘*’.
• A structure field reference (see Structures) using ‘.’, if the structure value is an lvalue.
• A structure field reference using ‘->’. This is always an lvalue since ‘->’ implies pointer dereference.
• A union alternative reference (see Unions), on the same conditions as for structure fields.
• An array-element reference using ‘[…]’, if the array is an lvalue.

If an expression’s outermost operation is any other operator, that expression is not an lvalue. Thus, the variable x is an lvalue, but x + 0 is not, even though these two expressions compute the same value (assuming x is a number).

An array can be an lvalue (the rules above determine whether it is one), but using the array in an expression converts it automatically to a pointer to the zeroth element. The result of this conversion is not an lvalue. Thus, if the variable a is an array, you can’t use a by itself as the left operand of an assignment. But you can assign to an element of a, such as a[0]. That is an lvalue since a is an lvalue.

7.3 Modifying Assignment

You can abbreviate the common construct

lvalue = lvalue + expression

as

lvalue += expression

This is known as a modifying assignment. For instance,

i = i + 5;
i += 5;

shows two statements that are equivalent. The first uses simple assignment; the second uses modifying assignment.

Modifying assignment works with any binary arithmetic operator. For instance, you can subtract something from an lvalue like this,

lvalue -= expression

or multiply it by a certain amount like this,

lvalue *= expression

or shift it by a certain amount like this.

lvalue <<= expression
lvalue >>= expression

In most cases, this feature adds no power to the language, but it provides substantial convenience. Also, when lvalue contains code that has side effects, the simple assignment performs those side effects twice, while the modifying assignment performs them once. For instance,

x[foo ()] = x[foo ()] + 5;

calls foo twice, and it could return different values each time. If foo () returns 1 the first time and 3 the second time, then the effect could be to add x[3] and 5 and store the result in x[1], or to add x[1] and 5 and store the result in x[3]. We don’t know which of the two it will do, because C does not specify which call to foo is computed first.

Such a statement is not well defined, and shouldn’t be used.

By contrast,

x[foo ()] += 5;

is well defined: it calls foo only once to determine which element of x to adjust, and it adjusts that element by adding 5 to it.

7.4 Increment and Decrement Operators

The operators ‘++’ and ‘--’ are the increment and decrement operators. When used on a numeric value, they add or subtract 1. We don’t consider them assignments, but they are equivalent to assignments.

Using ‘++’ or ‘--’ as a prefix, before an lvalue, is called preincrement or predecrement. This adds or subtracts 1 and the result becomes the expression’s value. For instance,

#include <stdio.h>   /* Declares printf. */

int
main (void)
{
  int i = 5;
  printf ("%d\n", i);
  printf ("%d\n", ++i);
  printf ("%d\n", i);
  return 0;
}

prints lines containing 5, 6, and 6 again. The expression ++i increments i from 5 to 6, and has the value 6, so the output from printf on that line says ‘6’.

Using ‘--’ instead, for predecrement,

#include <stdio.h>   /* Declares printf. */

int
main (void)
{
  int i = 5;
  printf ("%d\n", i);
  printf ("%d\n", --i);
  printf ("%d\n", i);
  return 0;
}

prints three lines that contain (respectively) ‘5’, ‘4’, and again ‘4’.

7.5 Postincrement and Postdecrement

Using ‘++’ or ‘--’ after an lvalue does something peculiar: it gets the value directly out of the lvalue and then increments or decrements it. Thus, the value of i++ is the same as the value of i, but i++ also increments i “a little later.” This is called postincrement or postdecrement.

For example,

#include <stdio.h>   /* Declares printf. */

int
main (void)
{
  int i = 5;
  printf ("%d\n", i);
  printf ("%d\n", i++);
  printf ("%d\n", i);
  return 0;
}

prints lines containing 5, again 5, and 6. The expression i++ has the value 5, which is the value of i at the time, but it increments i from 5 to 6 just a little later.

How much later is “just a little later”? The compiler has some flexibility in deciding that. The rule is that the increment has to happen by the next sequence point; in simple cases, that means by the end of the statement. See Sequence Points.

Regardless of precisely where the compiled code increments the value of i, the crucial thing is that the value of i++ is the value that i has before incrementing it.

If a unary operator precedes a postincrement or postincrement expression, the increment nests inside:

-a++   is equivalent to   -(a++)

That’s the only order that makes sense; -a is not an lvalue, so it can’t be incremented.

The most common use of postincrement is with arrays. Here’s an example of using postincrement to access one element of an array and advance the index for the next access. Compare this with the example avg_of_double (see An Example with Arrays), which is almost the same but doesn’t use postincrement.

double
avg_of_double_alt (int length, double input_data[])
{
  double sum = 0;
  int i;

  /* Fetch each element and add it into sum.  */
  for (i = 0; i < length;)
    /* Use the index i, then increment it.  */
    sum += input_data[i++];

  return sum / length;
}

7.6 Pitfall: Assignment in Subexpressions

In C, the order of computing parts of an expression is not fixed. Aside from a few special cases, the operations can be computed in any order. If one part of the expression has an assignment to x and another part of the expression uses x, the result is unpredictable because that use might be computed before or after the assignment.

Here’s an example of ambiguous code:

x = 20;
printf ("%d %d\n", x, x = 4);

If the second argument, x, is computed before the third argument, x = 4, the second argument’s value will be 20. If they are computed in the other order, the second argument’s value will be 4.

Here’s one way to make that code unambiguous:

y = 20;
printf ("%d %d\n", y, x = 4);

Here’s another way, with the other meaning:

x = 4;
printf ("%d %d\n", x, x);

This issue applies to all kinds of assignments, and to the increment and decrement operators, which are equivalent to assignments. See Order of Execution, for more information about this.

However, it can be useful to write assignments inside an if-condition or while-test along with logical operators. See Logical Operators and Assignments.

7.7 Write Assignments in Separate Statements

It is often convenient to write an assignment inside an if-condition, but that can reduce the readability of the program. Here’s an example of what to avoid:

if (x = advance (x))
  …

The idea here is to advance x and test if the value is nonzero. However, readers might miss the fact that it uses ‘=’ and not ‘==’. In fact, writing ‘=’ where ‘==’ was intended inside a condition is a common error, so GNU C can give warnings when ‘=’ appears in a way that suggests it’s an error.

It is much clearer to write the assignment as a separate statement, like this:

x = advance (x);
if (x != 0)
  …

This makes it unmistakably clear that x is assigned a new value.

Another method is to use the comma operator (see Comma Operator), like this:

if (x = advance (x), x != 0)
  …

However, putting the assignment in a separate statement is usually clearer unless the assignment is very short, because it reduces nesting.

8.1 Logical Operators

The logical operators combine truth values, which are normally represented in C as numbers. Any expression with a numeric value is a valid truth value: zero means false, and any other value means true. A pointer type is also meaningful as a truth value; a null pointer (which is zero) means false, and a non-null pointer means true (see Pointer Types). The value of a logical operator is always 1 or 0 and has type int (see Integer Data Types).

The logical operators are used mainly in the condition of an if statement, or in the end test in a for statement or while statement (see Statements). However, they are valid in any context where an integer-valued expression is allowed.

‘! exp’

Unary operator for logical “not.” The value is 1 (true) if exp is 0 (false), and 0 (false) if exp is nonzero (true).

Warning: if exp is anything but an lvalue or a function call, you should write parentheses around it.

‘left && right’

The logical “and” binary operator computes left and, if necessary, right. If both of the operands are true, the ‘&&’ expression gives the value 1 (which is true). Otherwise, the ‘&&’ expression gives the value 0 (false). If left yields a false value, that determines the overall result, so right is not computed.

‘left || right’

The logical “or” binary operator computes left and, if necessary, right. If at least one of the operands is true, the ‘||’ expression gives the value 1 (which is true). Otherwise, the ‘||’ expression gives the value 0 (false). If left yields a true value, that determines the overall result, so right is not computed.

Warning: never rely on the relative precedence of ‘&&’ and ‘||’. When you use them together, always use parentheses to specify explicitly how they nest, as shown here:

if ((r != 0 && x % r == 0)
    ||
    (s != 0 && x % s == 0))

8.2 Logical Operators and Comparisons

The most common thing to use inside the logical operators is a comparison. Conveniently, ‘&&’ and ‘||’ have lower precedence than comparison operators and arithmetic operators, so we can write expressions like this without parentheses and get the nesting that is natural: two comparison operations that must both be true.

if (r != 0 && x % r == 0)

This example also shows how it is useful that ‘&&’ guarantees to skip the right operand if the left one turns out false. Because of that, this code never tries to divide by zero.

This is equivalent:

if (r && x % r == 0)

A truth value is simply a number, so using r as a truth value tests whether it is nonzero. But r’s meaning as en expression is not a truth value—it is a number to divide by. So it is better style to write the explicit != 0.

Here’s another equivalent way to write it:

if (!(r == 0) && x % r == 0)

This illustrates the unary ‘!’ operator, and the need to write parentheses around its operand.

8.3 Logical Operators and Assignments

There are cases where assignments nested inside the condition can actually make a program easier to read. Here is an example using a hypothetical type list which represents a list; it tests whether the list has at least two links, using hypothetical functions, nonempty which is true if the argument is a nonempty list, and list_next which advances from one list link to the next. We assume that a list is never a null pointer, so that the assignment expressions are always “true.”

if (nonempty (list)
    && (temp1 = list_next (list))
    && nonempty (temp1)
    && (temp2 = list_next (temp1)))
  …  /* use temp1 and temp2 */

Here we take advantage of the ‘&&’ operator to avoid executing the rest of the code if a call to nonempty returns “false.” The only natural place to put the assignments is among those calls.

It would be possible to rewrite this as several statements, but that could make it much more cumbersome. On the other hand, when the test is even more complex than this one, splitting it into multiple statements might be necessary for clarity.

If an empty list is a null pointer, we can dispense with calling nonempty:

if ((temp1 = list_next (list))
    && (temp2 = list_next (temp1)))
 …

8.4 Conditional Expression

C has a conditional expression that selects one of two expressions to compute and get the value from. It looks like this:

condition ? iftrue : iffalse

• Rules for the Conditional Operator
• Conditional Operator Branches

x ? : y

next_element () ? : default_pointer

next_element () ? next_element () : default_pointer

8.5 Comma Operator

The comma operator stands for sequential execution of expressions. The value of the comma expression comes from the last expression in the sequence; the previous expressions are computed only for their side effects. It looks like this:

exp1, exp2 …

You can bundle any number of expressions together this way, by putting commas between them.

• The Uses of the Comma Operator
• Clean Use of the Comma Operator
• When Not to Use the Comma Operator

for (i = 0, j = 10, k = 20; i < n; i++)

while (printf ("At the test, x = %d\n", x), x != 0)

for (i = 0, j = 10, k = 20; i < n; i++)

foo (4, 5, 6)

foo ((4, 5, 6))

foo ((mumble (x, y), frob (z)),
     *p)

x = (y += 4, 8);

y += 4, x = 8;

y += 4;
x = 8;

10.1 Reordering of Operands

The C language does not necessarily carry out operations within an expression in the order they appear in the code. For instance, in this expression,

foo () + bar ()

foo might be called first or bar might be called first. If foo updates a datum and bar uses that datum, the results can be unpredictable.

The unpredictable order of computation of subexpressions also makes a difference when one of them contains an assignment. We already saw this example of bad code,

x = 20;
printf ("%d %d\n", x, x = 4);

in which the second argument, x, has a different value depending on whether it is computed before or after the assignment in the third argument.

10.2 Associativity and Ordering

An associative binary operator, such as +, when used repeatedly can combine any number of operands. The operands’ values may be computed in any order.

If the values are integers and overflow can be ignored, they may be combined in any order. Thus, given four functions that return unsigned int, calling them and adding their results as here

(foo () + bar ()) + (baz () + quux ())

may add up the results in any order.

By contrast, arithmetic on signed integers, in which overflow is significant, is not always associative (see Integer Overflow). Thus, the additions must be done in the order specified, obeying parentheses and left-association. That means computing (foo () + bar ()) and (baz () + quux ()) first (in either order), then adding the two.

The same applies to arithmetic on floating-point values, since that too is not really associative. However, the GCC option -funsafe-math-optimizations allows the compiler to change the order of calculation when an associative operation (associative in exact mathematics) combines several operands. The option takes effect when compiling a module (see Compilation). Changing the order of association can enable the program to pipeline the floating point operations.

In all these cases, the four function calls can be done in any order. There is no right or wrong about that.

10.3 Sequence Points

There are some points in the code where C makes limited guarantees about the order of operations. These are called sequence points. Here is where they occur:

• At the end of a full expression; that is to say, an expression that is not part of a larger expression. All side effects specified by that expression are carried out before execution moves on to subsequent code.
• At the end of the first operand of certain operators: ‘,’, ‘&&’, ‘||’, and ‘?:’. All side effects specified by that expression are carried out before any execution of the next operand.

  The commas that separate arguments in a function call are not comma operators, and they do not create sequence points. The rule for function arguments and the rule for operands are different (see Ordering of Operands).

• Just before calling a function. All side effects specified by the argument expressions are carried out before calling the function.

  If the function to be called is not constant—that is, if it is computed by an expression—all side effects in that expression are carried out before calling the function.

The ordering imposed by a sequence point applies locally to a limited range of code, as stated above in each case. For instance, the ordering imposed by the comma operator does not apply to code outside the operands of that comma operator. Thus, in this code,

(x = 5, foo (x)) + x * x

the sequence point of the comma operator orders x = 5 before foo (x), but x * x could be computed before or after them.

10.4 Postincrement and Ordering

The ordering requirements for the postincrement and postdecrement operations (see Postincrement and Postdecrement) are loose: those side effects must happen “a little later,” before the next sequence point. That still leaves room for various orders that give different results. In this expression,

z = x++ - foo ()

it’s unpredictable whether x gets incremented before or after calling the function foo. If foo refers to x, it might see the old value or it might see the incremented value.

In this perverse expression,

x = x++

x will certainly be incremented but the incremented value may be replaced with the old value. That’s because the incrementation and the assignment may occur in either oder. If the incrementation of x occurs after the assignment to x, the incremented value will remain in place. But if the incrementation happens first, the assignment will put the not-yet-incremented value back into x, so the expression as a whole will leave x unchanged.

The conclusion: avoid such expressions. Take care, when you use postincrement and postdecrement, that the specific expression you use is not ambiguous as to order of execution.

10.5 Ordering of Operands

Operands and arguments can be computed in any order, but there are limits to this intermixing in GNU C:

• The operands of a binary arithmetic operator can be computed in either order, but they can’t be intermixed: one of them has to come first, followed by the other. Any side effects in the operand that’s computed first are executed before the other operand is computed.
• That applies to assignment operators too, except that, in simple assignment, the previous value of the left operand is unused.
• The arguments in a function call can be computed in any order, but they can’t be intermixed. Thus, one argument is fully computed, then another, and so on until they have all been done. Any side effects in one argument are executed before computation of another argument begins.

These rules don’t cover side effects caused by postincrement and postdecrement operators—those can be deferred up to the next sequence point.

If you want to get pedantic, the fact is that GCC can reorder the computations in many other ways provided that it doesn’t alter the result of running the program. However, because it doesn’t alter the result of running the program, it is negligible, unless you are concerned with the values in certain variables at various times as seen by other processes. In those cases, you should use volatile to prevent optimizations that would make them behave strangely. See volatile Variables and Fields.

10.6 Optimization and Ordering

Sequence points limit the compiler’s freedom to reorder operations arbitrarily, but optimizations can still reorder them if the compiler concludes that this won’t alter the results. Thus, in this code,

x++;
y = z;
x++;

there is a sequence point after each statement, so the code is supposed to increment x once before the assignment to y and once after. However, incrementing x has no effect on y or z, and setting y can’t affect x, so the code could be optimized into this:

y = z;
x += 2;

Normally that has no effect except to make the program faster. But there are special situations where it can cause trouble due to things that the compiler cannot know about, such as shared memory. To limit optimization in those places, use the volatile type qualifier (see volatile Variables and Fields).

11.1 Integer Data Types

Here we describe all the integer types and their basic characteristics. See Integers in Depth, for more information about the bit-level integer data representations and arithmetic.

• Basic Integers
• Signed and Unsigned Types
• Narrow Integers
• Conversion among Integer Types
• Boolean Type
• Integer Variations

signed char ac[1000];   /* 1000 bytes */
short as[1000];         /* 2000 bytes */
int ai[1000];           /* 4000 bytes */
long long all[1000];    /* 8000 bytes */

bool a = 0;
bool b = 1;
bool c = 4; /* Stores the value 1 in c.  */

11.2 Floating-Point Data Types

Floating point is the binary analogue of scientific notation: internally it represents a number as a fraction and a binary exponent; the value is that fraction multiplied by the specified power of 2. (The C standard nominally permits other bases, but in GNU C the base is always 2.)

For instance, to represent 6, the fraction would be 0.75 and the exponent would be 3; together they stand for the value 0.75 * 2³, meaning 0.75 * 8. The value 1.5 would use 0.75 as the fraction and 1 as the exponent. The value 0.75 would use 0.75 as the fraction and 0 as the exponent. The value 0.375 would use 0.75 as the fraction and -1 as the exponent.

These binary exponents are used by machine instructions. You can write a floating-point constant this way if you wish, using hexadecimal; but normally we write floating-point numbers in decimal (base 10). See Floating-Point Constants.

C has three floating-point data types:

double

“Double-precision” floating point, which uses 64 bits. This is the normal floating-point type, and modern computers normally do their floating-point computations in this type, or some wider type. Except when there is a special reason to do otherwise, this is the type to use for floating-point values.

float

“Single-precision” floating point, which uses 32 bits. It is useful for floating-point values stored in structures and arrays, to save space when the full precision of double is not needed. In addition, single-precision arithmetic is faster on some computers, and occasionally that is useful. But not often—most programs don’t use the type float.

C would be cleaner if float were the name of the type we use for most floating-point values; however, for historical reasons, that’s not so.

long double

“Extended-precision” floating point is either 80-bit or 128-bit precision, depending on the machine in use. On some machines, which have no floating-point format wider than double, this is equivalent to double.

Floating-point arithmetic raises many subtle issues. See Floating Point in Depth, for more information.

11.3 Complex Data Types

Complex numbers can include both a real part and an imaginary part. The numeric constants covered above have real-numbered values. An imaginary-valued constant is an ordinary real-valued constant followed by ‘i’.

To declare numeric variables as complex, use the _Complex keyword.⁴ The standard C complex data types are floating point,

_Complex float foo;
_Complex double bar;
_Complex long double quux;

but GNU C supports integer complex types as well.

Since _Complex is a keyword just like float and double and long, the keywords can appear in any order, but the order shown above seems most logical.

GNU C supports constants for complex values; for instance, 4.0 + 3.0i has the value 4 + 3i as type _Complex double. See Imaginary Constants.

To pull the real and imaginary parts of the number back out, GNU C provides the keywords __real__ and __imag__:

_Complex double foo = 4.0 + 3.0i;

double a = __real__ foo; /* a is now 4.0. */
double b = __imag__ foo; /* b is now 3.0. */

Standard C does not include these keywords, and instead relies on functions defined in complex.h for accessing the real and imaginary parts of a complex number: crealf, creal, and creall extract the real part of a float, double, or long double complex number, respectively; cimagf, cimag, and cimagl extract the imaginary part.

GNU C also defines ‘~’ as an operator for complex conjugation, which means negating the imaginary part of a complex number:

_Complex double foo = 4.0 + 3.0i;
_Complex double bar = ~foo; /* bar is now 4 - 3i. */

For standard C compatibility, you can use the appropriate library function: conjf, conj, or confl.

11.4 The Void Type

The data type void is a dummy—it allows no operations. It really means “no value at all.” When a function is meant to return no value, we write void for its return type. Then return statements in that function should not specify a value (see return Statement). Here’s an example:

void
print_if_positive (double x, double y)
{
  if (x <= 0)
    return;
  if (y <= 0)
    return;
  printf ("Next point is (%f,%f)\n", x, y);
}

A void-returning function is comparable to what some other languages (for instance, Fortran and Pascal) call a “procedure” instead of a “function.”

11.5 Other Data Types

Beyond the primitive types, C provides several ways to construct new data types. For instance, you can define pointers, values that represent the addresses of other data (see Pointers). You can define structures, as in many other languages (see Structures), and unions, which define multiple ways to interpret the contents of the same memory space (see Unions). Enumerations are collections of named integer codes (see Enumeration Types).

Array types in C are used for allocating space for objects, but C does not permit operating on an array value as a whole. See Arrays.

11.6 Type Designators

Some C constructs require a way to designate a specific data type independent of any particular variable or expression which has that type. The way to do this is with a type designator. The constructs that need one include casts (see Explicit Type Conversion) and sizeof (see Type Size).

We also use type designators to talk about the type of a value in C, so you will see many type designators in this manual. When we say, “The value has type int,” int is a type designator.

To make the designator for any type, imagine a variable declaration for a variable of that type and delete the variable name and the final semicolon.

For example, to designate the type of full-word integers, we start with the declaration for a variable foo with that type, which is this:

int foo;

Then we delete the variable name foo and the semicolon, leaving int—exactly the keyword used in such a declaration. Therefore, the type designator for this type is int.

What about long unsigned integers? From the declaration

unsigned long int foo;

we determine that the designator is unsigned long int.

Following this procedure, the designator for any primitive type is simply the set of keywords which specifies that type in a declaration. The same is true for compound types such as structures, unions, and enumerations.

Designators for pointer types do follow the rule of deleting the variable name and semicolon, but the result is not so simple. See Pointer-Type Designators, as part of the chapter about pointers. See Array Type Designators), for designators for array types.

To understand what type a designator stands for, imagine a variable name inserted into the right place in the designator to make a valid declaration. What type would that variable be declared as? That is the type the designator designates.

12.1 Integer Constants

An integer constant consists of a number to specify the value, followed optionally by suffix letters to specify the data type.

The simplest integer constants are numbers written in base 10 (decimal), such as 5, 77, and 403. A decimal constant cannot start with the character ‘0’ (zero) because that makes the constant octal.

You can get the effect of a negative integer constant by putting a minus sign at the beginning. In grammatical terms, that is an arithmetic expression rather than a constant, but it behaves just like a true constant.

Integer constants can also be written in octal (base 8), hexadecimal (base 16), or binary (base 2). An octal constant starts with the character ‘0’ (zero), followed by any number of octal digits (‘0’ to ‘7’):

0      // zero
077    // 63
0403   // 259

Pedantically speaking, the constant 0 is an octal constant, but we can think of it as decimal; it has the same value either way.

A hexadecimal constant starts with ‘0x’ (upper or lower case) followed by hex digits (‘0’ to ‘9’, as well as ‘a’ through ‘f’ in upper or lower case):

0xff   // 255
0XA0   // 160
0xffFF // 65535

A binary constant starts with ‘0b’ (upper or lower case) followed by bits (each represented by the characters ‘0’ or ‘1’):

0b101  // 5

Binary constants are a GNU C extension, not part of the C standard.

Sometimes a space is needed after an integer constant to avoid lexical confusion with the following tokens. See Invalid Numbers.

12.2 Integer Constant Data Types

The type of an integer constant is normally int, if the value fits in that type, but here are the complete rules. The type of an integer constant is the first one in this sequence that can properly represent the value,

1. int
2. unsigned int
3. long int
4. unsigned long int
5. long long int
6. unsigned long long int

and that isn’t excluded by the following rules.

If the constant has ‘l’ or ‘L’ as a suffix, that excludes the first two types (non-long).

If the constant has ‘ll’ or ‘LL’ as a suffix, that excludes first four types (non-long long).

If the constant has ‘u’ or ‘U’ as a suffix, that excludes the signed types.

Otherwise, if the constant is decimal (not binary, octal, or hexadecimal), that excludes the unsigned types.

Here are some examples of the suffixes.

3000000000u      // three billion as unsigned int.
0LL              // zero as a long long int.
0403l            // 259 as a long int.

Suffixes in integer constants are rarely used. When the precise type is important, it is cleaner to convert explicitly (see Explicit Type Conversion).

See Integer Data Types.

12.3 Floating-Point Constants

A floating-point constant must have either a decimal point, an exponent-of-ten, or both; they distinguish it from an integer constant.

To indicate an exponent, write ‘e’ or ‘E’. The exponent value follows. It is always written as a decimal number; it can optionally start with a sign. The exponent n means to multiply the constant’s value by ten to the nth power.

Thus, ‘1500.0’, ‘15e2’, ‘15e+2’, ‘15.0e2’, ‘1.5e+3’, ‘.15e4’, and ‘15000e-1’ are six ways of writing a floating-point number whose value is 1500. They are all equivalent in principle.

Here are more examples with decimal points:

1.0
1000.
3.14159
.05
.0005

For each of them, here are some equivalent constants written with exponents:

1e0, 1.0000e0
100e1, 100e+1, 100E+1, 1e3, 10000e-1
3.14159e0
5e-2, .0005e+2, 5E-2, .0005E2
.05e-2

A floating-point constant normally has type double. You can force it to type float by adding ‘f’ or ‘F’ at the end. For example,

3.14159f
3.14159e0f
1000.f
100E1F
.0005f
.05e-2f

Likewise, ‘l’ or ‘L’ at the end forces the constant to type long double.

You can use exponents in hexadecimal floating constants, but since ‘e’ would be interpreted as a hexadecimal digit, the character ‘p’ or ‘P’ (for “power”) indicates an exponent.

The exponent in a hexadecimal floating constant is an optionally signed decimal integer that specifies a power of 2 (not 10 or 16) to multiply into the number.

Here are some examples:

0xAp2        // 40 in decimal
0xAp-1       // 5 in decimal
0x2.0Bp4     // 32.6875 decimal
0xE.2p3      // 113 decimal
0x123.ABCp0  // 291.6708984375 in decimal
0x123.ABCp4  // 4666.734375 in decimal
0x100p-8     // 1
0x10p-4      // 1
0x1p+4       // 16
0x1p+8       // 256

See Floating-Point Data Types.

12.4 Imaginary Constants

A complex number consists of a real part plus an imaginary part. (You may omit one part if it is zero.) This section explains how to write numeric constants with imaginary values. By adding these to ordinary real-valued numeric constants, we can make constants with complex values.

The simple way to write an imaginary-number constant is to attach the suffix ‘i’ or ‘I’, or ‘j’ or ‘J’, to an integer or floating-point constant. For example, 2.5fi has type _Complex float and 3i has type _Complex int. The four alternative suffix letters are all equivalent.

The other way to write an imaginary constant is to multiply a real constant by _Complex_I, which represents the imaginary number i. Standard C doesn’t support suffixing with ‘i’ or ‘j’, so this clunky method is needed.

To write a complex constant with a nonzero real part and a nonzero imaginary part, write the two separately and add them, like this:

4.0 + 3.0i

That gives the value 4 + 3i, with type _Complex double.

Such a sum can include multiple real constants, or none. Likewise, it can include multiple imaginary constants, or none. For example:

_Complex double foo, bar, quux;

foo = 2.0i + 4.0 + 3.0i; /* Imaginary part is 5.0. */
bar = 4.0 + 12.0; /* Imaginary part is 0.0. */
quux = 3.0i + 15.0i; /* Real part is 0.0. */

See Complex Data Types.

12.5 Invalid Numbers

Some number-like constructs which are not really valid as numeric constants are treated as numbers in preprocessing directives. If these constructs appear outside of preprocessing, they are erroneous. See Preprocessing Tokens.

Sometimes we need to insert spaces to separate tokens so that they won’t be combined into a single number-like construct. For example, 0xE+12 is a preprocessing number that is not a valid numeric constant, so it is a syntax error. If what we want is the three tokens 0xE + 12, we have to insert two spaces as separators.

12.6 Character Constants

A character constant is written with single quotes, as in 'c'. In the simplest case, c is a single ASCII character that the constant should represent. The constant has type int, and its value is the character code of that character. For instance, 'a' represents the character code for the letter ‘a’: 97, that is.

To put the ‘'’ character (single quote) in the character constant, escape it with a backslash (‘\’). This character constant looks like '\''. The backslash character here functions as an escape character, and such a sequence, starting with ‘\’, is called an escape sequence.

To put the ‘\’ character (backslash) in the character constant, escape it with ‘\’ (another backslash). This character constant looks like '\\'.

Here are all the escape sequences that represent specific characters in a character constant. The numeric values shown are the corresponding ASCII character codes, as decimal numbers.

'\a' ⇒ 7       /* alarm, CTRL-g */
'\b' ⇒ 8       /* backspace, BS, CTRL-h */
'\t' ⇒ 9       /* tab, TAB, CTRL-i */
'\n' ⇒ 10      /* newline, CTRL-j */
'\v' ⇒ 11      /* vertical tab, CTRL-k */
'\f' ⇒ 12      /* formfeed, CTRL-l */
'\r' ⇒ 13      /* carriage return, RET, CTRL-m */
'\e' ⇒ 27      /* escape character, ESC, CTRL-[ */
'\\' ⇒ 92      /* backslash character, \ */
'\'' ⇒ 39      /* single quote character, ' */
'\"' ⇒ 34      /* double quote character, " */
'\?' ⇒ 63      /* question mark, ? */

‘\e’ is a GNU C extension; to stick to standard C, write ‘\33’. (The number after ‘backslash’ is octal.) To specify a character constant using decimal, use a cast; for instance, (unsigned char) 27.

You can also write octal and hex character codes as ‘\octalcode’ or ‘\xhexcode’. Decimal is not an option here, so octal codes do not need to start with ‘0’.

The character constant’s value has type int. However, the character code is treated initially as a char value, which is then converted to int. If the character code is greater than 127 (0177 in octal), the resulting int may be negative on a platform where the type char is 8 bits long and signed.

12.7 String Constants

A string constant represents a series of characters. It starts with ‘"’ and ends with ‘"’; in between are the contents of the string. Quoting special characters such as ‘"’, ‘\’ and newline in the contents works in string constants as in character constants. In a string constant, ‘'’ does not need to be quoted.

A string constant defines an array of characters which contains the specified characters followed by the null character (code 0). Using the string constant is equivalent to using the name of an array with those contents. In simple cases, where there are no backslash escape sequences, the length in bytes of the string constant is one greater than the number of characters written in it.

As with any array in C, using the string constant in an expression converts the array to a pointer (see Pointers) to the array’s zeroth element (see Accessing Array Elements). This pointer will have type char * because it points to an element of type char. char * is an example of a type designator for a pointer type (see Pointer-Type Designators). That type is used for strings generally, not just the strings expressed as constants in a program.

Thus, the string constant "Foo!" is almost equivalent to declaring an array like this

char string_array_1[] = {'F', 'o', 'o', '!', '\0' };

and then using string_array_1 in the program. There are two differences, however:

• The string constant doesn’t define a name for the array.
• The string constant is probably stored in a read-only area of memory.

Newlines are not allowed in the text of a string constant. The motive for this prohibition is to catch the error of omitting the closing ‘"’. To put a newline in a constant string, write it as ‘\n’ in the string constant.

A real null character in the source code inside a string constant causes a warning. To put a null character in the middle of a string constant, write ‘\0’ or ‘\000’.

Consecutive string constants are effectively concatenated. Thus,

"Fo" "o!"   is equivalent to   "Foo!"

This is useful for writing a string containing multiple lines, like this:

"This message is so long that it needs more than\n"
"a single line of text.  C does not allow a newline\n"
"to represent itself in a string constant, so we have to\n"
"write \\n to put it in the string.  For readability of\n"
"the source code, it is advisable to put line breaks in\n"
"the source where they occur in the contents of the\n"
"constant.\n"

The sequence of a backslash and a newline is ignored anywhere in a C program, and that includes inside a string constant. Thus, you can write multi-line string constants this way:

"This is another way to put newlines in a string constant\n\
and break the line after them in the source code."

However, concatenation is the recommended way to do this.

You can also write perverse string constants like this,

"Fo\
o!"

but don’t do that—write it like this instead:

"Foo!"

Be careful to avoid passing a string constant to a function that modifies the string it receives. The memory where the string constant is stored may be read-only, which would cause a fatal SIGSEGV signal that normally terminates the function (see Signals. Even worse, the memory may not be read-only. Then the function might modify the string constant, thus spoiling the contents of other string constants that are supposed to contain the same value and are unified by the compiler.

12.8 UTF-8 String Constants

Writing ‘u8’ immediately before a string constant, with no intervening space, means to represent that string in UTF-8 encoding as a sequence of bytes. UTF-8 represents ASCII characters with a single byte, and represents non-ASCII Unicode characters (codes 128 and up) as multibyte sequences. Here is an example of a UTF-8 constant:

u8"A cónstàñt"

This constant occupies 13 bytes plus the terminating null, because each of the accented letters is a two-byte sequence.

Concatenating an ordinary string with a UTF-8 string conceptually produces another UTF-8 string. However, if the ordinary string contains character codes 128 and up, the results cannot be relied on.

12.9 Unicode Character Codes

You can specify Unicode characters, for individual character constants or as part of string constants (see String Constants), using escape sequences; and even in C identifiers. Use the ‘\u’ escape sequence with a 16-bit hexadecimal Unicode character code. If the code value is too big for 16 bits, use the ‘\U’ escape sequence with a 32-bit hexadecimal Unicode character code. (These codes are called universal character names.) For example,

\u6C34      /* 16-bit code (UTF-16) */
\U0010ABCD  /* 32-bit code (UTF-32) */

One way to use these is in UTF-8 string constants (see UTF-8 String Constants). For instance,

u8"fóó \u6C34 \U0010ABCD"

You can also use them in wide character constants (see Wide Character Constants), like this:

u'\u6C34'      /* 16-bit code */
U'\U0010ABCD'  /* 32-bit code */

and in wide string constants (see Wide String Constants), like this:

u"\u6C34\u6C33"  /* 16-bit code */
U"\U0010ABCD"    /* 32-bit code */

And in an identifier:

int foo\u6C34bar = 0;

Codes in the range of D800 through DFFF are not valid in Unicode. Codes less than 00A0 are also forbidden, except for 0024, 0040, and 0060; these characters are actually ASCII control characters, and you can specify them with other escape sequences (see Character Constants).

12.10 Wide Character Constants

A wide character constant represents characters with more than 8 bits of character code. This is an obscure feature that we need to document but that you probably won’t ever use. If you’re just learning C, you may as well skip this section.

The original C wide character constant looks like ‘L’ (upper case!) followed immediately by an ordinary character constant (with no intervening space). Its data type is wchar_t, which is an alias defined in stddef.h for one of the standard integer types. Depending on the platform, it could be 16 bits or 32 bits. If it is 16 bits, these character constants use the UTF-16 form of Unicode; if 32 bits, UTF-32.

There are also Unicode wide character constants which explicitly specify the width. These constants start with ‘u’ or ‘U’ instead of ‘L’. ‘u’ specifies a 16-bit Unicode wide character constant, and ‘U’ a 32-bit Unicode wide character constant. Their types are, respectively, char16_t and char32_t; they are declared in the header file uchar.h. These character constants are valid even if uchar.h is not included, but some uses of them may be inconvenient without including it to declare those type names.

The character represented in a wide character constant can be an ordinary ASCII character. L'a', u'a' and U'a' are all valid, and they are all equal to 'a'.

In all three kinds of wide character constants, you can write a non-ASCII Unicode character in the constant itself; the constant’s value is the character’s Unicode character code. Or you can specify the Unicode character with an escape sequence (see Unicode Character Codes).

12.11 Wide String Constants

A wide string constant stands for an array of 16-bit or 32-bit characters. They are rarely used; if you’re just learning C, you may as well skip this section.

There are three kinds of wide string constants, which differ in the data type used for each character in the string. Each wide string constant is equivalent to an array of integers, but the data type of those integers depends on the kind of wide string. Using the constant in an expression will convert the array to a pointer to its zeroth element, as usual for arrays in C (see Accessing Array Elements). For each kind of wide string constant, we state here what type that pointer will be.

char16_t

This is a 16-bit Unicode wide string constant: each element is a 16-bit Unicode character code with type char16_t, so the string has the pointer type char16_t *. (That is a type designator; see Pointer-Type Designators.) The constant is written as ‘u’ (which must be lower case) followed (with no intervening space) by a string constant with the usual syntax.

char32_t

This is a 32-bit Unicode wide string constant: each element is a 32-bit Unicode character code, and the string has type char32_t *. It’s written as ‘U’ (which must be upper case) followed (with no intervening space) by a string constant with the usual syntax.

wchar_t

This is the original kind of wide string constant. It’s written as ‘L’ (which must be upper case) followed (with no intervening space) by a string constant with the usual syntax, and the string has type wchar_t *.

The width of the data type wchar_t depends on the target platform, which makes this kind of wide string somewhat less useful than the newer kinds.

char16_t and char32_t are declared in the header file uchar.h. wchar_t is declared in stddef.h.

Consecutive wide string constants of the same kind concatenate, just like ordinary string constants. A wide string constant concatenated with an ordinary string constant results in a wide string constant. You can’t concatenate two wide string constants of different kinds. In addition, you can’t concatenate a wide string constant (of any kind) with a UTF-8 string constant.

14.1 Address of Data

The most basic way to make a pointer is with the “address-of” operator, ‘&’. Let’s suppose we have these variables available:

int i;
double a[5];

Now, &i gives the address of the variable i—a pointer value that points to i’s location—and &a[3] gives the address of the element 3 of a. (By the usual 1-origin numbering convention of ordinary English, it is actually the fourth element in the array, since the element at the start has index 0.)

The address-of operator is unusual because it operates on a place to store a value (an lvalue, see Lvalues), not on the value currently stored there. (The left argument of a simple assignment is unusual in the same way.) You can use it on any lvalue except a bit field (see Bit Fields) or a constructor (see Structure Constructors).

14.2 Pointer Types

For each data type t, there is a type for pointers to type t. For these variables,

int i;
double a[5];

• i has type int; we say &i is a “pointer to int.”
• a has type double[5]; we say &a is a “pointer to arrays of five doubles.”
• a[3] has type double; we say &a[3] is a “pointer to double.”

14.3 Pointer-Variable Declarations

The way to declare that a variable foo points to type t is

t *foo;

To remember this syntax, think “if you dereference foo, using the ‘*’ operator, what you get is type t. Thus, foo points to type t.”

Thus, we can declare variables that hold pointers to these three types, like this:

int *ptri;            /* Pointer to int. */
double *ptrd;         /* Pointer to double. */
double (*ptrda)[5];   /* Pointer to double[5]. */

‘int *ptri;’ means, “if you dereference ptri, you get an int.” ‘double (*ptrda)[5];’ means, “if you dereference ptrda, then subscript it by an integer less than 5, you get a double.” The parentheses express the point that you would dereference it first, then subscript it.

Contrast the last one with this:

double *aptrd[5];     /* Array of five pointers to double. */

Because ‘*’ has lower syntactic precedence than subscripting, ‘double *aptrd[5]’ means, “if you subscript aptrd by an integer less than 5, then dereference it, you get a double.” Therefore, *aptrd[5] declares an array of pointers, not a pointer to an array.

14.4 Pointer-Type Designators

Every type in C has a designator; you make it by deleting the variable name and the semicolon from a declaration (see Type Designators). Here are the designators for the pointer types of the example declarations in the previous section:

int *           /* Pointer to int. */
double *        /* Pointer to double. */
double (*)[5]   /* Pointer to double[5]. */

Remember, to understand what type a designator stands for, imagine the corresponding variable declaration with a variable name in it, and figure out what type that variable would have. Thus, the type designator double (*)[5] corresponds to the variable declaration double (*variable)[5]. That deciares a pointer variable which, when dereferenced, gives an array of 5 doubles. So the type designator means, “pointer to an array of 5 doubles.”

14.5 Dereferencing Pointers

The main use of a pointer value is to dereference it (access the data it points at) with the unary ‘*’ operator. For instance, *&i is the value at i’s address—which is just i. The two expressions are equivalent, provided &i is valid.

A pointer-dereference expression whose type is data (not a function) is an lvalue.

Pointers become really useful when we store them somewhere and use them later. Here’s a simple example to illustrate the practice:

{
  int i;
  int *ptr;

  ptr = &i;

  i = 5;

  …

  return *ptr;   /* Returns 5, fetched from i.  */
}

This shows how to declare the variable ptr as type int * (pointer to int), store a pointer value into it (pointing at i), and use it later to get the value of the object it points at (the value in i).

If anyone can provide a useful example which is this basic, I would be grateful.

14.6 Null Pointers

A pointer value can be null, which means it does not point to any object. The cleanest way to get a null pointer is by writing NULL, a standard macro defined in stddef.h. You can also do it by casting 0 to the desired pointer type, as in (char *) 0. (The cast operator performs explicit type conversion; See Explicit Type Conversion.)

You can store a null pointer in any lvalue whose data type is a pointer type:

char *foo;
foo = NULL;

These two, if consecutive, can be combined into a declaration with initializer,

char *foo = NULL;

You can also explicitly cast NULL to the specific pointer type you want—it makes no difference.

char *foo;
foo = (char *) NULL;

To test whether a pointer is null, compare it with zero or NULL, as shown here:

if (p != NULL)
  /* p is not null.  */
  operate (p);

Since testing a pointer for not being null is basic and frequent, all but beginners in C will understand the conditional without need for != NULL:

if (p)
  /* p is not null.  */
  operate (p);

14.7 Dereferencing Null or Invalid Pointers

Trying to dereference a null pointer is an error. On most platforms, it generally causes a signal, usually SIGSEGV (see Signals).

char *foo = NULL;
c = *foo;    /* This causes a signal and terminates.  */

Likewise a pointer that has the wrong alignment for the target data type (on most types of computer), or points to a part of memory that has not been allocated in the process’s address space.

The signal terminates the program, unless the program has arranged to handle the signal (see The GNU C Library in The GNU C Library Reference Manual).

However, the signal might not happen if the dereference is optimized away. In the example above, if you don’t subsequently use the value of c, GCC might optimize away the code for *foo. You can prevent such optimization using the volatile qualifier, as shown here:

volatile char *p;
volatile char c;
c = *p;

You can use this to test whether p points to unallocated memory. Set up a signal handler first, so the signal won’t terminate the program.

14.8 Void Pointers

The peculiar type void *, a pointer whose target type is void, is used often in C. It represents a pointer to we-don’t-say-what. Thus,

void *numbered_slot_pointer (int);

declares a function numbered_slot_pointer that takes an integer parameter and returns a pointer, but we don’t say what type of data it points to.

The functions for dynamic memory allocation (see Dynamic Memory Allocation) use type void * to refer to blocks of memory, regardless of what sort of data the program stores in those blocks.

With type void *, you can pass the pointer around and test whether it is null. However, dereferencing it gives a void value that can’t be used (see The Void Type). To dereference the pointer, first convert it to some other pointer type.

Assignments convert void * automatically to any other pointer type, if the left operand has a pointer type; for instance,

{
  int *p;
  /* Converts return value to int *.  */
  p = numbered_slot_pointer (5);
  …
}

Passing an argument of type void * for a parameter that has a pointer type also converts. For example, supposing the function hack is declared to require type float * for its argument, this will convert the null pointer to that type.

/* Declare hack that way.
   We assume it is defined somewhere else.  */
void hack (float *);
…
/* Now call hack.  */
{
  /* Converts return value of numbered_slot_pointer
     to float * to pass it to hack.  */
  hack (numbered_slot_pointer (5));
  …
}

You can also convert to another pointer type with an explicit cast (see Explicit Type Conversion), like this:

(int *) numbered_slot_pointer (5)

Here is an example which decides at run time which pointer type to convert to:

void
extract_int_or_double (void *ptr, bool its_an_int)
{
  if (its_an_int)
    handle_an_int (*(int *)ptr);
  else
    handle_a_double (*(double *)ptr);
}

The expression *(int *)ptr means to convert ptr to type int *, then dereference it.

14.9 Pointer Comparison

Two pointer values are equal if they point to the same location, or if they are both null. You can test for this with == and !=. Here’s a trivial example:

{
  int i;
  int *p, *q;

  p = &i;
  q = &i;
  if (p == q)
    printf ("This will be printed.\n");
  if (p != q)
    printf ("This won't be printed.\n");
}

Ordering comparisons such as > and >= operate on pointers by converting them to unsigned integers. The C standard says the two pointers must point within the same object in memory, but on GNU/Linux systems these operations simply compare the numeric values of the pointers.

The pointer values to be compared should in principle have the same type, but they are allowed to differ in limited cases. First of all, if the two pointers’ target types are nearly compatible (see Compatible Types), the comparison is allowed.

If one of the operands is void * (see Void Pointers) and the other is another pointer type, the comparison operator converts the void * pointer to the other type so as to compare them. (In standard C, this is not allowed if the other type is a function pointer type, but it works in GNU C.)

Comparison operators also allow comparing the integer 0 with a pointer value. This works by converting 0 to a null pointer of the same type as the other operand.

14.10 Pointer Arithmetic

Adding an integer (positive or negative) to a pointer is valid in C. It assumes that the pointer points to an element in an array, and advances or retracts the pointer across as many array elements as the integer specifies. Here is an example, in which adding a positive integer advances the pointer to a later element in the same array.

void
incrementing_pointers ()
{
  int array[5] = { 45, 29, 104, -3, 123456 };
  int elt0, elt1, elt4;

  int *p = &array[0];
  /* Now p points at element 0.  Fetch it.  */
  elt0 = *p;

  ++p;
  /* Now p points at element 1.  Fetch it.  */
  elt1 = *p;

  p += 3;
  /* Now p points at element 4 (the last).  Fetch it.  */
  elt4 = *p;

  printf ("elt0 %d  elt1 %d  elt4 %d.\n",
          elt0, elt1, elt4);
  /* Prints elt0 45  elt1 29  elt4 123456.  */
}

Here’s an example where adding a negative integer retracts the pointer to an earlier element in the same array.

void
decrementing_pointers ()
{
  int array[5] = { 45, 29, 104, -3, 123456 };
  int elt0, elt3, elt4;

  int *p = &array[4];
  /* Now p points at element 4 (the last).  Fetch it.  */
  elt4 = *p;

  --p;
  /* Now p points at element 3.  Fetch it.  */
  elt3 = *p;

  p -= 3;
  /* Now p points at element 0.  Fetch it.  */
  elt0 = *p;

  printf ("elt0 %d  elt3 %d  elt4 %d.\n",
          elt0, elt3, elt4);
  /* Prints elt0 45  elt3 -3  elt4 123456.  */
}

If one pointer value was made by adding an integer to another pointer value, it should be possible to subtract the pointer values and recover that integer. That works too in C.

void
subtract_pointers ()
{
  int array[5] = { 45, 29, 104, -3, 123456 };
  int *p0, *p3, *p4;

  int *p = &array[4];
  /* Now p points at element 4 (the last).  Save the value.  */
  p4 = p;

  --p;
  /* Now p points at element 3.  Save the value.  */
  p3 = p;

  p -= 3;
  /* Now p points at element 0.  Save the value.  */
  p0 = p;

  printf ("%d, %d, %d, %d\n",
          p4 - p0, p0 - p0, p3 - p0, p0 - p3);
  /* Prints 4, 0, 3, -3.  */
}

The addition operation does not know where arrays begin or end in memory. All it does is add the integer (multiplied by target object size) to the numeric value of the pointer. When the initial pointer and the result point into the same array, the result is well-defined.

Warning: Only experts should do pointer arithmetic involving pointers into different memory objects.

The difference between two pointers has type int, or long if necessary (see Integer Data Types). The clean way to declare it is to use the typedef name ptrdiff_t defined in the file stddef.h.

C defines pointer subtraction to be consistent with pointer-integer addition, so that (p3 - p1) + p1 equals p3, as in ordinary algebra. Pointer subtraction works by subtracting p1’s numeric value from p3’s, and dividing by target object size. The two pointer arguments should point into the same array.

In standard C, addition and subtraction are not allowed on void *, since the target type’s size is not defined in that case. Likewise, they are not allowed on pointers to function types. However, these operations work in GNU C, and the “size of the target type” is taken as 1 byte.

14.11 Pointers and Arrays

The clean way to refer to an array element is array[index]. Another, complicated way to do the same job is to get the address of that element as a pointer, then dereference it: * (&array[0] + index) (or equivalently * (array + index)). This first gets a pointer to element zero, then increments it with + to point to the desired element, then gets the value from there.

That pointer-arithmetic construct is the definition of square brackets in C. a[b] means, by definition, *(a + b). This definition uses a and b symmetrically, so one must be a pointer and the other an integer; it does not matter which comes first.

Since indexing with square brackets is defined in terms of addition and dereferencing, that too is symmetrical. Thus, you can write 3[array] and it is equivalent to array[3]. However, it would be foolish to write 3[array], since it has no advantage and could confuse people who read the code.

It may seem like a discrepancy that the definition *(a + b) requires a pointer, while array[3] uses an array value instead. Why is this valid? The name of the array, when used by itself as an expression (other than in sizeof), stands for a pointer to the array’s zeroth element. Thus, array + 3 converts array implicitly to &array[0], and the result is a pointer to element 3, equivalent to &array[3].

Since square brackets are defined in terms of such an addition, array[3] first converts array to a pointer. That’s why it works to use an array directly in that construct.

14.12 Pointer Arithmetic at Low-Level

The behavior of pointer arithmetic is theoretically defined only when the pointer values all point within one object allocated in memory. But the addition and subtraction operators can’t tell whether the pointer values are all within one object. They don’t know where objects start and end. So what do they really do?

Adding pointer p to integer i treats p as a memory address, which is in fact an integer—call it pint. It treats i as a number of elements of the type that p points to. These elements’ sizes add up to i * sizeof (*p). So the sum, as an integer, is pint + i * sizeof (*p). This value is reinterpreted as a pointer of the same type as p.

If the starting pointer value p and the result do not point at parts of the same object, the operation is not officially legitimate, and C code is not “supposed” to do it. But you can do it anyway, and it gives precisely the results described by the procedure above. In some special situations it can do something useful, but non-wizards should avoid it.

Here’s a function to offset a pointer value as if it pointed to an object of any given size, by explicitly performing that calculation:

#include <stdint.h>

void *
ptr_add (void *p, int i, int objsize)
{
  intptr_t p_address = (long) p;
  intptr_t totalsize = i * objsize;
  intptr_t new_address = p_address + totalsize;
  return (void *) new_address;
}

This does the same job as p + i with the proper pointer type for p. It uses the type intptr_t, which is defined in the header file stdint.h. (In practice, long long would always work, but it is cleaner to use intptr_t.)

14.13 Pointer Increment and Decrement

The ‘++’ operator adds 1 to a variable. We have seen it for integers (see Increment and Decrement Operators), but it works for pointers too. For instance, suppose we have a series of positive integers, terminated by a zero, and we want to add them up. Here is a simple way to step forward through the array by advancing a pointer.

int
sum_array_till_0 (int *p)
{
  int sum = 0;

  for (;;)
    {
      /* Fetch the next integer.  */
      int next = *p++;
      /* Exit the loop if it’s 0.  */
      if (next == 0)
        break;
      /* Add it into running total.  */
      sum += next;
    }

  return sum;
}

The statement ‘break;’ will be explained further on (see break Statement). Used in this way, it immediately exits the surrounding for statement.

*p++ uses postincrement (++; see Postincrement and Postdecrement) on the pointer p. that expression parses as *(p++), because a postfix operator always takes precedence over a prefix operator. Therefore, it dereferences the entering value of p, then increments p afterwards.

Incrementing a variable means adding 1 to it, as in p = p + 1. Since p is a pointer, adding 1 to it advances it by the width of the datum it points to—in this case, sizeof (int). Therefore, each iteration of the loop picks up the next integer from the series and puts it into next.

This for-loop has no initialization expression since p and sum are already initialized, has no end-test since the ‘break;’ statement will exit it, and needs no expression to advance it since that’s done within the loop by incrementing p and sum. Thus, those three expressions after for are left empty.

Another way to write this function is by keeping the parameter value unchanged and using indexing to access the integers in the table.

int
sum_array_till_0_indexing (int *p)
{
  int i;
  int sum = 0;

  for (i = 0; ; i++)
    {
      /* Fetch the next integer.  */
      int next = p[i];
      /* Exit the loop if it’s 0.  */
      if (next == 0)
        break;
      /* Add it into running total.  */
      sum += next;
    }

  return sum;
}

In this program, instead of advancing p, we advance i and add it to p. (Recall that p[i] means *(p + i).) Either way, it uses the same address to get the next integer.

It makes no difference in this program whether we write i++ or ++i, because the value of that expression is not used. We use it for its effect, to increment i.

The ‘--’ operator also works on pointers; it can be used to step backwards through an array, like this:

int
after_last_nonzero (int *p, int len)
{
  /* Set up q to point just after the last array element.  */
  int *q = p + len;

  while (q != p)
    /* Step q back until it reaches a nonzero element.  */
    if (*--q != 0)
      /* Return the index of the element after that nonzero.  */
      return q - p + 1;

  return 0;
}

That function returns the length of the nonzero part of the array specified by its arguments; that is, the index of the first zero of the run of zeros at the end.

14.14 Drawbacks of Pointer Arithmetic

Pointer arithmetic is clean and elegant, but it is also the cause of a major security flaw in the C language. Theoretically, it is only valid to adjust a pointer within one object allocated as a unit in memory. However, if you unintentionally adjust a pointer across the bounds of the object and into some other object, the system has no way to detect this error.

A bug which does that can easily result in clobbering (overwriting) part of another object. For example, with array[-1] you can read or write the nonexistent element before the beginning of an array—probably part of some other data.

Combining pointer arithmetic with casts between pointer types, you can create a pointer that fails to be properly aligned for its type. For example,

int a[2];
char *pa = (char *)a;
int *p = (int *)(pa + 1);

gives p a value pointing to an “integer” that includes part of a[0] and part of a[1]. Dereferencing that with *p can cause a fatal SIGSEGV signal or it can return the contents of that badly aligned int (see Signals. If it “works,” it may be quite slow. It can also cause aliasing confusions (see Aliasing).

Warning: Using improperly aligned pointers is risky—don’t do it unless it is really necessary.

14.15 Pointer-Integer Conversion

On modern computers, an address is simply a number. It occupies the same space as some size of integer. In C, you can convert a pointer to the appropriate integer types and vice versa, without losing information. The appropriate integer types are uintptr_t (an unsigned type) and intptr_t (a signed type). Both are defined in stdint.h.

For instance,

#include <stdint.h>
#include <stdio.h>

void
print_pointer (void *ptr)
{
  uintptr_t converted = (uintptr_t) ptr;

  printf ("Pointer value is 0x%x\n",
          (unsigned int) converted);
}

The specification ‘%x’ in the template (the first argument) for printf means to represent this argument using hexadecimal notation. It’s cleaner to use uintptr_t, since hexadecimal printing treats the number as unsigned, but it won’t actually matter: all printf gets to see is the series of bits in the number.

Warning: Converting pointers to integers is risky—don’t do it unless it is really necessary.

14.16 Printing Pointers

To print the numeric value of a pointer, use the ‘%p’ specifier. For example:

void
print_pointer (void *ptr)
{
  printf ("Pointer value is %p\n", ptr);
}

The specification ‘%p’ works with any pointer type. It prints ‘0x’ followed by the address in hexadecimal, printed as the appropriate unsigned integer type.

15.1 Referencing Structure Fields

To make a structure useful, there has to be a way to examine and store its fields. The ‘.’ (period) operator does that; its use looks like object.field.

Given this structure and variable,

struct intlistlink
  {
    int datum;
    struct intlistlink *next;
  };

struct intlistlink foo;

you can write foo.datum and foo.next to refer to the two fields in the value of foo. These fields are lvalues, so you can store values into them, and read the values out again.

Most often, structures are dynamically allocated (see the next section), and we refer to the objects via pointers. (*p).field is somewhat cumbersome, so there is an abbreviation: p->field. For instance, assume the program contains this declaration:

struct intlistlink *ptr;

You can write ptr->datum and ptr->next to refer to the two fields in the object that ptr points to.

If a unary operator precedes an expression using ‘->’, the ‘->’ nests inside:

  -ptr->datum   is equivalent to   -(ptr->datum)

You can intermix ‘->’ and ‘.’ without parentheses, as shown here:

struct { double d; struct intlistlink l; } foo;

…foo.l.next->next->datum…

15.2 Arrays as Fields

When you declare field in a structure as an array, as here:

struct record
  {
    char *name;
    int data[4];
  };

Each struct record object holds one string (a pointer, of course) and four integers, all part of a field called data. If recptr is a pointer of type struct record *, then it points to a struct record which contains those things; you can access the second integer in that record with recptr->data[1].

If you have two objects of type struct record, each one contains an array. With this declaration,

struct record r1, r2;

r1.data holds space for 4 ints, and r2.data holds space for another 4 ints,

15.3 Dynamic Memory Allocation

To allocate an object dynamically, call the library function malloc (see The GNU C Library in The GNU C Library Reference Manual). Here is how to allocate an object of type struct intlistlink. To make this code work, include the file stdlib.h, like this:

#include <stddef.h>  /* Defines NULL. */
#include <stdlib.h>  /* Declares malloc.  */

…

struct intlistlink *
alloc_intlistlink ()
{
  struct intlistlink *p;

  p = malloc (sizeof (struct intlistlink));

  if (p == NULL)
    fatal ("Ran out of storage");

  /* Initialize the contents. */
  p->datum = 0;
  p->next = NULL;

  return p;
}

malloc returns void *, so the assignment to p will automatically convert it to type struct intlistlink *. The return value of malloc is always sufficiently aligned (see Type Alignment) that it is valid for any data type.

The test for p == NULL is necessary because malloc returns a null pointer if it cannot get any storage. We assume that the program defines the function fatal to report a fatal error to the user.

Here’s how to add one more integer to the front of such a list:

struct intlistlink *my_list = NULL;

void
add_to_mylist (int my_int)
{
  struct intlistlink *p = alloc_intlistlink ();

  p->datum = my_int;
  p->next = mylist;
  mylist = p;
}

The way to free the objects is by calling free. Here’s a function to free all the links in one of these lists:

void
free_intlist (struct intlistlink *p)
{
  while (p)
    {
      struct intlistlink *q = p;
      p = p->next;
      free (q);
    }
}

We must extract the next pointer from the object before freeing it, because free can clobber the data that was in the object. For the same reason, the program must not use the list any more after freeing its elements. To make sure it won’t, it is best to clear out the variable where the list was stored, like this:

free_intlist (mylist);

mylist = NULL;

15.4 Field Offset

To determine the offset of a given field field in a structure type type, use the macro offsetof, which is defined in the file stddef.h. It is used like this:

offsetof (type, field)

Here is an example:

struct foo
{
  int element;
  struct foo *next;
};

offsetof (struct foo, next)
/* On most machines that is 4.  It may be 8.  */

15.5 Structure Layout

The rest of this chapter covers advanced topics about structures. If you are just learning C, you can skip it.

The precise layout of a struct type is crucial when using it to overlay hardware registers, to access data structures in shared memory, or to assemble and disassemble packets for network communication. It is also important for avoiding memory waste when the program makes many objects of that type. However, the layout depends on the target platform. Each platform has conventions for structure layout, which compilers need to follow.

Here are the conventions used on most platforms.

The structure’s fields appear in the structure layout in the order they are declared. When possible, consecutive fields occupy consecutive bytes within the structure. However, if a field’s type demands more alignment than it would get that way, C gives it the alignment it requires by leaving a gap after the previous field.

Once all the fields have been laid out, it is possible to determine the structure’s alignment and size. The structure’s alignment is the maximum alignment of any of the fields in it. Then the structure’s size is rounded up to a multiple of its alignment. That may require leaving a gap at the end of the structure.

Here are some examples, where we assume that char has size and alignment 1 (always true), and int has size and alignment 4 (true on most kinds of computers):

struct foo
{
  char a, b;
  int c;
};

This structure occupies 8 bytes, with an alignment of 4. a is at offset 0, b is at offset 1, and c is at offset 4. There is a gap of 2 bytes before c.

Contrast that with this structure:

struct foo
{
  char a;
  int c;
  char b;
};

This structure has size 12 and alignment 4. a is at offset 0, c is at offset 4, and b is at offset 8. There are two gaps: three bytes before c, and three bytes at the end.

These two structures have the same contents at the C level, but one takes 8 bytes and the other takes 12 bytes due to the ordering of the fields. A reliable way to avoid this sort of wastage is to order the fields by size, biggest fields first.

15.6 Packed Structures

In GNU C you can force a structure to be laid out with no gaps by adding __attribute__((packed)) after struct (or at the end of the structure type declaration). Here’s an example:

struct __attribute__((packed)) foo
{
  char a;
  int c;
  char b;
};

Without __attribute__((packed)), this structure occupies 12 bytes (as described in the previous section), assuming 4-byte alignment for int. With __attribute__((packed)), it is only 6 bytes long—the sum of the lengths of its fields.

Use of __attribute__((packed)) often results in fields that don’t have the normal alignment for their types. Taking the address of such a field can result in an invalid pointer because of its improper alignment. Dereferencing such a pointer can cause a SIGSEGV signal on a machine that doesn’t, in general, allow unaligned pointers.

See Attributes in Declarations.

15.7 Bit Fields

A structure field declaration with an integer type can specify the number of bits the field should occupy. We call that a bit field. These are useful because consecutive bit fields are packed into a larger storage unit. For instance,

unsigned char opcode: 4;

specifies that this field takes just 4 bits. Since it is unsigned, its possible values range from 0 to 15. A signed field with 4 bits, such as this,

signed char small: 4;

can hold values from -8 to 7.

You can subdivide a single byte into those two parts by writing

unsigned char opcode: 4;
signed char small: 4;

in the structure. With bit fields, these two numbers fit into a single char.

Here’s how to declare a one-bit field that can hold either 0 or 1:

unsigned char special_flag: 1;

You can also use the bool type for bit fields:

bool special_flag: 1;

Except when using bool (which is always unsigned, see Boolean Type), always specify signed or unsigned for a bit field. There is a default, if that’s not specified: the bit field is signed if plain char is signed, except that the option -funsigned-bitfields forces unsigned as the default. But it is cleaner not to depend on this default.

Bit fields are special in that you cannot take their address with ‘&’. They are not stored with the size and alignment appropriate for the specified type, so they cannot be addressed through pointers to that type.

15.8 Bit Field Packing

Programs to communicate with low-level hardware interfaces need to define bit fields laid out to match the hardware data. This section explains how to do that.

Consecutive bit fields are packed together, but each bit field must fit within a single object of its specified type. In this example,

unsigned short a : 3, b : 3, c : 3, d : 3, e : 3;

all five fields fit consecutively into one two-byte short. They need 15 bits, and one short provides 16. By contrast,

unsigned char a : 3, b : 3, c : 3, d : 3, e : 3;

needs three bytes. It fits a and b into one char, but c won’t fit in that char (they would add up to 9 bits). So c and d go into a second char, leaving a gap of two bits between b and c. Then e needs a third char. By contrast,

unsigned char a : 3, b : 3;
unsigned int c : 3;
unsigned char d : 3, e : 3;

needs only two bytes: the type unsigned int allows c to straddle bytes that are in the same word.

You can leave a gap of a specified number of bits by defining a nameless bit field. This looks like type : nbits;. It is allocated space in the structure just as a named bit field would be allocated.

You can force the following bit field to advance to the following aligned memory object with type : 0;.

Both of these constructs can syntactically share type with ordinary bit fields. This example illustrates both:

unsigned int a : 5, : 3, b : 5, : 0, c : 5, : 3, d : 5;

It puts a and b into one int, with a 3-bit gap between them. Then : 0 advances to the next int, so c and d fit into that one.

These rules for packing bit fields apply to most target platforms, including all the usual real computers. A few embedded controllers have special layout rules.

15.9 const Fields

A structure field declared const cannot be assigned to (see const Variables and Fields). For instance, let’s define this modified version of struct intlistlink:

struct intlistlink_ro  /* “ro” for read-only.  */
  {
    const int datum;
    struct intlistlink *next;
  };

This structure can be used to prevent part of the code from modifying the datum field:

/* p has type struct intlistlink *.
   Convert it to struct intlistlink_ro *.  */
struct intlistlink_ro *q
  = (struct intlistlink_ro *) p;

q->datum = 5;     /* Error! */
p->datum = 5;     /* Valid since *p is
                     not a struct intlistlink_ro.  */

A const field can get a value in two ways: by initialization of the whole structure, and by making a pointer-to-structure point to an object in which that field already has a value.

Any const field in a structure type makes assignment impossible for structures of that type (see Structure Assignment). That is because structure assignment works by assigning the structure’s fields, one by one.

15.10 Arrays of Length Zero

GNU C allows zero-length arrays. They are useful as the last field of a structure that is really a header for a variable-length object. Here’s an example, where we construct a variable-size structure to hold a line which is this_length characters long:

struct line {
  int length;
  char contents[0];
};

struct line *thisline
  = ((struct line *)
     malloc (sizeof (struct line)
             + this_length));
thisline->length = this_length;

In ISO C90, we would have to give contents a length of 1, which means either wasting space or complicating the argument to malloc.

15.11 Flexible Array Fields

The C99 standard adopted a more complex equivalent of zero-length array fields. It’s called a flexible array, and it’s indicated by omitting the length, like this:

struct line
{
  int length;
  char contents[];
};

The flexible array has to be the last field in the structure, and there must be other fields before it.

Under the C standard, a structure with a flexible array can’t be part of another structure, and can’t be an element of an array.

GNU C allows static initialization of flexible array fields. The effect is to “make the array long enough” for the initializer.

struct f1 { int x; int y[]; } f1
  = { 1, { 2, 3, 4 } };

This defines a structure variable named f1 whose type is struct f1. In C, a variable name or function name never conflicts with a structure type tag.

Omitting the flexible array field’s size lets the initializer determine it. This is allowed only when the flexible array is defined in the outermost structure and you declare a variable of that structure type. For example:

struct foo { int x; int y[]; };
struct bar { struct foo z; };

struct foo a = { 1, { 2, 3, 4 } };        // Valid.
struct bar b = { { 1, { 2, 3, 4 } } };    // Invalid.
struct bar c = { { 1, { } } };            // Valid.
struct foo d[1] = { { 1 { 2, 3, 4 } } };  // Invalid.

15.12 Overlaying Different Structures

Be careful about using different structure types to refer to the same memory within one function, because GNU C can optimize code assuming it never does that. See Aliasing. Here’s an example of the kind of aliasing that can cause the problem:

struct a { int size; char *data; };
struct b { int size; char *data; };
struct a foo;
struct a *p = &foo;
struct b *q = (struct b *) &foo;

Here q points to the same memory that the variable foo occupies, but they have two different types. The two types struct a and struct b are defined alike, but they are not the same type. Interspersing references using the two types, like this,

p->size = 0;
q->size = 1;
x = p->size;

allows GNU C to assume that p->size is still zero when it is copied into x. The GNU C compiler “knows” that q points to a struct b and this is not supposed to overlap with a struct a. Other compilers might also do this optimization.

The ISO C standard considers such code erroneous, precisely so that this optimization will not be incorrect.

15.13 Structure Assignment

Assignment operating on a structure type copies the structure. The left and right operands must have the same type. Here is an example:

#include <stddef.h>  /* Defines NULL. */
#include <stdlib.h>  /* Declares malloc.  */
…

struct point { double x, y; };

struct point *
copy_point (struct point point)
{
  struct point *p
    = (struct point *) malloc (sizeof (struct point));
  if (p == NULL)
    fatal ("Out of memory");
  *p = point;
  return p;
}

Notionally, assignment on a structure type works by copying each of the fields. Thus, if any of the fields has the const qualifier, that structure type does not allow assignment:

struct point { const double x, y; };

struct point a, b;

a = b;            /* Error! */

See Assignment Expressions.

When a structure type has a field which is an array, as here,

struct record
  {
    char *name;
    int data[4];
  };

struct record r1, r2;

structure assigment such as r1 = r2 copies array fields’ contents just as it copies all the other fields.

This is the only way in C that you can operate on the whole contents of a array with one operation: when the array is contained in a struct. You can’t copy the contents of the data field as an array, because

r1.data = r2.data;

would convert the array objects (as always) to pointers to the zeroth elements of the arrays (of type struct record *), and the assignment would be invalid because the left operand is not an lvalue.

15.14 Unions

A union type defines alternative ways of looking at the same piece of memory. Each alternative view is defined with a data type, and identified by a name. A union definition looks like this:

union name
{
  alternative declarations…
};

Each alternative declaration looks like a structure field declaration, except that it can’t be a bit field. For instance,

union number
{
  long int integer;
  double float;
}

lets you store either an integer (type long int) or a floating point number (type double) in the same place in memory. The length and alignment of the union type are the maximum of all the alternatives—they do not have to be the same. In this union example, double probably takes more space than long int, but that doesn’t cause a problem in programs that use the union in the normal way.

The members don’t have to be different in data type. Sometimes each member pertains to a way the data will be used. For instance,

union datum
{
  double latitude;
  double longitude;
  double height;
  double weight;
  int continent;
}

This union holds one of several kinds of data; most kinds are floating points, but the value can also be a code for a continent which is an integer. You could use one member of type double to access all the values which have that type, but the different member names will make the program clearer.

The alignment of a union type is the maximum of the alignments of the alternatives. The size of the union type is the maximum of the sizes of the alternatives, rounded up to a multiple of the alignment (because every type’s size must be a multiple of its alignment).

All the union alternatives start at the address of the union itself. If an alternative is shorter than the union as a whole, it occupies the first part of the union’s storage, leaving the last part unused for that alternative.

Warning: if the code stores data using one union alternative and accesses it with another, the results depend on the kind of computer in use. Only wizards should try to do this. However, when you need to do this, a union is a clean way to do it.

Assignment works on any union type by copying the entire value.

15.15 Packing With Unions

Sometimes we design a union with the intention of packing various kinds of objects into a certain amount of memory space. For example.

union bytes8
{
  long long big_int_elt;
  double double_elt;
  struct { int first, second; } two_ints;
  struct { void *first, *second; } two_ptrs;
};

union bytes8 *p;

This union makes it possible to look at 8 bytes of data that p points to as a single 8-byte integer (p->big_int_elt), as a single floating-point number (p->double_elt), as a pair of integers (p->two_ints.first and p->two_ints.second), or as a pair of pointers (p->two_ptrs.first and p->two_ptrs.second).

To pack storage with such a union makes assumptions about the sizes of all the types involved. This particular union was written expecting a pointer to have the same size as int. On a machine where one pointer takes 8 bytes, the code using this union probably won’t work as expected. The union, as such, will function correctly—if you store two values through two_ints and extract them through two_ints, you will get the same integers back—but the part of the program that expects the union to be 8 bytes long could malfunction, or at least use too much space.

The above example shows one case where a struct type with no tag can be useful. Another way to get effectively the same result is with arrays as members of the union:

union eight_bytes
{
  long long big_int_elt;
  double double_elt;
  int two_ints[2];
  void *two_ptrs[2];
};

15.16 Cast to a Union Type

In GNU C, you can explicitly cast any of the alternative types to the union type; for instance,

(union eight_bytes) (long long) 5

makes a value of type union eight_bytes which gets its contents through the alternative named big_int_elt.

The value being cast must exactly match the type of the alternative, so this is not valid:

(union eight_bytes) 5  /* Error!  5 is int. */

A cast to union type looks like any other cast, except that the type specified is a union type. You can specify the type either with union tag or with a typedef name (see Defining Typedef Names).

Using the cast as the right-hand side of an assignment to a variable of union type is equivalent to storing in an alternative of the union:

union foo u;

u = (union foo) x   means   u.i = x

u = (union foo) y   means   u.d = y

You can also use the union cast as a function argument:

void hack (union foo);
…
hack ((union foo) x);

15.17 Structure Constructors

You can construct a structure value by writing its type in parentheses, followed by an initializer that would be valid in a declaration for that type. For instance, given this declaration,

struct foo {int a; char b[2];} structure;

you can create a struct foo value as follows:

((struct foo) {x + y, 'a', 0})

This specifies x + y for field a, the character ‘a’ for field b’s element 0, and the null character for field b’s element 1.

The parentheses around that constructor are to necessary, but we recommend writing them to make the nesting of the containing expression clearer.

You can also show the nesting of the two by writing it like this:

((struct foo) {x + y, {'a', 0} })

Each of those is equivalent to writing the following statement expression (see Statements and Declarations in Expressions):

({
  struct foo temp = {x + y, 'a', 0};
  temp;
})

You can also use field labels in the structure constructor to indicate which fields you’re specifying values for, instead of using the order of the fields to specify that:

(struct foo) {.a = x + y, .b = {'a', 0}}

You can also create a union value this way, but it is not especially useful since that is equivalent to doing a cast:

  ((union whosis) {value})
is equivalent to
  ((union whosis) (value))

15.18 Unnamed Types as Fields

A structure or a union can contain, as fields, unnamed structures and unions. Here’s an example:

struct
{
  int a;
  union
  {
    int b;
    float c;
  };
  int d;
} foo;

You can access the fields of the unnamed union within foo as if they were individual fields at the same level as the union definition:

foo.a = 42;
foo.b = 47;
foo.c = 5.25; // Overwrites the value in foo.b.
foo.d = 314;

Avoid using field names that could cause ambiguity. For example, with this definition:

struct
{
  int a;
  struct
  {
    int a;
    float b;
  };
} foo;

it is impossible to tell what foo.a refers to. GNU C reports an error when a definition is ambiguous in this way.

15.19 Incomplete Types

A type that has not been fully defined is called an incomplete type. Structure and union types are incomplete when the code makes a forward reference, such as struct foo, before defining the type. An array type is incomplete when its length is unspecified.

You can’t use an incomplete type to declare a variable or field, or use it for a function parameter or return type. The operators sizeof and _Alignof give errors when used on an incomplete type.

However, you can define a pointer to an incomplete type, and declare a variable or field with such a pointer type. In general, you can do everything with such pointers except dereference them. For example:

extern void bar (struct mysterious_value *);

void
foo (struct mysterious_value *arg)
{
  bar (arg);
}

…

{
  struct mysterious_value *p, **q;

  p = *q;
  foo (p);
}

These examples are valid because the code doesn’t try to understand what p points to; it just passes the pointer around. (Presumably bar is defined in some other file that really does have a definition for struct mysterious_value.) However, dereferencing the pointer would get an error; that requires a definition for the structure type.

15.20 Intertwined Incomplete Types

When several structure types contain pointers to each other, you can define the types in any order because pointers to types that come later are incomplete types. Thus, Here is an example.

/* An employee record points to a group.  */
struct employee
{
  char *name;
  …
  struct group *group;  /* incomplete type.  */
  …
};

/* An employee list points to employees.  */
struct employee_list
{
  struct employee *this_one;
  struct employee_list *next;  /* incomplete type.  */
  …
};

/* A group points to one employee_list.  */
struct group
{
  char *name;
  …
  struct employee_list *employees;
  …
};

15.21 Type Tags

The name that follows struct (see Structures), union (see Unions, or enum (see Enumeration Types) is called a type tag. In C, a type tag never conflicts with a variable name or function name; the type tags have a separate name space. Thus, there is no name conflict in this code:

struct pair { int a, b; };
int pair = 1;

nor in this one:

struct pair { int a, b; } pair;

where pair is both a structure type tag and a variable name.

However, struct, union, and enum share the same name space of tags, so this is a conflict:

struct pair { int a, b; };
enum pair { c, d };

and so is this:

struct pair { int a, b; };
struct pair { int c, d; };

When the code defines a type tag inside a block, the tag’s scope is limited to that block (as for local variables). Two definitions for one type tag do not conflict if they are in different scopes; rather, each is valid in its scope. For example,

struct pair { int a, b; };

void
pair_up_doubles (int len, double array[])
{
  struct pair { double a, b; };
  …
}

has two definitions for struct pair which do not conflict. The one inside the function applies only within the definition of pair_up_doubles. Within its scope, that definition shadows the outer definition.

If struct pair appears inside the function body, before the inner definition, it refers to the outer definition—the only one that has been seen at that point. Thus, in this code,

struct pair { int a, b; };

void
pair_up_doubles (int len, double array[])
{
  struct two_pairs { struct pair *p, *q; };
  struct pair { double a, b; };
  …
}

the structure two_pairs has pointers to the outer definition of struct pair, which is probably not desirable.

To prevent that, you can write struct pair; inside the function body as a variable declaration with no variables. This is a forward declaration of the type tag pair: it makes the type tag local to the current block, with the details of the type to come later. Here’s an example:

void
pair_up_doubles (int len, double array[])
{
  /* Forward declaration for pair.  */
  struct pair;
  struct two_pairs { struct pair *p, *q; };
  /* Give the details.  */
  struct pair { double a, b; };
  …
}

However, the cleanest practice is to avoid shadowing type tags.

16.1 Accessing Array Elements

If the variable a is an array, the nth element of a is a[n]. You can use that expression to access an element’s value or to assign to it:

x = a[5];
a[6] = 1;

Since the variable a is an lvalue, a[n] is also an lvalue.

The lowest valid index in an array is 0, not 1, and the highest valid index is one less than the number of elements.

The C language does not check whether array indices are in bounds, so if the code uses an out-of-range index, it will access memory outside the array.

Warning: Using only valid index values in C is the programmer’s responsibility.

Array indexing in C is not a primitive operation: it is defined in terms of pointer arithmetic and dereferencing. Now that we know what a[i] does, we can ask how a[i] does its job.

In C, x[y] is an abbreviation for *(x+y). Thus, a[i] really means *(a+i). See Pointers and Arrays.

When an expression with array type (such as a) appears as part of a larger C expression, it is converted automatically to a pointer to element zero of that array. For instance, a in an expression is equivalent to &a[0]. Thus, *(a+i) is computed as *(&a[0]+i).

Now we can analyze how that expression gives us the desired element of the array. It makes a pointer to element 0 of a, advances it by the value of i, and dereferences that pointer.

Another equivalent way to write the expression is (&a[0])[i].

16.2 Declaring an Array

To make an array declaration, write [length] after the name being declared. This construct is valid in the declaration of a variable, a function parameter, a function value type (the value can’t be an array, but it can be a pointer to one), a structure field, or a union alternative.

The surrounding declaration specifies the element type of the array; that can be any type of data, but not void or a function type. For instance,

double a[5];

declares a as an array of 5 doubles.

struct foo bstruct[length];

declares bstruct as an array of length objects of type struct foo. A variable array size like this is allowed when the array is not file-scope.

Other declaration constructs can nest within the array declaration construct. For instance:

struct foo *b[length];

declares b as an array of length pointers to struct foo. This shows that the length need not be a constant (see Arrays of Variable Length).

double (*c)[5];

declares c as a pointer to an array of 5 doubles, and

char *(*f (int))[5];

declares f as a function taking an int argument and returning a pointer to an array of 5 strings (pointers to chars).

double aa[5][10];

declares aa as an array of 5 elements, each of which is an array of 10 doubles. This shows how to declare a multidimensional array in C (see Multidimensional Arrays).

All these declarations specify the array’s length, which is needed in these cases in order to allocate storage for the array.

16.3 Strings

A string in C is a sequence of elements of type char, terminated with the null character, the character with code zero.

Programs often need to use strings with specific, fixed contents. To write one in a C program, use a string constant such as "Take me to your leader!". The data type of a string constant is char *. For the full syntactic details of writing string constants, String Constants.

To declare a place to store a non-constant string, declare an array of char. Keep in mind that it must include one extra char for the terminating null. For instance,

char text[] = { 'H', 'e', 'l', 'l', 'o', 0 };

declares an array named ‘text’ with six elements—five letters and the terminating null character. An equivalent way to get the same result is this,

char text[] = "Hello";

which copies the elements of the string constant, including its terminating null character.

char message[200];

declares an array long enough to hold a string of 199 ASCII characters plus the terminating null character.

When you store a string into message be sure to check or prove that the length does not exceed its size. For example,

void
set_message (char *text)
{
  int i;
  for (i = 0; i < sizeof (message); i++)
    {
      message[i] = text[i];
      if (text[i] == 0)
        return;
    }
  fatal_error ("Message is too long for `message');
}

It’s easy to do this with the standard library function strncpy, which fills out the whole destination array (up to a specified length) with null characters. Thus, if the last character of the destination is not null, the string did not fit. Many system libraries, including the GNU C library, hand-optimize strncpy to run faster than an explicit for-loop.

Here’s what the code looks like:

void
set_message (char *text)
{
  strncpy (message, text, sizeof (message));
  if (message[sizeof (message) - 1] != 0)
    fatal_error ("Message is too long for `message');
}

See The GNU C Library in The GNU C Library Reference Manual, for more information about the standard library functions for operating on strings.

You can avoid putting a fixed length limit on strings you construct or operate on by allocating the space for them dynamically. See Dynamic Memory Allocation.

16.4 Array Type Designators

Every C type has a type designator, which you make by deleting the variable name and the semicolon from a declaration (see Type Designators). The designators for array types follow this rule, but they may appear surprising.

type   int a[5];           designator   int [5]
type   double a[5][3];     designator   double [5][3]
type   struct foo *a[5];   designator   struct foo *[5]

16.5 Incomplete Array Types

An array is equivalent, for most purposes, to a pointer to its zeroth element. When that is true, the length of the array is irrelevant. The length needs to be known only for allocating space for the array, or for sizeof and typeof (see Referring to a Type with __auto_type). Thus, in some contexts C allows

• An extern declaration says how to refer to a variable allocated elsewhere. It does not need to allocate space for the variable, so if it is an array, you can omit the length. For example,

  extern int foo[];
  

• When declaring a function parameter as an array, the argument value passed to the function is really a pointer to the array’s zeroth element. This value does not say how long the array really is, there is no need to declare it. For example,

  int
  func (int foo[])
  

These declarations are examples of incomplete array types, types that are not fully specified. The incompleteness makes no difference for accessing elements of the array, but it matters for some other things. For instance, sizeof is not allowed on an incomplete type.

With multidimensional arrays, only the first dimension can be omitted:

extern struct chesspiece *funnyboard foo[][8];

In other words, the code doesn’t have to say how many rows there are, but it must state how big each row is.

16.6 Limitations of C Arrays

Arrays have quirks in C because they are not “first-class objects”: there is no way in C to operate on an array as a unit.

The other composite objects in C, structures and unions, are first-class objects: a C program can copy a structure or union value in an assignment, or pass one as an argument to a function, or make a function return one. You can’t do those things with an array in C. That is because a value you can operate on never has an array type.

An expression in C can have an array type, but that doesn’t produce the array as a value. Instead it is converted automatically to a pointer to the array’s element at index zero. The code can operate on the pointer, and through that on individual elements of the array, but it can’t get and operate on the array as a unit.

There are three exceptions to this conversion rule, but none of them offers a way to operate on the array as a whole.

First, ‘&’ applied to an expression with array type gives you the address of the array, as an array type. However, you can’t operate on the whole array that way—if you apply ‘*’ to get the array back, that expression converts, as usual, to a pointer to its zeroth element.

Second, the operators sizeof, _Alignof, and typeof do not convert the array to a pointer; they leave it as an array. But they don’t operate on the array’s data—they only give information about its type.

Third, a string constant used as an initializer for an array is not converted to a pointer—rather, the declaration copies the contents of that string in that one special case.

You can copy the contents of an array, just not with an assignment operator. You can do it by calling the library function memcpy or memmove (see The GNU C Library in The GNU C Library Reference Manual). Also, when a structure contains just an array, you can copy that structure.

An array itself is an lvalue if it is a declared variable, or part of a structure or union that is an lvalue. When you construct an array from elements (see Constructing Array Values), that array is not an lvalue.

16.7 Multidimensional Arrays

Strictly speaking, all arrays in C are unidimensional. However, you can create an array of arrays, which is more or less equivalent to a multidimensional array. For example,

struct chesspiece *board[8][8];

declares an array of 8 arrays of 8 pointers to struct chesspiece. This data type could represent the state of a chess game. To access one square’s contents requires two array index operations, one for each dimension. For instance, you can write board[row][column], assuming row and column are variables with integer values in the proper range.

How does C understand board[row][column]? First of all, board is converted automatically to a pointer to the zeroth element (at index zero) of board. Adding row to that makes it point to the desired element. Thus, board[row]’s value is an element of board—an array of 8 pointers.

However, as an expression with array type, it is converted automatically to a pointer to the array’s zeroth element. The second array index operation, [column], accesses the chosen element from that array.

As this shows, pointer-to-array types are meaningful in C. You can declare a variable that points to a row in a chess board like this:

struct chesspiece *(*rowptr)[8];

This points to an array of 8 pointers to struct chesspiece. You can assign to it as follows:

rowptr = &board[5];

The dimensions don’t have to be equal in length. Here we declare statepop as an array to hold the population of each state in the United States for each year since 1900:

#define NSTATES 50
{
  int nyears = current_year - 1900 + 1;
  int statepop[NSTATES][nyears];
  …
}

The variable statepop is an array of NSTATES subarrays, each indexed by the year (counting from 1900). Thus, to get the element for a particular state and year, we must subscript it first by the number that indicates the state, and second by the index for the year:

statepop[state][year - 1900]

The subarrays within the multidimensional array are allocated consecutively in memory, and within each subarray, its elements are allocated consecutively in memory. The most efficient way to process all the elements in the array is to scan the last subscript in the innermost loop. This means consecutive accesses go to consecutive memory locations, which optimizes use of the processor’s memory cache. For example:

int total = 0;
float average;

for (int state = 0; state < NSTATES, ++state)
  {
    for (int year = 0; year < nyears; ++year)
      {
        total += statepop[state][year];
      }
  }

average = total / nyears;

C’s layout for multidimensional arrays is different from Fortran’s layout. In Fortran, a multidimensional array is not an array of arrays; rather, multidimensional arrays are a primitive feature, and it is the first index that varies most rapidly between consecutive memory locations. Thus, the memory layout of a 50x114 array in C matches that of a 114x50 array in Fortran.

16.8 Constructing Array Values

You can construct an array from elements by writing them inside braces, and preceding all that with the array type’s designator in parentheses. There is no need to specify the array length, since the number of elements determines that. The constructor looks like this:

(elttype[]) { elements };

Here is an example, which constructs an array of string pointers:

(char *[]) { "x", "y", "z" };

That’s equivalent in effect to declaring an array with the same initializer, like this:

char *array[] = { "x", "y", "z" };

and then using the array.

If all the elements are simple constant expressions, or made up of such, then the compound literal can be coerced to a pointer to its zeroth element and used to initialize a file-scope variable (see File-Scope Variables), as shown here:

char **foo = (char *[]) { "x", "y", "z" };

The data type of foo is char **, which is a pointer type, not an array type. The declaration is equivalent to defining and then using an array-type variable:

char *nameless_array[] = { "x", "y", "z" };
char **foo = &nameless_array[0];

16.9 Arrays of Variable Length

In GNU C, you can declare variable-length arrays like any other arrays, but with a length that is not a constant expression. The storage is allocated at the point of declaration and deallocated when the block scope containing the declaration exits. For example:

#include <stdio.h>  /* Defines FILE. */
#include <string.h> /* Declares str. */

FILE *
concat_fopen (char *s1, char *s2, char *mode)
{
  char str[strlen (s1) + strlen (s2) + 1];
  strcpy (str, s1);
  strcat (str, s2);
  return fopen (str, mode);
}

(This uses some standard library functions; see String and Array Utilities in The GNU C Library Reference Manual.)

The length of an array is computed once when the storage is allocated and is remembered for the scope of the array in case it is used in sizeof.

Warning: don’t allocate a variable-length array if the size might be very large (more than 100,000), or in a recursive function, because that is likely to cause stack overflow. Allocate the array dynamically instead (see Dynamic Memory Allocation).

Jumping or breaking out of the scope of the array name deallocates the storage. Jumping into the scope is not allowed; that gives an error message.

You can also use variable-length arrays as arguments to functions:

struct entry
tester (int len, char data[len][len])
{
  …
}

As usual, a function argument declared with an array type is really a pointer to an array that already exists. Calling the function does not allocate the array, so there’s no particular danger of stack overflow in using this construct.

To pass the array first and the length afterward, use a forward declaration in the function’s parameter list (another GNU extension). For example,

struct entry
tester (int len; char data[len][len], int len)
{
  …
}

The int len before the semicolon is a parameter forward declaration, and it serves the purpose of making the name len known when the declaration of data is parsed.

You can write any number of such parameter forward declarations in the parameter list. They can be separated by commas or semicolons, but the last one must end with a semicolon, which is followed by the “real” parameter declarations. Each forward declaration must match a “real” declaration in parameter name and data type. ISO C11 does not support parameter forward declarations.

19.1 Expression Statement

The most common kind of statement in C is an expression statement. It consists of an expression followed by a semicolon. The expression’s value is discarded, so the expressions that are useful are those that have side effects: assignment expressions, increment and decrement expressions, and function calls. Here are examples of expression statements:

x = 5;              /* Assignment expression. */
p++;                /* Increment expression. */
printf ("Done\n");  /* Function call expression. */
*p;                 /* Cause SIGSEGV signal if p is null. */
x + y;              /* Useless statement without effect. */

In very unusual circumstances we use an expression statement whose purpose is to get a fault if an address is invalid:

volatile char *p;
…
*p;                 /* Cause signal if p is null. */

If the target of p is not declared volatile, the compiler might optimize away the memory access, since it knows that the value isn’t really used. See volatile Variables and Fields.

19.2 if Statement

An if statement computes an expression to decide whether to execute the following statement or not. It looks like this:

if (condition)
  execute-if-true

The first thing this does is compute the value of condition. If that is true (nonzero), then it executes the statement execute-if-true. If the value of condition is false (zero), it doesn’t execute execute-if-true; instead, it does nothing.

This is a complex statement because it contains a component if-true-substatement that is a nested statement. It must be one and only one statement. The way to put multiple statements there is to group them into a block (see Blocks).

19.3 if-else Statement

An if-else statement computes an expression to decide which of two nested statements to execute. It looks like this:

if (condition)
  if-true-substatement
else
  if-false-substatement

The first thing this does is compute the value of condition. If that is true (nonzero), then it executes the statement if-true-substatement. If the value of condition is false (zero), then it executes the statement if-false-substatement instead.

This is a complex statement because it contains components if-true-substatement and if-else-substatement that are nested statements. Each must be one and only one statement. The way to put multiple statements in such a component is to group them into a block (see Blocks).

19.4 Blocks

A block is a construct that contains multiple statements of any kind. It begins with ‘{’ and ends with ‘}’, and has a series of statements and declarations in between. Another name for blocks is compound statements.

Is a block a statement? Yes and no. It doesn’t look like a normal statement—it does not end with a semicolon. But you can use it like a statement; anywhere that a statement is required or allowed, you can write a block and consider that block a statement.

So far it seems that a block is a kind of statement with an unusual syntax. But that is not entirely true: a function body is also a block, and that block is definitely not a statement. The text after a function header is not treated as a statement; only a function body is allowed there, and nothing else would be meaningful there.

In a formal grammar we would have to choose—either a block is a kind of statement or it is not. But this manual is meant for humans, not for parser generators. The clearest answer for humans is, “a block is a statement, in some ways.”

A block that isn’t a function body is called an internal block or a nested block. You can put a nested block directly inside another block, but more often the nested block is inside some complex statement, such as a for statement or an if statement.

There are two uses for nested blocks in C:

• To specify the scope for local declarations. For instance, a local variable’s scope is the rest of the innermost containing block.
• To write a series of statements where, syntactically, one statement is called for. For instance, the execute-if-true of an if statement is one statement. To put multiple statements there, they have to be wrapped in a block, like this:

  if (x < 0)
    {
      printf ("x was negative\n");
      x = -x;
    }
  

This example (repeated from above) shows a nested block which serves both purposes: it includes two statements (plus a declaration) in the body of a while statement, and it provides the scope for the declaration of q.

void
free_intlist (struct intlistlink *p)
{
  while (p)
    {
      struct intlistlink *q = p;
      p = p->next;
      free (q);
    }
}

19.5 return Statement

The return statement makes the containing function return immediately. It has two forms. This one specifies no value to return:

return;

That form is meant for functions whose return type is void (see The Void Type). You can also use it in a function that returns nonvoid data, but that’s a bad idea, since it makes the function return garbage.

The form that specifies a value looks like this:

return value;

which computes the expression value and makes the function return that. If necessary, the value undergoes type conversion to the function’s declared return value type, which works like assigning the value to a variable of that type.

19.6 Loop Statements

You can use a loop statement when you need to execute a series of statements repeatedly, making an iteration. C provides several different kinds of loop statements, described in the following subsections.

Every kind of loop statement is a complex statement because contains a component, here called body, which is a nested statement. Most often the body is a block.

• while Statement
• do-while Statement
• break Statement
• for Statement
• Example of for
• Omitted for-Expressions
• for-Index Declarations
• continue Statement

while (test)
  body

#include <stddef.h> /* Defines NULL. */
…
while (chain->next != NULL)
  chain = chain->next;

do
  body
while (test);

while (*p)
  {
    /* End loop if we have reached a newline.  */
    if (*p == '\n')
      break;
    p++
  }

struct list_if_tuples
{
  struct list_if_tuples next;
  int length;
  data *contents;
};

void
process_all_elements (struct list_if_tuples *list)
{
  while (list)
    {
      /* Process all the elements in this node’s vector,
         stopping when we reach one that is null.  */
      for (i = 0; i < list->length; i++
        {
          /* Null element terminates this node’s vector.  */
          if (list->contents[i] == NULL)
            /* Exit the for loop.  */
            break;
          /* Operate on the next element.  */
          process_element (list->contents[i]);
        }

      list = list->next;
    }
}

for (start; continue-test; advance)
  body

int i;
for (i = 1; i < n; ++i)
  /* If n is 1 or less, the loop runs zero times,  */
  /* since i < n is false the first time.  */
  {
    /* Now last is fib (i)
       and prev is fib (i - 1).  */
    /* Compute fib (i + 1).  */
    int next = prev + last;
    /* Shift the values down.  */
    prev = last;
    last = next;
    /* Now last is fib (i + 1)
       and prev is fib (i).
       But that won’t stay true for long,
       because we are about to increment i.  */
  }

for (start; continue-test; advance)
  body

int i = 0;
for (; i < n; ++i)

int i;
for (i = 0; i < n; ++i)

for (i = 0; i < n;)
  {
    …
    ++i;
  }

for (i = 0; i < n; ++i)
  {
    …
  }

for (int i = 0; i < n; ++i)
  {
    …
  }

for (int i = 0, j = 1, *p = NULL; i < n; ++i, ++j, ++p)
  {
    …
  }

for (int i; i < n; ++i)
  {
    …
  }

for (;*p; ++p)
  {
    /* End loop if we have reached a newline.  */
    if (*p == '\n')
      break;
    /* Pay no attention to spaces.  */
    if (*p == ' ')
      continue;
    /* Operate on the next character.  */
    …
  }

for (;*p; ++p)
  {
    /* Exit if we have reached a newline.  */
    if (*p == '\n')
      break;
    /* Pay no attention to spaces.  */
    if (*p != ' ')
      {
        /* Operate on the next character.  */
        …
      }
  }

19.7 switch Statement

The switch statement selects code to run according to the value of an expression. The expression, in parentheses, follows the keyword switch. After that come all the cases to select among, inside braces. It looks like this:

switch (selector)
  {
    cases…
  }

A case can look like this:

case value:
  statements
  break;

which means “come here if selector happens to have the value value,” or like this (a GNU C extension):

case rangestart ... rangeend:
  statements
  break;

which means “come here if selector happens to have a value between rangestart and rangeend (inclusive).” See Case Ranges.

The values in case labels must reduce to integer constants. They can use arithmetic, and enum constants, but they cannot refer to data in memory, because they have to be computed at compile time. It is an error if two case labels specify the same value, or ranges that overlap, or if one is a range and the other is a value in that range.

You can also define a default case to handle “any other value,” like this:

default:
  statements
  break;

If the switch statement has no default: label, then it does nothing when the value matches none of the cases.

The brace-group inside the switch statement is a block, and you can declare variables with that scope just as in any other block (see Blocks). However, initializers in these declarations won’t necessarily be executed every time the switch statement runs, so it is best to avoid giving them initializers.

break; inside a switch statement exits immediately from the switch statement. See break Statement.

If there is no break; at the end of the code for a case, execution continues into the code for the following case. This happens more often by mistake than intentionally, but since this feature is used in real code, we cannot eliminate it.

Warning: When one case is intended to fall through to the next, write a comment like ‘falls through’ to say it’s intentional. That way, other programmers won’t assume it was an error and “fix” it erroneously.

Consecutive case statements could, pedantically, be considered an instance of falling through, but we don’t consider or treat them that way because they won’t confuse anyone.

19.8 Example of switch

Here’s an example of using the switch statement to distinguish among characters:

struct vp { int vowels, punct; };

struct vp
count_vowels_and_punct (char *string)
{
  int c;
  int vowels = 0;
  int punct = 0;
  /* Don’t change the parameter itself.  */
  /* That helps in debugging.  */
  char *p = string;
  struct vp value;

  while (c = *p++)
    switch (c)
      {
        case 'y':
        case 'Y':
          /* We assume y_is_consonant will check surrounding
                letters to determine whether this y is a vowel.  */
          if (y_is_consonant (p - 1))
            break;

          /* Falls through */

        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
        case 'A':
        case 'E':
        case 'I':
        case 'O':
        case 'U':
          vowels++;
          break;

        case '.':
        case ',':
        case ':':
        case ';':
        case '?':
        case '!':
        case '\"':
        case '\'':
          punct++;
          break;
      }

  value.vowels = vowels;
  value.punct = punct;

  return value;
}

19.9 Duff’s Device

The cases in a switch statement can be inside other control constructs. For instance, we can use a technique known as Duff’s device to optimize this simple function,

void
copy (char *to, char *from, int count)
{
  while (count > 0)
    *to++ = *from++, count--;
}

which copies memory starting at from to memory starting at to.

Duff’s device involves unrolling the loop so that it copies several characters each time around, and using a switch statement to enter the loop body at the proper point:

void
copy (char *to, char *from, int count)
{
  if (count <= 0)
    return;
  int n = (count + 7) / 8;
  switch (count % 8)
    {
      do {
        case 0: *to++ = *from++;
        case 7: *to++ = *from++;
        case 6: *to++ = *from++;
        case 5: *to++ = *from++;
        case 4: *to++ = *from++;
        case 3: *to++ = *from++;
        case 2: *to++ = *from++;
        case 1: *to++ = *from++;
        } while (--n > 0);
    }
}

19.10 Case Ranges

You can specify a range of consecutive values in a single case label, like this:

case low ... high:

This has the same effect as the proper number of individual case labels, one for each integer value from low to high, inclusive.

This feature is especially useful for ranges of ASCII character codes:

case 'A' ... 'Z':

Be careful: with integers, write spaces around the ... to prevent it from being parsed wrong. For example, write this:

case 1 ... 5:

rather than this:

case 1...5:

19.11 Null Statement

A null statement is just a semicolon. It does nothing.

A null statement is a placeholder for use where a statement is grammatically required, but there is nothing to be done. For instance, sometimes all the work of a for-loop is done in the for-header itself, leaving no work for the body. Here is an example that searches for the first newline in array:

for (p = array; *p != '\n'; p++)
  ;

19.12 goto Statement and Labels

The goto statement looks like this:

goto label;

Its effect is to transfer control immediately to another part of the current function—where the label named label is defined.

An ordinary label definition looks like this:

label:

and it can appear before any statement. You can’t use default as a label, since that has a special meaning for switch statements.

An ordinary label doesn’t need a separate declaration; defining it is enough.

Here’s an example of using goto to implement a loop equivalent to do–while:

{
 loop_restart:
  body
  if (condition)
    goto loop_restart;
}

The name space of labels is separate from that of variables and functions. Thus, there is no error in using a single name in both ways:

{
  int foo;    // Variable foo.
 foo:         // Label foo.
  body
  if (foo > 0)  // Variable foo.
    goto foo;   // Label foo.
}

Blocks have no effect on ordinary labels; each label name is defined throughout the whole of the function it appears in. It looks strange to jump into a block with goto, but it works. For example,

if (x < 0)
  goto negative;
if (y < 0)
  {
   negative:
    printf ("Negative\n");
    return;
  }

If the goto jumps into the scope of a variable, it does not initialize the variable. For example, if x is negative,

if (x < 0)
  goto negative;
if (y < 0)
  {
    int i = 5;
   negative:
    printf ("Negative, and i is %d\n", i);
    return;
  }

prints junk because i was not initialized.

If the block declares a variable-length automatic array, jumping into it gives a compilation error. However, jumping out of the scope of a variable-length array works fine, and deallocates its storage.

A label can’t come directly before a declaration, so the code can’t jump directly to one. For example, this is not allowed:

{
  goto foo;
foo:
  int x = 5;
  bar(&x);
}

The workaround is to add a statement, even an empty statement, directly after the label. For example:

{
  goto foo;
foo:
  ;
  int x = 5;
  bar(&x);
}

Likewise, a label can’t be the last thing in a block. The workaround solution is the same: add a semicolon after the label.

These unnecessary restrictions on labels make no sense, and ought in principle to be removed; but they do only a little harm since labels and goto are rarely the best way to write a program.

These examples are all artificial; it would be more natural to write them in other ways, without goto. For instance, the clean way to write the example that prints ‘Negative’ is this:

if (x < 0 || y < 0)
  {
    printf ("Negative\n");
    return;
  }

It is hard to construct simple examples where goto is actually the best way to write a program. Its rare good uses tend to be in complex code, thus not apt for the purpose of explaining the meaning of goto.

The only good time to use goto is when it makes the code simpler than any alternative. Jumping backward is rarely desirable, because usually the other looping and control constructs give simpler code. Using goto to jump forward is more often desirable, for instance when a function needs to do some processing in an error case and errors can occur at various different places within the function.

19.13 Locally Declared Labels

In GNU C you can declare local labels in any nested block scope. A local label is used in a goto statement just like an ordinary label, but you can only reference it within the block in which it was declared.

A local label declaration looks like this:

__label__ label;

or

__label__ label1, label2, …;

Local label declarations must come at the beginning of the block, before any ordinary declarations or statements.

The label declaration declares the label name, but does not define the label itself. That’s done in the usual way, with label:, before one of the statements in the block.

The local label feature is useful for complex macros. If a macro contains nested loops, a goto can be useful for breaking out of them. However, an ordinary label whose scope is the whole function cannot be used: if the macro can be expanded several times in one function, the label will be multiply defined in that function. A local label avoids this problem. For example:

#define SEARCH(value, array, target)              \
do {                                              \
  __label__ found;                                \
  __auto_type _SEARCH_target = (target);          \
  __auto_type _SEARCH_array = (array);            \
  int i, j;                                       \
  int value;                                      \
  for (i = 0; i < max; i++)                       \
    for (j = 0; j < max; j++)                     \
      if (_SEARCH_array[i][j] == _SEARCH_target)  \
        { (value) = i; goto found; }              \
  (value) = -1;                                   \
 found:;                                          \
} while (0)

This could also be written using a statement expression (see Statements and Declarations in Expressions):

#define SEARCH(array, target)                     \
({                                                \
  __label__ found;                                \
  __auto_type _SEARCH_target = (target);      \
  __auto_type _SEARCH_array = (array);     \
  int i, j;                                       \
  int value;                                      \
  for (i = 0; i < max; i++)                       \
    for (j = 0; j < max; j++)                     \
      if (_SEARCH_array[i][j] == _SEARCH_target)  \
        { value = i; goto found; }                \
  value = -1;                                     \
 found:                                           \
  value;                                          \
})

Ordinary labels are visible throughout the function where they are defined, and only in that function. However, explicitly declared local labels of a block are visible in nested function definitions inside that block. See Nested Functions, for details.

See goto Statement and Labels.

19.14 Labels as Values

In GNU C, you can get the address of a label defined in the current function (or a local label defined in the containing function) with the unary operator ‘&&’. The value has type void *. This value is a constant and can be used wherever a constant of that type is valid. For example:

void *ptr;
…
ptr = &&foo;

To use these values requires a way to jump to one. This is done with the computed goto statement⁵, goto *exp;. For example,

goto *ptr;

Any expression of type void * is allowed.

See goto Statement and Labels.

• Label Value Uses
• Label Value Caveats

static void *array[] = { &&foo, &&bar, &&hack };

goto *array[i];

static const int array[] = { &&foo - &&foo, &&bar - &&foo,
                             &&hack - &&foo };
goto *(&&foo + array[i]);

19.15 Statements and Declarations in Expressions

A block enclosed in parentheses can be used as an expression in GNU C. This provides a way to use local variables, loops and switches within an expression. We call it a statement expression.

Recall that a block is a sequence of statements surrounded by braces. In this construct, parentheses go around the braces. For example:

({ int y = foo (); int z;
   if (y > 0) z = y;
   else z = - y;
   z; })

is a valid (though slightly more complex than necessary) expression for the absolute value of foo ().

The last statement in the block should be an expression statement; an expression followed by a semicolon, that is. The value of this expression serves as the value of statement expression. If the last statement is anything else, the statement expression’s value is void.

This feature is mainly useful in making macro definitions compute each operand exactly once. See Using __auto_type for Local Variables.

Statement expressions are not allowed in expressions that must be constant, such as the value for an enumerator, the width of a bit-field, or the initial value of a static variable.

Jumping into a statement expression—with goto, or using a switch statement outside the statement expression—is an error. With a computed goto (see Labels as Values), the compiler can’t detect the error, but it still won’t work.

Jumping out of a statement expression is permitted, but since subexpressions in C are not computed in a strict order, it is unpredictable which other subexpressions will have been computed by then. For example,

  foo (), (({ bar1 (); goto a; 0; }) + bar2 ()), baz();

calls foo and bar1 before it jumps, and never calls baz, but may or may not call bar2. If bar2 does get called, that occurs after foo and before bar1.

20.1 Variable Declarations

Here’s what a variable declaration looks like:

keywords basetype decorated-variable [= init];

The keywords specify how to handle the scope of the variable name and the allocation of its storage. Most declarations have no keywords because the defaults are right for them.

C allows these keywords to come before or after basetype, or even in the middle of it as in unsigned static int, but don’t do that—it would surprise other programmers. Always write the keywords first.

The basetype can be any of the predefined types of C, or a type keyword defined with typedef. It can also be struct tag, union tag, or enum tag. In addition, it can include type qualifiers such as const and volatile (see Type Qualifiers).

In the simplest case, decorated-variable is just the variable name. That declares the variable with the type specified by basetype. For instance,

int foo;

uses int as the basetype and foo as the decorated-variable. It declares foo with type int.

struct tree_node foo;

declares foo with type struct tree_node.

• Declaring Arrays and Pointers
• Combining Variable Declarations

int foo[5];

struct list_elt *foo;

int foo[3][5];

struct list_elt *foo[5];

struct list_elt **foo;

int **(*foo[30])(int, double);

void
bar (int size)
{
  int foo[size];
  …
}

keywords basetype
   decorated-variable-1 [= init1],
   decorated-variable-2 [= init2];

keywords basetype
   decorated-variable-1 [= init1];
keywords basetype
   decorated-variable-2 [= init2];

int a, b;
int a = 1, b = 2;
int a, *p, array[5];
int a = 0, *p = &a, array[5] = {1, 2};

20.2 Initializers

A variable’s declaration, unless it is extern, should also specify its initial value. For numeric and pointer-type variables, the initializer is an expression for the value. If necessary, it is converted to the variable’s type, just as in an assignment.

You can also initialize a local structure-type (see Structures) or local union-type (see Unions) variable this way, from an expression whose value has the same type. But you can’t initialize an array this way (see Arrays), since arrays are not first-class objects in C (see Limitations of C Arrays) and there is no array assignment.