C syntax

Program Structure

Main Function

c
#include <stdio.h>

int main(void) {
    [printf](/page/Printf)("Hello, World!\n");
    [return 0](/page/Return_0);  // Success
}
#include <stdio.h>

int main(void) {
    [printf](/page/Printf)("Hello, World!\n");
    [return 0](/page/Return_0);  // Success
}

Command-Line Arguments

Lexical Elements

Identifiers

myVariable
_count
π_factor  /* Valid in C23 with universal character name */
myVariable
_count
π_factor  /* Valid in C23 with universal character name */

Keywords

Comments

c
/* This is a block [comment](/page/Comment) spanning
   multiple lines. It explains the purpose
   of the following [function](/page/Function). */
int main(void) {
    return 0;
}
/* This is a block [comment](/page/Comment) spanning
   multiple lines. It explains the purpose
   of the following [function](/page/Function). */
int main(void) {
    return 0;
}

c
// This is a line comment
int x = 5;  // Inline comment after statement
// This is a line comment
int x = 5;  // Inline comment after statement

Preprocessor Directives

Constants and Literals

Integer Constants

Floating-Point Constants

double pi = 3.14159;      // type [double](/page/Double)
float radius = 5.0f;      // type [float](/page/Float)
long double angle = 90.0L; // type [long double](/page/Long_double)
double pi = 3.14159;      // type [double](/page/Double)
float radius = 5.0f;      // type [float](/page/Float)
long double angle = 90.0L; // type [long double](/page/Long_double)

Character Constants

String Literals

Type System

Primitive Types

Derived Types

c
[int](/page/INT) *p;  /* p is a pointer to [int](/page/INT) */
[int](/page/INT) *p;  /* p is a pointer to [int](/page/INT) */

c
int a[10];  /* a is an array of 10 ints */
int a[10];  /* a is an array of 10 ints */

c
int f(int x);  /* f is a function returning int, taking int parameter */
int (*pf)(int x);  /* pf is a pointer to a function returning int, taking int parameter */
int f(int x);  /* f is a function returning int, taking int parameter */
int (*pf)(int x);  /* pf is a pointer to a function returning int, taking int parameter */

c
struct point {
    int x;
    int y;
};  /* structure with two int members */

union data {
    int i;
    float f;
};  /* union with int or float member */
struct point {
    int x;
    int y;
};  /* structure with two int members */

union data {
    int i;
    float f;
};  /* union with int or float member */

c
enum color {
    RED,
    GREEN = 2,
    BLUE
};  /* [enumerated type](/page/Enumerated_type) with values 0, 2, 3 */
enum color {
    RED,
    GREEN = 2,
    BLUE
};  /* [enumerated type](/page/Enumerated_type) with values 0, 2, 3 */

c
_Atomic [int](/page/INT) counter;  /* atomic integer type */
_Atomic [int](/page/INT) counter;  /* atomic integer type */

Type Qualifiers

c
const int x = 10;  // x cannot be modified after initialization
const int *p;      // Pointer to a const int; *p cannot be modified
const int x = 10;  // x cannot be modified after initialization
const int *p;      // Pointer to a const int; *p cannot be modified

c
volatile int status;  // Status register that may change externally
volatile int status;  // Status register that may change externally

c
void copy(int *restrict dest, const int *restrict src, size_t n);
void copy(int *restrict dest, const int *restrict src, size_t n);

c
_Atomic int counter;  // Atomic integer for thread-safe updates
_Atomic int counter;  // Atomic integer for thread-safe updates

Storage Classes

void function() {
    auto int counter = 0;  // Automatic storage, reinitialized on each call
    counter++;
}
void function() {
    auto int counter = 0;  // Automatic storage, reinitialized on each call
    counter++;
}

void function() {
    static int counter = 0;  // Retains value across calls
    counter++;
}
void function() {
    static int counter = 0;  // Retains value across calls
    counter++;
}

// file1.c
extern int global_var;  // Declaration with external linkage

// file2.c
int global_var = 10;  // Definition
// file1.c
extern int global_var;  // Declaration with external linkage

// file2.c
int global_var = 10;  // Definition

typedef unsigned int uint;  // uint is now an alias for unsigned int
typedef unsigned int uint;  // uint is now an alias for unsigned int

Declarations

Variable Declarations

Type Declarations

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

c
enum color {
    red,
    green = 5,
    blue
};
enum color {
    red,
    green = 5,
    blue
};

Function Declarations

Expressions and Operators

Operator Precedence and Associativity

Arithmetic Operators

c
int quotient = 5 / 2;  // quotient == 2
double fp_quotient = 5.0 / 2.0;  // fp_quotient == 2.5
int quotient = 5 / 2;  // quotient == 2
double fp_quotient = 5.0 / 2.0;  // fp_quotient == 2.5

c
int remainder = -5 % 3;  // remainder == -2 (C99+)
int remainder = -5 % 3;  // remainder == -2 (C99+)

Relational and Logical Operators

c
int a = 10, b = 5;
if (a == b) { /* false, does not execute */ }
if (a > b) { /* true, executes */ }
int a = 10, b = 5;
if (a == b) { /* false, does not execute */ }
if (a > b) { /* true, executes */ }

c
int x = 0;
if (x != 0 && (y = 5) > 0) { /* second operand skipped, y unchanged */ }
if (x != 0 || (z = 10) < 0) { /* second operand evaluated only if needed */ }
int x = 0;
if (x != 0 && (y = 5) > 0) { /* second operand skipped, y unchanged */ }
if (x != 0 || (z = 10) < 0) { /* second operand evaluated only if needed */ }

Bitwise Operators

Assignment Operators

c
int x = 10;
x += 5;  // Equivalent to x = x + 5; now x is 15
int x = 10;
x += 5;  // Equivalent to x = x + 5; now x is 15

c
int a = 1;
a = a + 1;  // Safe: old value of a used in computation before update
int a = 1;
a = a + 1;  // Safe: old value of a used in computation before update

Other Operators

c
int x = 10;
int *p = &x;  // p holds the address of x
int x = 10;
int *p = &x;  // p holds the address of x

c
int x = 10;
int *p = &x;
int y = *p;  // y is 10, dereferencing p
int x = 10;
int *p = &x;
int y = *p;  // y is 10, dereferencing p

c
size_t s1 = sizeof(int);      // size of int type
int arr[5];
size_t s2 = sizeof arr;       // size of the array (typically 5 * sizeof(int))
size_t s1 = sizeof(int);      // size of int type
int arr[5];
size_t s2 = sizeof arr;       // size of the array (typically 5 * sizeof(int))

c
int a = 5, b = 3;
int max = (a > b) ? a : b;  // max is 5
int a = 5, b = 3;
int max = (a > b) ? a : b;  // max is 5

c
int a = 1, b = 2;
int result = (a += 1, b * 2);  // evaluates a += 1 (discards), then b * 2; result is 4
int a = 1, b = 2;
int result = (a += 1, b * 2);  // evaluates a += 1 (discards), then b * 2; result is 4

c
struct Point { int x, y; };
struct Point p = {1, 2};
int val = p.x;  // dot access

struct Point *ptr = &p;
int val2 = ptr->y;  // arrow access
struct Point { int x, y; };
struct Point p = {1, 2};
int val = p.x;  // dot access

struct Point *ptr = &p;
int val2 = ptr->y;  // arrow access

Statements

Expression Statements

Compound Statements

c
{
    int x = 1;  // Declaration
    [printf](/page/Printf)("%d\n", x);  // Statement
    x++;  // Another statement
}
{
    int x = 1;  // Declaration
    [printf](/page/Printf)("%d\n", x);  // Statement
    x++;  // Another statement
}

c
{
    int outer = 10;
    {
        int inner = outer + 1;  // Accesses outer
        [printf](/page/Printf)("%d\n", inner);  // Outputs 11
    }  // inner destroyed here
    // outer still accessible
}
{
    int outer = 10;
    {
        int inner = outer + 1;  // Accesses outer
        [printf](/page/Printf)("%d\n", inner);  // Outputs 11
    }  // inner destroyed here
    // outer still accessible
}

Selection Statements

c
if (x > 0) {
    printf("Positive\n");
} else {
    printf("Non-positive\n");
}
if (x > 0) {
    printf("Positive\n");
} else {
    printf("Non-positive\n");
}

c
switch (grade) {
case 'A':
case 'B':
    printf("Good\n");
    break;
case 'C':
    printf("Average\n");
    break;
default:
    printf("Below average\n");
}
switch (grade) {
case 'A':
case 'B':
    printf("Good\n");
    break;
case 'C':
    printf("Average\n");
    break;
default:
    printf("Below average\n");
}

Iteration Statements

c
int i;
for (i = 0; i < 5; ++i) {
    printf("%d\n", i);  // Outputs 0 to 4
}
int i;
for (i = 0; i < 5; ++i) {
    printf("%d\n", i);  // Outputs 0 to 4
}

Jump Statements

if (condition) {
    goto cleanup;
}
// some code
cleanup:
    free(resources);
}
if (condition) {
    goto cleanup;
}
// some code
cleanup:
    free(resources);
}

int compute(int x) {
    if (x < 0) {
        return -1;  // Early return with value
    }
    // computations
    return result;
}
int compute(int x) {
    if (x < 0) {
        return -1;  // Early return with value
    }
    // computations
    return result;
}

Functions

Function Definition

Parameter Passing

Function Calls

c
#include <stdio.h>

void greet(int count) {
    printf("Hello, called %d times.\n", count);
}

int main() {
    int x = 5;
    greet(x++);  // Increments x after evaluation, but order with other args unspecified if multiple
    return 0;
}
#include <stdio.h>

void greet(int count) {
    printf("Hello, called %d times.\n", count);
}

int main() {
    int x = 5;
    greet(x++);  // Increments x after evaluation, but order with other args unspecified if multiple
    return 0;
}

Function Pointers

Advanced Features

Arrays

Pointers

Structures and Unions

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

c
union data {
    [int](/page/INT) i;
    [float](/page/Float) f;
};
union data {
    [int](/page/INT) i;
    [float](/page/Float) f;
};

c
struct flags {
    unsigned int valid:1;
    unsigned int error:3;
};
struct flags {
    unsigned int valid:1;
    unsigned int error:3;
};

c
struct container {
    int id;
    struct {
        char name[20];
    };  // Anonymous structure
};
struct container {
    int id;
    struct {
        char name[20];
    };  // Anonymous structure
};

Initialization

Attributes

Dynamic Memory Allocation

c
#include <stdlib.h>
int main() {
    int n = 10;
    int *arr = malloc(n * sizeof(int));
    if (arr == NULL) {
        // Handle allocation failure
        return 1;
    }
    // Use arr[0] to arr[n-1] as an array
    free(arr);
    return 0;
}
#include <stdlib.h>
int main() {
    int n = 10;
    int *arr = malloc(n * sizeof(int));
    if (arr == NULL) {
        // Handle allocation failure
        return 1;
    }
    // Use arr[0] to arr[n-1] as an array
    free(arr);
    return 0;
}