The GNU C Reference Manual

https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html
Admin
The GNU C Reference Manual documents the C programming language as implemented by the GNU Compiler...
Tokens:52,741
Snippets:497
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Output of Prefix vs Postfix Increment Example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

The output produced by the prefix vs postfix increment example.

```text
5
7

```

--------------------------------

### Valid declaration order example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows that a declaration is visible to declarations that come after it. This example works because x is declared before y uses it.

```c
int x = 5;
int y = x + 10;

```

--------------------------------

### Complex conjugation operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

GNU extension using ~ to conjugate a complex number. The example prints 314, which equals 25 + 289.

```c
__complex__ int x = 5 + 17i;
 
printf ("%d  \n", (x * ~x));

```

--------------------------------

### GCC computed goto example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Demonstrates GCC's extension allowing goto to jump to an address stored in a void* variable, using the && operator to take label addresses. This example uses a jump table to implement a rock-paper-scissors game.

```c
enum Play { ROCK=0, PAPER=1, SCISSORS=2 };
enum Result { WIN, LOSE, DRAW };

static enum Result turn (void) 
{
  const void * const jumptable[] = {&&rock, &&paper, &&scissors};
  enum Play opp;                /* opponent’s play */
  goto *jumptable[select_option (&opp)];
 rock:
  return opp == ROCK ? DRAW : (opp == PAPER ? LOSE : WIN);
 paper:
  return opp == ROCK ? WIN  : (opp == PAPER ? DRAW : LOSE);
 scissors:
  return opp == ROCK ? LOSE : (opp == PAPER ? WIN  : DRAW);
}

```

--------------------------------

### Equivalent fully initialized array

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the fully initialized array that results from the designated initializer examples.

```c
int my_array[5] = { 0, 0, 5, 0, 9 };

```

--------------------------------

### Less-than operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the < operator testing if x is less than y.

```c
if (x < y)
  puts ("x is less than y");

```

--------------------------------

### Prefix vs Postfix Increment Example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the difference between prefix and postfix increment. The output is `5` then `7`.

```c
int x = 5;
printf ("%d \n", x++);    /* Print x and then increment it. */
/* x is now equal to 6. */
printf ("%d \n", ++x);    /* Increment x and then print it. */

```

--------------------------------

### Invalid declaration order example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows that a declaration is not visible to declarations that came before it. This example will not work because y is used before it is declared.

```c
int x = y + 10;
int y = 5;

```

--------------------------------

### Example of goto statement with label

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Illustrates a goto statement jumping to a label 'end_of_program'. The ellipsis represents other code.

```c
goto end_of_program;
…
end_of_program:

```

--------------------------------

### Equivalent if-else statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the if-else equivalent of the conditional assignment example. If x equals 5, a gets y; otherwise a gets z.

```c
if (x == 5)
    a = y;
else
    a = z;

```

--------------------------------

### typedef examples for basic types

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Creates new names for unsigned char and double using typedef.

```c
typedef unsigned char byte_type;
typedef double real_number_type;

```

--------------------------------

### Output of fall-through switch example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

The output produced by the preceding switch example without break statements.

```text
x is 0
x is 1
x is something else

```

--------------------------------

### Less-than-or-equal-to operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the <= operator testing if x is less than or equal to y.

```c
if (x <= y)
  puts ("x is less than or equal to y");

```

--------------------------------

### Designated initializer with assignment operator

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Equivalent to the previous example but uses the assignment operator for clarity.

```c
int my_array[5] = { [2] = 5, [4] = 9 };

```

--------------------------------

### Function pointer example: message and example functions

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows calling a function through a pointer. The indirection operator * is optional when calling, and the & is optional when assigning. The example function selects between foo and bar based on a flag.

```c
void message (void (*func)(int), int times)
{
  int j;
  for (j=0; j<times; ++j)
    func (j);  /* (*func) (j); would be equivalent. */
}

void example (int want_foo) 
{
  void (*pf)(int) = &bar; /* The & is optional. */
  if (want_foo)
    pf = foo;
  message (pf, 5);
}

```

--------------------------------

### Addition operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows addition of integers, floating-point numbers, and pointers. Pointers can be added, but not multiplied or divided.

```c
/* Addition. */
x = 5 + 3;
y = 10.23 + 37.332;
quux_pointer = foo_pointer + bar_pointer;

```

--------------------------------

### Function pointer example: foo and bar definitions

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines two simple functions, foo and bar, that print messages. These are used in the function pointer example that follows.

```c
#include <stdio.h>

void foo (int i)
{
  printf ("foo %d!\n", i);
}

```

```c
void bar (int i)
{
  printf ("%d bar!\n", i);
}

```

--------------------------------

### Standalone function call example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Calls the function 'foo' with the parameter 5 as a standalone statement.

```c
foo (5);

```

--------------------------------

### Bitwise OR example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows bitwise inclusive disjunction: resulting bit is 0 only when both corresponding bits are 0.

```text
11001001 | 10011011 = 11011011

```

--------------------------------

### do loop printing integers 0-9

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example that prints the integers from zero through nine using a do loop and the post-increment operator.

```c
int x = 0;
do
  printf ("%d ", x++);
while (x < 10);

```

--------------------------------

### Bitwise operators in C code

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Examples of using &, |, ^, and ~ with unsigned integer operands.

```c
unsigned int foo = 42;
unsigned int bar = 57;
unsigned int quux;

quux = foo & bar;
quux = foo | bar;
quux = foo ^ bar;
quux = ~foo;

```

--------------------------------

### Greater-than operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the > operator testing if x is greater than y.

```c
if (x > y)
  puts ("x is greater than y");

```

--------------------------------

### Signed loop index overflow example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Contrived example showing two instances of signed overflow in a loop index and comparison. A compiler might optimize away or transform the comparisons, breaking wraparound assumptions.

```c
for (i = INT_MAX - 10; i <= INT_MAX; i++)
  if (i + 1 < 0)
    {
      report_overflow ();
      break;
    }

```

--------------------------------

### Equal-to operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the == operator testing equality. Prints a message based on whether x equals y.

```c
if (x == y)
  puts ("x is equal to y");
else
  puts ("x is not equal to y");

```

--------------------------------

### Bitwise AND example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows bitwise conjunction: resulting bit is 1 only when both corresponding bits are 1.

```text
11001001 & 10011011 = 10001001

```

--------------------------------

### Greater-than-or-equal-to operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the >= operator testing if x is greater than or equal to y.

```c
if (x >= y)
  puts ("x is greater than or equal to y");

```

--------------------------------

### Subtraction operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows subtraction of integers, floating-point numbers, and pointers. Pointers can be subtracted.

```c
/* Subtraction. */
x = 5 - 3;
y = 57.223 - 10.903;
quux_pointer = foo_pointer - bar_pointer;

```

--------------------------------

### while loop printing integers 0-9

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example that prints the integers from zero through nine using a while loop and the post-increment operator.

```c
int counter = 0;
while (counter < 10)
  printf ("%d ", counter++);

```

--------------------------------

### Basic Expression Examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows simple expressions: a literal, an arithmetic expression, and a function call with a comment. Innermost expressions are evaluated first.

```c
47
2 + 2
cosine(3.14159) /* We presume this returns a floating point value. */

```

--------------------------------

### if statement example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Executes puts ("x is 10"); only when x equals 10.

```c
if (x == 10)
  puts ("x is 10");

```

--------------------------------

### Real number constant examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Examples of real number constants in C. The integer constant 4 is automatically converted to double in the third assignment.

```c
double a, b, c, d, e, f;

a = 4.7;

b = 4.;

c = 4;

d = .7;

e = 0.7;
```

--------------------------------

### Bitwise NOT example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows bitwise negation: reverses each bit in the operand.

```text
~11001001 = 00110110

```

--------------------------------

### Multiplication operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows multiplication of integers and floating-point numbers. Pointers cannot be multiplied.

```c
/* Multiplication. */
x = 5 * 3;
y = 47.4 * 1.001;

```

--------------------------------

### Not-equal-to operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the != operator testing inequality. Prints a message based on whether x is not equal to y.

```c
if (x != y)
  puts ("x is not equal to y");
else
  puts ("x is equal to y");

```

--------------------------------

### if statement with else example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Executes one of two puts statements depending on whether x equals 10.

```c
if (x == 10)
  puts ("x is 10");
else
  puts ("x is not 10");

```

--------------------------------

### Pass-by-value example with function definition

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows that modifying a parameter inside a function does not change the original variable.

```c
int x = 23;
foo (x);
…
/* Definition for function foo. */
int foo (int a)
{
  a = 2 * a;
  return a;
}

```

--------------------------------

### Label example: treet

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows a simple label named treet followed by a colon. Labels identify source code for use with a later goto statement.

```c
treet:

```

--------------------------------

### String constant examples with concatenation and escape sequences

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows a single string constant, adjacent string constants that are concatenated, and a string using the \" escape sequence to include double quotes.

```c
/* This is a single string constant. */
"tutti frutti ice cream"

/* These string constants will be concatenated, same as above. */
"tutti " "frutti" " ice " "cream"

/* This one uses two escape sequences. */
"\"hello, world!\""

```

--------------------------------

### Bitwise XOR example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows bitwise exclusive disjunction: resulting bit is 1 when corresponding bits are different.

```text
11001001 ^ 10011011 = 01010010

```

--------------------------------

### Define an enumeration with explicit starting value

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines an enumeration 'more_fruit' where 'banana' is explicitly set to -17, and subsequent values increment by 1.

```c
enum more_fruit {banana = -17, apple, blueberry, mango};

```

--------------------------------

### Modulus operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the modulus operator % returning the remainder of integer division. Operands must be of a primitive integer type.

```c
/* Modular division. */
x = 5 % 3;
y = 74 % 47;

```

--------------------------------

### Declaring an Array with a Variable Size

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows a GNU extension that allows array sizes to be declared using variables. The example declares an array inside a function using its parameter as the number of elements.

```c
int
my_function (int number)
{
  int my_array[number];
  …;
}

```

--------------------------------

### Decrement Operator Example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the decrement operator `--` subtracting 1 from an operand. Prefix and postfix concepts apply as with the increment operator.

```c
int x = 5;

x--; /* x is now 4. */

```

--------------------------------

### Case range for ASCII characters

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example of using a case range with character literals to match any uppercase letter.

```c
case 'A' ... 'Z':

```

--------------------------------

### for loop with omitted initialize expression

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows that the initialize expression is optional. Here x is initialized before the loop, and the for statement starts with an empty initialize clause.

```c
int x = 1;
for (; x <= 10; x++)
  printf ("%d ", x);

```

--------------------------------

### switch statement with break and default

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Practical example of a switch statement that uses break in each case to prevent fall-through and includes a default case for unmatched values.

```c
switch (x)
  {
    case 0:
      puts ("x is 0");
      break;
    case 1:
      puts ("x is 1");
      break;
    default:
      puts ("x is something else");
      break;
  }

```

--------------------------------

### Division operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows division of integers and floating-point numbers. Integer division truncates toward zero for positive values; negative operands have implementation-defined rounding.

```c
/* Division. */
x = 5 / 3;
y = 940.0 / 20.2;

```

--------------------------------

### Parenthesized Subexpression Example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Demonstrates grouping subexpressions with parentheses. Innermost expressions are evaluated first; the outermost parentheses are optional.

```c
( 2 * ( ( 3 + 10 ) - ( 2 * 6 ) ) )

```

--------------------------------

### hello.c: Complete sample GNU C program

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

A complete C source file for a sample GNU program that prints a customizable greeting. It demonstrates GNU coding standards, including command-line option parsing with getopt_long, localization via gettext, and proper exit status handling with close_stdout. The program supports options --greeting, --help, --next-generation, --traditional, and --version.

```C
/* hello.c -- print a greeting message and exit.

   Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   2005, 2006, 2007 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

#include <config.h>
#include "system.h"

/* String containing name the program is called with.  */
const char *program_name;

static const struct option longopts[] =
{
  { "greeting", required_argument, NULL, 'g' },
  { "help", no_argument, NULL, 'h' },
  { "next-generation", no_argument, NULL, 'n' },
  { "traditional", no_argument, NULL, 't' },
  { "version", no_argument, NULL, 'v' },
  { NULL, 0, NULL, 0 }
};

static void print_help (void);
static void print_version (void);

int
main (int argc, char *argv[])
{
  int optc;
  int t = 0, n = 0, lose = 0;
  const char *greeting = NULL;

  program_name = argv[0];

  /* Set locale via LC_ALL.  */
  setlocale (LC_ALL, "");

#if ENABLE_NLS
  /* Set the text message domain.  */
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);
#endif

  /* Even exiting has subtleties.  The /dev/full device on GNU/Linux
     can be used for testing whether writes are checked properly.  For
     instance, hello >/dev/full should exit unsuccessfully.  On exit,
     if any writes failed, change the exit status.  This is
     implemented in the Gnulib module "closeout".  */
  atexit (close_stdout);

  while ((optc = getopt_long (argc, argv, "g:hntv", longopts, NULL)) != -1)
    switch (optc)
      {
      /* One goal here is having --help and --version exit immediately,
         per GNU coding standards.  */
      case 'v':
        print_version ();
        exit (EXIT_SUCCESS);
        break;
      case 'g':
        greeting = optarg;
        break;
      case 'h':
        print_help ();
        exit (EXIT_SUCCESS);
        break;
      case 'n':
        n = 1;
        break;
      case 't':
        t = 1;
        break;
      default:
        lose = 1;
        break;
      }

  if (lose || optind < argc)
    {
      /* Print error message and exit.  */
      if (optind < argc)
        fprintf (stderr, _("%s: extra operand: %s\n"),
		 program_name, argv[optind]);
      fprintf (stderr, _("Try `%s --help' for more information.\n"),
               program_name);
      exit (EXIT_FAILURE);
    }

  /* Print greeting message and exit. */
  if (t)
    printf (_("hello, world\n"));

  else if (n)
    /* TRANSLATORS: Use box drawing characters or other fancy stuff
       if your encoding (e.g., UTF-8) allows it.  If done so add the
       following note, please:

       [Note: For best viewing results use a UTF-8 locale, please.]
    */
	printf (_("\
+---------------+\n\
| Hello, world! |\n\
+---------------+\n\
"));

  else
    {
      if (!greeting)
        greeting = _("Hello, world!");
      puts (greeting);
    }
  
  exit (EXIT_SUCCESS);
}



/* Print help info.  This long message is split into
   several pieces to help translators be able to align different
   blocks and identify the various pieces.  */

static void
print_help (void)
{
  /* TRANSLATORS: --help output 1 (synopsis)
     no-wrap */
        printf (_("\
Usage: %s [OPTION]...\n"), program_name);

  /* TRANSLATORS: --help output 2 (brief description)
     no-wrap */
  fputs (_("\
Print a friendly, customizable greeting.\n"), stdout);

  puts ("");
  /* TRANSLATORS: --help output 3: options 1/2
     no-wrap */
  fputs (_("\
  -h, --help          display this help and exit\n\
  -v, --version       display version information and exit\n"), stdout);
}
```

--------------------------------

### Function call requiring a return value

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example of calling a function in a context that requires a return value, assigning the result to x.

```c
x = cosine (y);

```

--------------------------------

### Declaring and defining integer variables

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example showing how to declare and define integer variables in C. The first line declares an integer named foo without initializing it, leaving its value unspecified. The second line defines an unsigned int bar initialized to 42, and the third line defines a char quux initialized to the character 'a'.

```c
int foo;
unsigned int bar = 42;
char quux = 'a';

```

--------------------------------

### Equivalent Assignment Using = Operator

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the equivalent assignment using the standard `=` operator. This is the same result as the compound assignment example because there are no side effects from evaluating `x` as an lvalue.

```c
x = x + y;

```

--------------------------------

### main function with command-line parameters

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines main with argc and argv to accept command-line parameters. argc is the number of parameters including the program name; argv is an array of strings. Prints each parameter.

```c
int
main (int argc, char *argv[])
{
  int counter;

  for (counter = 0; counter < argc; counter++)
    printf ("%s\n", argv[counter]);
  
  return 0;
}

```

--------------------------------

### Compound Assignment Operator Example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the compound assignment operator `+=`. The result is equivalent to `x = x + y;` because evaluating `x` as an lvalue has no side effects.

```c
x += y;

```

--------------------------------

### Function pointer initialization with and without &

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Demonstrates that the address operator is optional when taking the address of a function; both forms are equivalent.

```c
extern int foo (void);
int (*fp1) (void) = foo; /* fp1 points to foo */
int (*fp2) (void) = &foo; /* fp2 also points to foo */

```

--------------------------------

### Unary positive operator example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the unary positive operator +42. It has no effect on program operation because numeric values are positive by default.

```c
int x = +42;

```

--------------------------------

### Infinite recursion example (watermelon)

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Demonstrates an infinitely recursive function that never stops until the program is interrupted or runs out of memory. The function calls itself with the same argument, so there is no base case.

```C
int
watermelon (int x)
{
  return (watermelon (x));
}

```

--------------------------------

### Conditional operator assignment example

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Assigns y to a if x equals 5, otherwise assigns z. Demonstrates the conditional operator as a shorthand for an if-else statement.

```c
a = (x == 5) ? y : z;

```

--------------------------------

### switch statement without break (fall-through)

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example showing that without break, all following cases execute after a match. The output is 'x is 0', 'x is 1', 'x is something else'.

```c
int x = 0;
switch (x)
  {
    case 0:
      puts ("x is 0");
    case 1:
      puts ("x is 1");
    default:
      puts ("x is something else");
  }

```

--------------------------------

### Increment Operator Examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the increment operator `++` applied to variables of different primitive types and a pointer. Note that incrementing a pointer only makes sense if the new pointer value is a valid memory address.

```c
char w = '1';
int x = 5;
char y = 'B';
float z = 5.2;
int *p = &x;

++w;   /* w is now the character ‘2’ (not the value 2). */
x++;   /* x is now 6. */
++y;   /* y is now ‘C’ (on ASCII systems). */
z++;   /* z is now 6.2. */
++p;   /* p is now &x + sizeof(int). */

```

--------------------------------

### Function sum_of_squares using for loop

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Computes the summation of squares from start to end inclusive. Uses a for loop to accumulate i*i into sum and returns the result.

```c
int
sum_of_squares (int start, int end)
{
  int i, sum = 0;
  for (i = start; i <= end; i++)
    sum += i * i;
  return sum;
}

```

--------------------------------

### Initialize a range of elements with GNU extension

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Uses the GNU range syntax [first ... last] to set a range of elements to the same value. Spaces around '...' are required.

```c
int new_array[100] = { [0 ... 9] = 1, [10 ... 98] = 2, 3 };

```

--------------------------------

### Negation operator examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows unary negation on int and float. For unsigned operands, the result is the maximum value of the unsigned type minus the operand value.

```c
/* Negation. */
int x = -5;
float y = -3.14159;

```

--------------------------------

### Initialize first three elements, rest default to zero

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes only the first three elements; the remaining two are automatically set to zero.

```c
int my_array[5] = { 0, 1, 2 };

```

--------------------------------

### Initialize array with full list of values

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Declares an array of five integers and initializes all elements with a comma-separated list in braces.

```c
int my_array[5] = { 0, 1, 2, 3, 4 };

```

--------------------------------

### Accessing Structure Members with the Member Access Operator

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows how to access members of a structure variable using the dot operator. The example declares a struct point with x and y members, creates a variable first_point, and assigns values to its members.

```c
struct point
  {
    int x, y;
  };

struct point first_point;

first_point.x = 0;
first_point.y = 5;

```

--------------------------------

### General form of goto statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a goto statement: 'goto label;'. The label must be in the same function.

```c
goto label;

```

--------------------------------

### Standard Assignment Operator Examples

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the standard assignment operator `=` storing values in variables. The left operand cannot be a literal or constant. Unlike compound assignment operators, `=` can store structure values.

```c
int x = 10;
float y = 45.12 + 2.0;
int z = (2 * (3 + function () ));

struct foo {
  int bar;
  int baz;
} quux = {3, 4};

```

--------------------------------

### Defining Bit Fields in a Structure

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines a structure type with two bit fields: suit (2 bits) and face_value (4 bits). The example uses unsigned int, giving ranges 0-3 and 0-15 respectively. Signed bit fields would have different ranges.

```c
struct card
  {
    unsigned int suit : 2;
    unsigned int face_value : 4;
  };

```

--------------------------------

### General form of a function call

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax for calling a function with parameters.

```c
function-name (parameters)

```

--------------------------------

### General form of the for statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a for loop: initialize, test, and step expressions followed by a statement. The test is evaluated before each iteration; if false, the loop ends.

```c
for (initialize; test; step)
  statement

```

--------------------------------

### INT_MIN negation program and output

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Program demonstrating that negating INT_MIN yields INT_MIN on twos-complement systems. Output shows INT_MAX, INT_MIN, and -INT_MIN values.

```c
#include <limits.h>
#include <stdio.h>

int main (int argc, char *argv[]) 
{
  int x;
  x = INT_MAX;
  printf("INT_MAX  = %d\n", x);
  x = INT_MIN;
  printf("INT_MIN  = %d\n", x);
  x = -x;
  printf("-INT_MIN = %d\n", x);
  return 0;
}

```

```output
INT_MAX  = 2147483647
INT_MIN  = -2147483648
-INT_MIN = -2147483648

```

--------------------------------

### Declare and initialize character arrays as strings

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows five ways to declare and initialize character arrays as strings. The null character '\0' is included automatically even when not explicitly stated, except when initializing with individual characters where it is not guaranteed.

```c
char blue[26];
char yellow[26] = {'y', 'e', 'l', 'l', 'o', 'w', '\0'};
char orange[26] = "orange";
char gray[] = {'g', 'r', 'a', 'y', '\0'};
char salmon[] = "salmon";
```

--------------------------------

### Dereferencing a pointer with *

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows how to assign a pointer to an address and then dereference it to read the stored value.

```c
int x = 5;
int y;
int *ptr;

ptr = &x;    /* ptr now holds the address of x. */

y = *ptr;    /* y gets the value stored at the address
                stored in ptr. */

```

--------------------------------

### Simple main function with no parameters

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines main with no parameters, prints a message, and returns 0 to indicate success. In C99, reaching the end of main without a return is equivalent to return 0.

```c
int
main (void)
{
  puts ("Hi there!");
  return 0;
}

```

--------------------------------

### Address operator & to obtain memory address

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows how to use the address operator & to store the memory address of an integer variable in a pointer.

```c
int x = 5;
int *pointer_to_x = &x;

```

--------------------------------

### General form of function definition

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax for a function definition, including the body enclosed in braces. Parameter names are required in definitions.

```c
return-type
function-name (parameter-list)
{
  function-body
}

```

--------------------------------

### Functionally identical programs with and without white space

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows two versions of a simple program that are functionally identical because white space is ignored outside string constants.

```c
#include <stdio.h>

int
main()
{
  printf( "hello, world\n" );
  return 0;
}

```

```c
#include <stdio.h> int main(){printf("hello, world\n");
return 0;}

```

--------------------------------

### General form of return statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a return statement: 'return return-value;'. return-value is optional; returning an expression is invalid for void functions.

```c
return return-value;

```

--------------------------------

### Initialize structure members with GNU C extension syntax

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes members by name using the member: value syntax, omitting the period and using a colon instead of '='. This is a GNU C extension.

```c
struct point first_point = { y: 10, x: 5 };

```

--------------------------------

### General form of switch statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a switch statement with multiple case labels and an optional default case. All compared expressions must be of integer type, and compare-N expressions must be constant integers.

```c
switch (test)
  {
    case compare-1:
      if-equal-statement-1
    case compare-2:
      if-equal-statement-2
    …
    default:
      default-statement
  }

```

--------------------------------

### Initialize structure members with designated initializers (C99)

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes members by name using the .member = value syntax. Available in C99 and as a C89 extension in GCC. Allows initializing members in any order.

```c
struct point first_point = { .y = 10, .x = 5 };

```

--------------------------------

### Source file sqrt.c with function definition

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Implements the computeSqrt function declared in sqrt.h. Includes the header file and provides the function definition. The ellipsis (…) represents the implementation body.

```c
/* sqrt.c */
#include "sqrt.h"

double
computeSqrt (double x)
{
  double result;
  …
  return result;
}

```

--------------------------------

### Left shift operator <<

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shifts bits left, discarding bits shifted off the left and adding zeros on the right. Example shows 47 shifted left by 1.

```c
x = 47;    /* 47 is 00101111 in binary. */
x << 1;    /* 00101111 << 1 is 01011110. */

```

--------------------------------

### Initialize structure members with positional values

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes the x member to 5 and the y member to 10 using a brace-enclosed list in declaration order.

```c
struct point
  {
    int x, y;
  };
struct point first_point = { 5, 10 };

```

--------------------------------

### for loop with omitted step expression

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Omitting the step expression prevents progress toward loop completion. This example prints the number 1 repeatedly because x is never incremented.

```c
for (x = 1; x <= 10;)
  printf ("%d ", x);

```

--------------------------------

### Infinite for loop with omitted test expression

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Omitting the test expression creates an infinite loop, equivalent to using 1 as the test. This example prints x incremented by 1 indefinitely.

```c
for (x = 1; ; x++)
  printf ("%d ", x);

```

--------------------------------

### Initialize union member with colon syntax

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes a specific union member using the colon syntax: member name followed by a colon and the value. This allows initializing any member, not just the first.

```c
union numbers first_number = { f: 3.14159 };

```

--------------------------------

### Function call with multiple parameters

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Calls 'quux' with two arguments separated by a comma.

```c
a = quux (5, 10);

```

--------------------------------

### Operator precedence pitfall with pointer increment

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example showing that unary operators bind right to left. In this expression, p is incremented as a side effect, but foo takes the value of *(p++) rather than (*p)++.

```c
foo = *p++;
```

--------------------------------

### String constants with different spacing are not the same

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows that spaces inside string constants are significant, so the two strings are not identical.

```c
"potato knish"

```

```c
"potato                        knish"

```

--------------------------------

### Accessing Nested Structure Members

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows how to access members of a structure that is itself a member of another structure. The example declares a struct rectangle containing two struct point members and assigns values to their x and y fields.

```c
struct rectangle
  {
    struct point top_left, bottom_right;
  };

struct rectangle my_rectangle;

my_rectangle.top_left.x = 0;
my_rectangle.top_left.y = 5;

my_rectangle.bottom_right.x = 10;
my_rectangle.bottom_right.y = 0;

```

--------------------------------

### Compound statement expression for absolute value

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

A GNU C extension that uses a compound statement inside parentheses to create an expression. The last expression (z;) becomes the value of the construct. This example computes the absolute value of function().

```c
({ int y = function (); int z;
    if (y > 0) z = y;
   else z = - y;
   z; })
```

--------------------------------

### C code with signed overflow leading to undefined behavior

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

This example shows how signed overflow can cause undefined behavior, allowing the compiler to optimize away security checks. If counter equals INT_MAX, counter++ overflows, making the behavior undefined and potentially removing the password test.

```c
if (password == expected_password)
  allow_superuser_privileges ();
else if (counter++ == INT_MAX)
  abort ();
else
  printf ("%d password mismatches\n", counter);

```

--------------------------------

### Loop iterating through powers of 2

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Example loop that attempts to iterate through all powers of 2 representable by int. The C standard allows a compiler to optimize away the comparison and generate an infinite loop because behavior is undefined on overflow. As of writing, this optimization is not done by any production GCC with -O2, but may be performed by other compilers or more aggressive GCC options.

```c
int j;
for (j = 1; 0 < j; j *= 2)
  test (j);

```

--------------------------------

### Print integers from zero through nine with for loop

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

A counter-controlled loop that initializes x to 0, tests x < 10, and increments x each iteration. The body prints the current value of x.

```c
int x;
for (x = 0; x < 10; x++)
  printf ("%d ", x);

```

--------------------------------

### General form of while statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a while loop with an exit test at the beginning. The loop continues as long as test evaluates to true.

```c
while (test)
  statement

```

--------------------------------

### Any amount of white space allowed where one space is allowed

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows two statements that are functionally identical despite different white space usage.

```c
/* These two statements are functionally identical. */
x++;

x
       ++       ;

```

--------------------------------

### General form of pointer declaration

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the general syntax for declaring a pointer: data-type followed by the indirection operator and the pointer name.

```c
data-type * name;

```

--------------------------------

### Initializing a pointer with a variable address

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Declares an int variable i and a pointer ip initialized with the address of i using the address operator.

```c
int i;
int *ip = &i;

```

--------------------------------

### Initialize array of structures with inner braces

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes the elements of a structure array. The additional inner grouping braces are optional.

```c
struct point point_array [3] = { {2, 3}, {4, 5}, {6, 7} };
```

--------------------------------

### Store date in a single integer using shifts

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Packs day, month, and year into one integer using left shifts and addition.

```c
int d = 12;
int m = 6;
int y = 1983;
int x = (((y << 4) + m) << 5) + d;

```

--------------------------------

### Calling a function with a pointer parameter

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows how to modify a variable by passing its address and dereferencing the pointer.

```c
void
foo (int *x)
{
  *x = *x + 42;
}
…
int a = 15;
foo (&a);

```

--------------------------------

### General form of if statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the general syntax of an if statement with optional else clause. If test is true, then-statement executes; otherwise else-statement executes.

```c
if (test)
  then-statement
else
  else-statement

```

--------------------------------

### Initialize nested structure members

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines a rectangle structure containing two point structures and initializes its members with nested braces. The extra braces are optional but improve readability.

```c
struct point
  {
    int x, y;
  };

struct rectangle
  {
    struct point top_left, bottom_right;
  };

struct rectangle my_rectangle = { {0, 5}, {10, 0} };

```

--------------------------------

### General form of do statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax of a do loop with an exit test at the end. The loop body executes at least once before the test is evaluated.

```c
do
  statement
while (test);

```

--------------------------------

### Function declaration with two parameters

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Declares a function foo taking an int and a double, returning int.

```c
int foo (int, double);

```

--------------------------------

### Initialize fewer than all structure members

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes only the x member to 5; y is initialized to 0 and p to NULL, as if they were static variables.

```c
struct pointy
  {
    int x, y;
    char *p;
  };
struct pointy first_pointy = { 5 };

```

--------------------------------

### Header file sqrt.h with function declaration

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Declares the computeSqrt function in a header file so other source files can use it without knowing the implementation. By convention, header files contain declarations, not definitions.

```c
/* sqrt.h */

double
computeSqrt (double x);

```

--------------------------------

### Partially initialize structure array with grouping braces

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows partial initialization of some structures in the array. With grouping braces, the value 4 is assigned to the x member of the second element, not to the y member of the first.

```c
struct point point_array [3] = { {2}, {4, 5}, {6, 7} };
```

--------------------------------

### Function declaration with parameter names

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Declares a function foo with named parameters x and y. Parameter names in declaration need not match those in definition.

```c
int foo (int x, double y);

```

--------------------------------

### Extract date components using shifts and modulo

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Extracts the original day, month, and year from the packed integer using right shifts and modular division.

```c
d = x % 32;
m = (x >> 5) % 16;
y = x >> 9;

```

--------------------------------

### Define an enumeration with default values

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines an enumeration 'fruit' with four constants that default to 0, 1, 2, and 3.

```c
enum fruit {grape, cherry, lemon, kiwi};

```

--------------------------------

### Initialize array of unions with inner braces

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes the first members of the elements of a number array. The additional inner grouping braces are optional.

```c
union numbers number_array [3] = { {3}, {4}, {5} };
```

--------------------------------

### Attempt to assign new string literal to array (fails)

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Illustrates that after initialization, you cannot assign a new string literal to an array using the assignment operator. The assignment 'lemon = "steak sauce";' will not work.

```c
char lemon[26] = "custard";
lemon = "steak sauce";      /* Fails! */
```

--------------------------------

### Variadic function definition using va_start, va_arg, va_end

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Defines add_multiple_values to sum a variable number of integers. Requires #include <stdarg.h>. The first parameter 'number' is the count of optional arguments. va_end is optional with GCC but recommended for portability.

```c
int
add_multiple_values (int number, ...)
{
  int counter, total = 0;
  
  /* Declare a variable of type ‘va_list’. */
  va_list parameters;

  /* Call the ‘va_start’ function. */
  va_start (parameters, number);

  for (counter = 0; counter < number; counter++)
    {
      /* Get the values of the optional parameters. */
      total += va_arg (parameters, int);
    }

  /* End use of the ‘parameters’ variable. */
  va_end (parameters);

  return total;
}

```

--------------------------------

### Equivalent array parameter as pointer

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the equivalent declaration using a pointer, emphasizing that arrays decay to pointers.

```c
void foo (int *a);
…
int x[100];
foo (x);

```

--------------------------------

### Initialize first union member with brace initializer

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes the first member 'i' of a union variable to 5 using a brace initializer. The 'f' member is left alone.

```c
union numbers
  {
    int i;
    float f;
  };
union numbers first_number = { 5 };

```

--------------------------------

### Pointer to a structure type

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Creates a structure type fish, a variable salmon, and a pointer fish_ptr to that structure, initialized with the address of salmon.

```c
struct fish
  {
    float length, weight;
  };
struct fish salmon = {4.3, 5.8};
struct fish *fish_ptr = &salmon;

```

--------------------------------

### General form of typedef statement

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax for creating a new type name with typedef. old-type-name can be multiple tokens, new-type-name must be a single identifier.

```c
typedef old-type-name new-type-name

```

--------------------------------

### Initialize structure members at definition

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Initializes structure members when declaring the variable during the structure definition, placing the initializer after the variable name.

```c
struct point
  {
    int x, y;
  } first_point = { 5, 10 };

```

--------------------------------

### sizeof operator with types and expressions

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Illustrates using sizeof with type names (in parentheses) and expressions. The result is of type size_t.

```c
size_t a = sizeof(int);
size_t b = sizeof(float);
size_t c = sizeof(5);
size_t d = sizeof(5.143);
size_t e = sizeof a;

```

--------------------------------

### General form of function declaration

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Shows the syntax for a function declaration, ending with a semicolon. return-type can be void for no return value.

```c
return-type function-name (parameter-list);

```

--------------------------------

### Using complex numbers with complex.h (carg, cabs)

Source: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

Includes complex.h and stdio.h, declares a complex double variable z, and prints its phase and modulus using carg and cabs functions. Requires C99 or later.

```c
#include <complex.h>    
#include <stdio.h>  

void example (void) 
{    
  complex double z = 1.0 + 3.0*I; 
  printf ("Phase is %f, modulus is %f\n", carg (z), cabs (z));        
}  

```
Tokens:
Raw