GNU C Language Manual

https://www.gnu.org/software/c-intro-and-ref/manual/c-intro-and-ref.html
Admin
This manual explains the GNU C language, a dialect of C used with the GNU Compiler Collection (GCC)...
Tokens:160,406
Snippets:1,394
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Pointer equality comparison example

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

Trivial example showing pointer equality and inequality tests with printf output.

```c
{
  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");
}

```

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

### Standard for loop with start expression

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

The conventional way to write a for loop with the start expression inside the parentheses. This is the alternative to the previous example.

```c
int i;
for (i = 0; i < n; ++i)

```

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

### Accessing command-line parameters with argc and argv

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

Example of accessing command-line parameters. argv[0] is the program name, and argc is the number of strings in argv. The example checks for --version and --help options.

```c
#include <string.h> /* Declare strcmp. */

int
main (int argc, char *argv[])
{
  char *program_name = argv[0];

  for (int i = 1; i < argc; i++)
    {
      if (!strcmp (argv[i], "--version"))
        {
          /* Print version information and exit. */
          …
        }
      else if (!strcmp (argv[i], "--help"))
        {
          /* Print help information and exit. */
          …
        }
    }
  …
}

```

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

### Line continuation example with backslash-newline

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

Shows how backslash-newline sequences can split tokens and comments across lines. The example is equivalent to '/* */ foo += 10;' and is provided as an illustration of what not to do in real programs.

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

```

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

### Omitted start expression in for loop

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

Instead of using the start expression, the loop preparation can be done before the for statement. This example initializes i before the loop and omits the start expression.

```c
int i = 0;
for (; i < n; ++i)

```

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

### Equivalent mixed initializer without designators

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

Shows the equivalent initialization for the mixed designated and non-designated example.

```c
int foo[10] = { 0, 0, 0, 42, 43, 44, 0, 58, 0, 0 };

```

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

### sizeof (type) example with double

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

Shows using sizeof with a type in parentheses. This example is equivalent to the previous expression example.

```c
i = sizeof (double) + 10;

```

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

### Bitwise AND example with &

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

Demonstrates the bitwise AND operator: each bit in the result is 1 only if both corresponding bits are 1.

```c
0b10101010 & 0b11001100 ⇒ 0b10001000
```

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

### Bitwise OR example with |

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

Demonstrates the bitwise OR operator: each bit in the result is 1 if either corresponding bit is 1.

```c
0b10101010 | 0b11001100 ⇒ 0b11101110
```

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

### GCC dependency pragma examples

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

Examples of the GCC dependency pragma in both line and token forms. The line form declares a file dependency and warns if the file is newer; the token form uses _Pragma with escaped quotes and a backslash continuation.

```c
#pragma GCC dependency "parse.y"
_pragma ("GCC dependency \"/usr/include/time.h\" \
rerun fixincludes")

```

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

### GCC push_options/pop_options stack example

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

Saves and restores target and optimize settings around a function definition to enable forward-propagate temporarily.

```c
_Pragma ("GCC push_options")
_Pragma ("GCC optimize forward-propagate")

/* Functions to compile
   with the forward-propagate optimization. */

_Pragma ("GCC pop_options")
/* Ends enablement of forward-propagate. */

```

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

### GCC optimize pragma example

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

Applies the forward-propagate optimization to all following function definitions.

```c
_Pragma ("GCC optimize -fforward-propagate")

```

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

### Preincrement example: ++i

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

Complete C program demonstrating preincrement. It prints lines containing '5', '6', and '6' again.

```c
#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;
}

```

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

### Bitwise negation examples with ~

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

Shows the effect of the unary bitwise negation operator ~ on various integer values, including the identity ~x = -x - 1. The last example demonstrates ~(-1) equals 0.

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

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

### Postincrement example: i++

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

Complete C program demonstrating postincrement. It prints lines containing '5', '5', and '6'.

```c
#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;
}

```

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

### GCC target pragma example

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

Activates the popcnt optimization for all following function definitions, supported on some targets.

```c
_Pragma ("GCC target popcnt")

```

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

### Clearer alternative using separate statements

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

Another clearer alternative to the discouraged example, using two separate statements.

```c
y += 4;
x = 8;
```

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

### Pointer-type designators for example declarations

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

Shows the type designators for the pointer types declared in the previous section.

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

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

### GCC diagnostic error pragma example

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

Treats diagnostics enabled by -Wformat as errors for code following the pragma.

```c
_Pragma ("GCC diagnostic error -Wformat")

```

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

### Void function example

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

Shows a function with void return type. Return statements in such functions should not specify a value.

```c
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);
}

```

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

### Example local variable declaration

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

Declares the local variable 'i' as an integer. This is a concrete instance of the basic declaration syntax.

```c
int i;

```

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

### Predecrement example: --i

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

Complete C program demonstrating predecrement. It prints three lines containing '5', '4', and '4' respectively.

```c
#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;
}

```

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

### Fetching environment variables with getenv

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

Example of using getenv from stdlib.h to fetch the user's home directory. This method does not require defining main with the envp parameter.

```c
#include <stdlib.h>  /* Declares getenv. */
#include <stdio.h>   /* Declares printf. */

int
main (void)
{
  char *home_directory = getenv ("HOME");
  if (home_directory)
    printf ("My home directory is: %s\n", home_directory);
  else
    printf ("My home directory is not defined!\n");
}

```

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

### Example of offsetof with struct foo

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

Declares a struct foo and uses offsetof to get the offset of the next field. The comment notes that on most machines it is 4, but may be 8.

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

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

```

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

### sizeof expression example with double variable

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

Shows using sizeof with an expression to get the size of a double variable. The result is 18 on most computers because a occupies 8 bytes and 10 is added.

```c
double a;

i = sizeof a + 10;

```

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

### sizeof with cast ambiguity example

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

Demonstrates the parsing ambiguity when applying sizeof to a cast expression. The first line parses as (sizeof (int)) - x, not sizeof ((int) -x). To get the intended result, parentheses must be written as shown.

```c
sizeof (int) -x

```

```c
(sizeof (int)) - x

```

```c
sizeof ((int) -x)

```

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

### Declaration visibility example: valid forward reference

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

Shows that a declared identifier is visible to code after its declaration, so this example works.

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

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

### GCC diagnostic push/pop stack example

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

Demonstrates using push and pop to temporarily change severity of -Wformat diagnostics, with an excess pop that restores command-line settings.

```c
_Pragma ("GCC diagnostic error -Wformat")

/* -Wformat messages treated as errors.  */

_Pragma ("GCC diagnostic push")
_Pragma ("GCC diagnostic warning -Wformat")

/* -Wformat messages treated as warnings.  */

_Pragma ("GCC diagnostic push")
_Pragma ("GCC diagnostic ignored -Wformat")

/* -Wformat messages suppressed.  */

_Pragma ("GCC diagnostic pop")

/* -Wformat messages treated as warnings again.  */

_Pragma ("GCC diagnostic pop")

/* -Wformat messages treated as errors again.  */

/* This is an excess ‘pop’ that matches no ‘push’.  */
_Pragma ("GCC diagnostic pop")

/* -Wformat messages treated once again
   as specified by the GCC command-line options.  */

```

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

### Get label address with && operator

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

Use '&&' to get the address of a label in the current function. The value has type void * and is a constant.

```c
void *ptr;
…
ptr = &&foo;

```

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

### Declaration visibility example: invalid forward reference

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

Shows that a declared identifier is not visible to code before its declaration, so this example cannot refer to y before its declaration.

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

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

### for Statement Syntax

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

Template for the for loop, which uses three expressions: start, continue-test, and advance. The start expression is computed once, then the test is evaluated before each iteration.

```c
for (start; continue-test; advance)
  body

```

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

### main function calling conventions

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

Three conventional signatures for main: with no arguments, with argc and argv, and with an additional envp array. Using void as the parameter list indicates main does not use arguments. char **argv is equivalent to char *argv[].

```c
int main (void) {…}
int main (int argc, char *argv[]) {…}
int main (int argc, char *argv[], char *envp[]) {…}

```

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

### break Statement Example: Nested Loops

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

Example showing that break exits only the innermost loop. The for loop breaks when a null element is found, but the outer while loop continues.

```c
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;
    }
}

```

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

### Example of for Loop from Fibonacci Function

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

Example for loop from an iterative Fibonacci function. It initializes i to 1, continues while i < n, and increments i each iteration. The body computes the next Fibonacci number.

```c
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.  */
  }

```

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

### Boolean type initialization example

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

Shows how to initialize `bool` variables with 0, 1, and a nonzero value. Any nonzero value converts to 1. `bool` is defined in stdbool.h, not a keyword.

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

```

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

### break Statement Example: Loop Until Newline

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

Example showing how break exits a while loop when a newline character is encountered. The loop advances pointer p until it reaches a null character or newline.

```c
while (*p)
  {
    /* End loop if we have reached a newline.  */
    if (*p == '\n')
      break;
    p++
  }

```

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

### Right shift division examples

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

Shows that shifting right one bit is division by two, rounding towards negative infinity. These examples use unsigned integers and binary constants.

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

```

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

### Clean alternative to goto for error handling

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

A cleaner way to write the example that prints 'Negative' without using goto, using a logical OR condition.

```c
if (x < 0 || y < 0)
  {
    printf ("Negative\n");
    return;
  }

```

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

### Structure with char, char, int fields

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

Example structure with fields char a, char b, and int c. Assumes char has size/alignment 1 and int has size/alignment 4. Occupies 8 bytes with alignment 4; a at offset 0, b at offset 1, c at offset 4, with a 2-byte gap before c.

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

```

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

### Commenting out a block comment start with a line comment

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

Warns that using a line comment to comment out the start of a traditional comment can cause the block comment delimiter to be ignored, leading to unexpected code.

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

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

### Structure with char, int, char fields

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

Example structure with fields char a, int c, and char b. Assumes char has size/alignment 1 and int has size/alignment 4. Occupies 12 bytes with alignment 4; a at offset 0, c at offset 4, b at offset 8, with gaps of 3 bytes before c and 3 bytes at the end.

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

```

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

### Command table initialization

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

Initializes an array of command structures with literal name strings and function pointers. This is the manual approach that the macro example improves upon.

```c
struct command commands[] =
{
  { "quit", quit_command },
  { "help", help_command },
  /* … */
};

```

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

### Declare and initialize va_list with va_start

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

Declares a va_list variable and initializes it with va_start, pointing before the first additional argument.

```c
va_list ap;
va_start (ap, last_fixed_parameter);

```

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

### Combined Declarations with Initializers

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

Examples of combining multiple declarations with commas, including initializers. In the last two examples, a is an int, p is a pointer to int, and array is an array of 5 ints; the unspecified elements of array are initialized to zero.

```c
int a, b;
int a = 1, b = 2;
int a, *p, array[5];
int a = 0, *p = &a, array[5] = {1, 2};
```

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

### Equivalent array declaration with initializer

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

Declares an array with the same elements as the compound literal example.

```c
char *array[] = { "x", "y", "z" };
```

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

### Bitwise XOR example with ^

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

Demonstrates the bitwise XOR operator: each bit in the result is 1 if exactly one of the corresponding bits is 1.

```c
0b10101010 ^ 0b11001100 ⇒ 0b01100110
```

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

### Example output of macheps for arguments 0 to 10, Infinity, and NaN

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

This output shows the hexadecimal values returned by macheps for arguments from 0 to 10, as well as Infinity and NaN. Note the special handling for NaN and zero, and that Infinity terminates the loop at the first iteration.

```text
macheps (  0) = 0x1.0000000000000p-1074
macheps (  1) = 0x1.0000000000000p-52
macheps (  2) = 0x1.0000000000000p-51
macheps (  3) = 0x1.8000000000000p-52
macheps (  4) = 0x1.0000000000000p-50
macheps (  5) = 0x1.4000000000000p-51
macheps (  6) = 0x1.8000000000000p-51
macheps (  7) = 0x1.c000000000000p-51
macheps (  8) = 0x1.0000000000000p-49
macheps (  9) = 0x1.2000000000000p-50
macheps ( 10) = 0x1.4000000000000p-50
macheps (Inf) = infinity
macheps (NaN) = nan
```

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

### Chained assignment example

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

Illustrates right-associativity of assignment operators, where multiple variables are assigned the same value.

```c
x = y = z = 0;
```

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

### Define and call a function-like macro lang_init

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

Shows the definition of a function-like macro and its expansion when called with different whitespace placements. The macro expands to c_init() regardless of spaces between the macro name and parentheses in the call.

```c
#define lang_init()  c_init ()
lang_init ()
     → c_init ()
lang_init     ()
     → c_init ()
lang_init()
     → c_init ()

```

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

### Long identifier example

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

Declares a variable with a long identifier to illustrate that identifiers can be as long as you like.

```c
int anti_dis_establishment_arian_ism;
```

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

### Aliasing example with structs and pointers

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

This example shows a program where two different struct types (struct a and struct b) are used to access the same memory location. When compiled without optimization, it works as intended, but with optimization, the compiler may assume the pointers do not alias, leading to different behavior. The code is used to illustrate the type-based aliasing rules in C.

```c
#include <stdio.h>
struct a { int size; char *data; };
struct b { float size; char *data; };

void sub (struct a *p, struct b *q)
{
  int x;
  p->size = 0;
  q->size = 1;
  x = p->size;
  printf("x       =%d\n", x);
  printf("p->size =%d\n", (int)p->size);
  printf("q->size =%d\n", (int)q->size);
}

int main(void)
{
  struct a foo;
  struct a *p = &foo;
  struct b *q = (struct b *) &foo;

  sub (p, q);
}

```

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

### Jumping into a block with goto

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

Shows that jumping into a block with goto works, even though it looks strange. The label negative is inside a block.

```c
if (x < 0)
  goto negative;
if (y < 0)
  {
   negative:
    printf ("Negative\n");
    return;
  }

```

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

### Recommended simple string constant

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

Shows the recommended way to write the string constant "Foo!" without backslash-newline.

```c
"Foo!"

```

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

### Header file header.h

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

A simple header file declaring a function prototype. This is used in the #include example.

```c
char *test (void);

```

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

### Function parameter shadowing example

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

Demonstrates that a function parameter's scope is the entire function body, but it can be shadowed by a file-scope variable with the same name.

```c
int x = 42;

void
foo (int x)
{
  printf ("%d\n", x);
}
```

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

### Shadowing in subblock example

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

Shows that a declaration with block scope can be shadowed by another declaration with the same name in a subblock.

```c
void
foo (void)
{
  char *x = "foo";
  {
    int x = 42;
    …
    exit (x / 6);
  }
}
```

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

### Expansion of SKIP_SPACES with do-while

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

Shows the expansion of SKIP_SPACES (p, lim); using the do-while version, which is a single statement.

```c
do { /* … */ } while (0);

```

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

### Calling add_multiple_values

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

Example call to the variadic function add_multiple_values with three additional arguments, summing to 236.

```c
sum = add_multiple_values (3, 12, 34, 190);
/* Value is 12+34+190. */

```
Tokens:
Raw