C (programming language)

The history of C is not the story of designing a single complete language from the beginning, but rather an evolutionary history formed by successively modifying BCPL, B (programming language), and NB within the operating-system research and constrained hardware environment of Bell Labs in the late 1960s. Dennis Ritchie, who designed C, recorded that C was created together with early UNIX between 1969 and 1973, with the most creative changes concentrated in 1972.^[1]

The types, pointers, arrays, structures, declaration syntax, and preprocessor now recognized as the core of C were not completed all at once according to a single design document. C developed incrementally by solving problems discovered while implementing actual operating systems, compilers, and file-processing tools. Its type system and portability were later strengthened while UNIX was ported to other computers, and through the publication of 《The C Programming Language》 and ANSI and ISO standardization, it evolved from the system implementation language of a particular research laboratory into an internationally standardized programming language.

BCPL and the Linguistic Lineage

The direct linguistic lineage of C begins with BCPL. BCPL was designed by Martin Richards for writing compilers and system software, and its initial reference manual was written in 1967. Work related to BCPL implementations and research was also conducted at Bell Labs around 1969.^[2]

BCPL was an untyped language that effectively used a single machine word as its basic unit of data. Memory was regarded as a continuous space of equally sized cells, and a single value could be interpreted as an integer, an address, or another kind of value depending on the operation. An array was also represented not as an independent high-level object, but as a combination of the location of its first memory cell and index calculation.

In BCPL and later B, array access conceptually had the following relationship.

V[i]
*(V + i)

This relationship continued into C, but in C, pointer arithmetic evolved so that the unit of movement is determined by the size of the data type to which the pointer points.

BCPL supported functions, global declarations, conditional and loop statements, indirect references corresponding to pointers, and separate compilation. C’s function-centered structure, many of its operators, and its control statements were inherited from BCPL and B, but C as a whole was not a direct copy of BCPL syntax. C’s data types, structures, declaration system, and preprocessor developed separately afterward.

Withdrawal from Multics and the Beginning of UNIX

In the late 1960s, Bell Labs participated in the Multics project, which was being developed jointly by MIT and General Electric. Multics was a large-scale operating system intended to provide time-sharing, multi-user operation, a hierarchical file system, dynamic linking, and a strong protection system.

However, as the project became increasingly complex and delayed, Bell Labs withdrew from Multics around 1969. Ken Thompson, Dennis Ritchie, and others began creating a smaller and more directly usable computing environment based on their experience with Multics.^[3]

Early UNIX was developed on the DEC PDP-7. At the time, no suitable high-level language or development environment was available for that computer, so the core of the operating system was written in assembly language. The researchers needed a system programming language that could be implemented even on a small computer and was easier to use than assembly language.

The major concepts of early UNIX included the following.

• Processes
• A hierarchical file system
• A command interpreter running in user space
• Simple text files
• A common interface for files and devices
• Small, composable command-line tools

C developed from the need to implement programs and the operating system itself in this UNIX environment.

Development of B

Ken Thompson developed B (programming language), a simplified form of BCPL, between 1969 and 1970. B retained BCPL’s general computational model and function-centered structure while being reduced enough for a compiler and programs to run in the very small PDP-7 environment.

B was also an untyped language centered on a single machine word. It did not strictly distinguish integers from addresses at the language level, and an array variable stored a value representing the beginning of a contiguous region of memory.

A B function was written in a form similar to the following.

max(a, b) {
    if (a > b)
        return a;
    return b;
}

This code is a simplified example intended to demonstrate the syntactic form of B. B already had several syntactic elements that later continued into C, including brace-delimited blocks, function calls, conditional statements, and return.

B introduced ++ and --, which later became characteristic C operators. A commonly repeated explanation states that these operators were created because of the PDP-11’s autoincrement addressing mode, but the PDP-11 was not yet in use when B was developed. Ritchie explained that the direct motivation was to express increment and decrement with compact syntax and to generate efficient code.^[4]

The order of compound assignment operators in early B and C was the reverse of their current form.

value =+ 1;
value =- 1;
value =* 2;

In modern C, these are written as follows.

value += 1;
value -= 1;
value *= 2;

Instead of directly generating native machine code, the PDP-7 B compiler generated threaded code consisting of lists of addresses of small code fragments and executed it through an interpreter. This reduced the size of the compiler, but execution was slow, and the approach was insufficient for rewriting all of UNIX in B within the limited memory of the PDP-7.

The PDP-11 and the Limitations of B

As the UNIX project demonstrated its potential, the Bell Labs researchers obtained a DEC PDP-11 in 1970. Early UNIX for the PDP-11 was also implemented in assembly language, but the new hardware clearly exposed the limitations of B’s single-word data type.

The PDP-11 used 16-bit words and byte-addressed memory. The word-centered structure of BCPL and B treated integers, addresses, and character data as a single word, but the PDP-11 required the following elements to be distinguished.

• 8-bit characters
• 16-bit integers
• Byte-addressed memory addresses
• Pointers and arrays
• Floating-point values

In B, manipulating characters required extracting and recombining particular bytes within a word. Pointers also required additional calculations to convert word indexes into actual byte addresses. Representing every value with a single word could not use the PDP-11 hardware naturally and efficiently.

Beginning in 1971, Dennis Ritchie added data types such as char and int to B and began writing a new compiler that generated PDP-11 machine code directly instead of threaded code.

From NB to C

The transitional language between B and C was called NB, or New B. No NB source code has been found, and its characteristics are inferred from Dennis Ritchie’s recollections and surviving compiler materials.^[5]

NB provided char and int, along with arrays and pointers for each type. Pointer arithmetic was adjusted according to the size of the pointed-to type.

char *characters;
int *numbers;

characters += 1;
numbers += 1;

Both operations add 1 to a pointer, but the actual address displacement differs according to the sizes of char and int.

NB arrays were still implemented in a manner similar to B. An array variable stored the address of separately allocated storage. This worked for simple arrays, but created problems when attempting to include an array within a structure.

For a structure to represent the actual layout of a file, device, or data in memory, the array elements had to be stored contiguously inside the structure itself. If each array contained a separate hidden pointer, the structure’s actual memory layout did not match the intended data.

While solving this problem, Ritchie created the key rule that established the relationship between arrays and pointers in C. An array became an actual object containing contiguous elements, while an array name was converted in most expressions into a pointer value referring to its first element.

int values[4];

int *first = values;
int *same = &values[0];

This rule made it possible to include arrays directly within structures while preserving much of the array-access behavior of existing B code.

Formation of Early C

Once the type system and new compiler had taken a stable form, Ritchie abandoned the name NB and began calling the language C. Ritchie did not settle on a single explanation of whether the name C was chosen simply because it followed B in the alphabet or because it represented the next stage after BCPL.

The years 1972 and 1973 were the critical period in the transition from untyped B to typed C. The last1120c and prestruct-c materials preserved by Dennis Ritchie are early C compiler sources written during this period. Their exact dates are difficult to determine because of timestamp information on the original tapes and subsequent copying, but it is clear that both compilers date from between 1972 and 1973.^[6]

The last1120c compiler, which retains a 1972 copyright notice, contains function definitions of the following form.

main(argc, argv)
int argv[];
{
    /* ... */
}

This code is a short excerpt preserving the actual form used at the time. Unlike modern C, main has no return type, the parameter names are listed first, and their types are declared separately on the following line. argv is also declared as int argv[] rather than the modern char **argv.^[7]

The same compiler actually used the compound assignment operators of the period.

i =+ *sp++;
i =% hshsiz;
i =* pssiz;

Early compilers did not support the general compound declaration syntax common today. Pointers were declared using an array-like notation.

int pointer[];

A declaration system capable of combining pointer, array, and function types was developed later.

int *pointer;
int **pointer_to_pointer;
int (*callback)(int);

last1120c had no structures, and the string struct does not appear in its source. The later prestruct-c began to support structures and used the . and -> operators. However, early structure declarations used parentheses rather than braces, unlike modern C.^[8]

There was no C preprocessor at the time. Token categories, operator properties, and similar values were written directly throughout the compiler source as numeric constants rather than named macros.

The early compiler used two passes distributed across several files. The first pass parsed the source and created a syntax tree, while the second pass read the tree and generated PDP-11 assembly code. Compared with modern compilers, it was extremely small and primitive, but it demonstrated an early form of a self-hosting system in which a compiler written in C translated C programs.

Development of Operators and the Declaration System

In early B and C, & and | were used both for bitwise operations and for logical operations in conditional expressions. && and || were added to distinguish logical operations from bitwise operations.

if (pointer != 0 && *pointer != 0) {
    process(*pointer);
}

&& provides short-circuit evaluation by not evaluating the right-hand condition when the left-hand condition is false, while || does not evaluate the right-hand condition when the left-hand condition is true.

C declaration syntax developed to reflect the way a declared name appears when used in an expression.

int value;
int *pointer;
int values[10];
int function(int value);
int (*callback)(int value);

The declarations can be read so that *pointer denotes an int value, values[index] denotes an int value, and the result of function(value) is an int.

The declaration system for combining arrays, pointers, and functions across multiple levels did not exist in the earliest compilers, but had developed into a form close to the modern system by around 1975.

Emergence of the C Preprocessor

The C preprocessor began to be introduced between 1972 and 1973. The early preprocessor provided file inclusion and simple parameterless macro substitution.

#include "header.h"

#define BUFFER_SIZE 512

Function-like macros and conditional compilation were added later.

#define MAX(left, right) \
    ((left) > (right) ? (left) : (right))

#ifdef PDP11
/* PDP-11-specific code */
#endif

The preprocessor was implemented as a separate translation stage that transformed tokens before ordinary C parsing. Because of this history, preprocessing directives have syntax and processing rules distinct from ordinary C statements.

The Early hello, world

Brian Kernighan’s early C tutorial, 《Programming in C — A Tutorial》, written at Bell Labs, included the following program.

main() {
    printf("hello, world");
}

This is an early form of the now widely used Hello, world! example. It has no return type for main, no declaration for printf, no header file, and no explicit return statement.^[9]

Written in modern C using K&R brace style, the same program takes the following form.

#include <stdio.h>

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

Early C could implicitly assume that an undeclared function returned an integer. Therefore, code that called printf without first including a function declaration was permitted. Such implicit function declarations caused type mismatch and portability problems and were later removed in C99.

Rewriting UNIX in C

By early 1973, most of the core elements of modern C were in place. The size and performance of the code generated by the compiler had also reached a level at which system programs written in assembly language could be replaced.

Ken Thompson attempted to port the UNIX kernel to early C in 1972, before structures were complete, but abandoned the work because the language was not yet mature enough. After structures and the type system developed further, the UNIX kernel was rewritten in C during the summer of 1973.^[10]

Kernel source from around UNIX Fourth Edition contains forms such as the following.

proc[0].p_stat = SRUN;
proc[0].p_flag =| SLOAD|SSYS;
u.u_procp = &proc[0];

Structure member access, arrays, and address operations are similar to modern C, but compound assignment was still written as =| rather than |=.

Kernel functions of the period used old-style function definitions such as the following.

main()
{
    register i1, *p;

    /* ... */
}

Because this is historical source code, its original form is preserved. The return type and the type of i1 are omitted, and omitted types could be treated as int.

Device drivers of the period represented device memory addresses and control bits as integer constants.

#define LPADDR 0177514
#define IENABLE 0100

Through arrays, pointers, structures, and bitwise operations, C could represent operating-system process tables, file systems, and device registers. At the same time, because it was less dependent on specific hardware than assembly language, it provided a foundation for moving UNIX to other computers.

C and UNIX were not the first example of implementing an operating system in a high-level language, but UNIX written in C demonstrated that a small language could provide native performance, hardware control, and portability together.

Early C Reference Manuals

Around 1974 and 1975, reference manuals and tutorials describing the C implementation were organized. Dennis Ritchie’s 《C Reference Manual》 described the lexical elements, types, expressions, declarations, and program structure of C for the PDP-11.

At the time, C had the following basic types.

char character;
int integer;
float single_precision;
double double_precision;

Arrays, pointers, functions, and structures could be constructed from the basic types.

int values[10];
int *pointer;
int function();
struct point {
    int x;
    int y;
};

Function definitions used a form in which parameter names and types were separated.

int add(a, b)
int a, b;
{
    return a + b;
}

This form later became known as an old-style function definition or K&R function definition syntax. It is a separate concept from the K&R placement of braces as a code style.

Using modern function declaration syntax and K&R code style, the same function is written as follows.

int add(int a, int b) {
    return a + b;
}

The relationship between arrays and pointers also became established as an important language rule in manuals of the period.

array[index]
*(array + index)

Function arguments were passed by value, and a pointer had to be passed to modify an object belonging to the caller.

void swap(int *left, int *right) {
    int temporary = *left;

    *left = *right;
    *right = temporary;
}

Portability and the Portable C Compiler

The portability of C and UNIX was not a fully developed primary objective from the moment the language was created. Early work focused on building a small system that the researchers could actually use, and the advantage of portability became increasingly important through later practical porting efforts.

Stephen C. Johnson developed the Portable C Compiler so that it could be adapted relatively easily to new processors. Johnson, Thompson, and Ritchie ported UNIX to the Interdata 8/32, and it was subsequently expanded to architectures including the VAX.^[11]

The Interdata port demonstrated that C code and UNIX were not completely tied to the PDP-11. However, the process also exposed problems caused by remnants of the earlier untyped languages that remained in early C.

Early programs could use loose conversions between integers and pointers.

int address;

address = pointer;
pointer = address;

Such code did not operate correctly on systems where integers and pointers had different sizes. C subsequently developed toward a clearer distinction between pointer types and the explicit expression of required conversions.

Modern C can use appropriate integer types provided by the platform.

#include <stdint.h>

uintptr_t address = (uintptr_t)pointer;
pointer = (void *)address;

The unsigned type and explicit type casts were added, while type rules for structure pointers and function calls were also strengthened.

Development of lint

Early C compilers could not sufficiently check function calls and type mismatches across multiple translation units. Stephen C. Johnson developed lint to supplement these limitations.

Early function declarations did not include parameter types.

int calculate();

In this state, it was difficult to determine solely from the call site whether the following call matched the actual function definition.

double result = calculate(1.5);

lint analyzed multiple source files and diagnosed function argument and return-type mismatches, suspicious integer-to-pointer conversions, unused values, and similar issues. These problems became an important background for the introduction of function prototypes in ANSI C.

The Standard Input and Output Library

A portable input and output package written by Mike Lesk around 1973 became the foundation of the later C standard input and output library. Early UNIX programs directly used low-level operating-system file descriptors and system calls, but the portable input and output package provided a higher-level interface for handling characters and files in a similar way across different systems.

Modern C standard input and output is used in forms such as the following.

#include <stdio.h>

int copy_stream(FILE *input, FILE *output) {
    int character;

    while ((character = fgetc(input)) != EOF) {
        if (fputc(character, output) == EOF) {
            return -1;
        }
    }

    return ferror(input) ? -1 : 0;
}

The separation of the language itself from its libraries provided the basis for maintaining a small language core while offering common functionality such as input and output, strings, and memory allocation in a portable form.

K&R C

In 1978, Brian Kernighan and Dennis Ritchie published 《The C Programming Language》. The book became known as K&R, after the surnames of its authors, and was also called the white book because of its white cover.

K&R was not the first C document, but it presented the core of the language and library in a concise and consistent form to a wide audience. Until an official standard was produced, it served for approximately ten years as the de facto definition of the C language.^[12]

A typical program from the period of the first edition of K&R had the following form.

#include <stdio.h>

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

Because this code demonstrates historical syntax, its original form is preserved. The return type of main is omitted, and an empty parameter list did not explicitly declare that the function accepted no arguments, but instead meant that no parameter information had been specified.

A function with parameters used the following old-style definition syntax.

int maximum(a, b)
int a, b;
{
    return a > b ? a : b;
}

A function declaration could be written as follows, but did not include parameter types.

int maximum();

C continued to change after the first edition of K&R. Between the late 1970s and early 1980s, the following features spread through the language and its implementations.

• unsigned
• long
• union
• enum
• void
• Structure assignment
• Passing and returning structures
• Stricter pointer type checking
• Compound assignment operators in their current form

Modern compound assignment operators have the following form.

value += offset;
flags |= ENABLED;
count *= 2;

The older =+, =|, and =* forms disappeared.

Expansion into Personal Computing and Industry

During the 1980s, C compilers became available for major computer architectures and operating systems. Many early compilers used the design and code of the Portable C Compiler, but independent commercial compilers and development environments gradually appeared.

C spread beyond UNIX workstations into the following environments.

• Personal computers
• MS-DOS applications
• Commercial operating systems
• Embedded controllers
• Networking equipment
• Databases
• Graphics software
• Games and system utilities

Implementing a C compiler for a new computer made it possible to port operating systems, development tools, libraries, and applications together. C was also used as a portable low-level target language for representing the compilation output of other languages.

During this period, C++ and Objective-C appeared as direct extensions of C. Java, C#, JavaScript, and later languages were also strongly influenced by C’s brace-delimited blocks, expressions, operators, and control-statement syntax.

The Need for Standardization

As C spread across companies, hardware platforms, and operating systems, incompatible dialects also increased. The first edition of K&R was widely used, but it was not an official standard that completely specified every detail of the language.

Compiler developers could handle the following elements differently.

• Sizes and conversions of integer types
• Passing and returning structures
• Function declaration and call checking
• Preprocessor behavior
• The standard library
• Pointer conversions
• Extension keywords
• Platform-specific calling conventions

Problems increased in which the same C source code was interpreted differently by different compilers or a program written in one environment could not be compiled in another. Commercial contracts and government procurement also required a formal specification for judging the conformance of C implementations.

ANSI formed the X3J11 technical committee in 1983 to begin developing a United States national standard for C. The committee’s objective was not to create an entirely new language, but to define the common practices of already widely used C clearly and consistently.^[13]

The following principles were important during the standardization process.

• Preserve the value of existing C programs.
• Improve program portability.
• Do not adopt one particular compiler as the standard.
• Retain the ability to write hardware-specific system code.
• Do not obstruct efficient implementation.
• Prioritize features with practical implementation experience.

ANSI C and C89

X3J11 published ANSI X3.159-1989 in 1989. This edition is called C89 or ANSI C. ISO adopted it in 1990 as ISO/IEC 9899:1990, and it is also called C90 according to the publication year of the international standard.^[14]

One of the important changes in C89 was the function prototype. A K&R-style function declaration did not indicate the number or types of parameters.

int calculate();

ANSI C made it possible to include parameter types in a declaration.

int calculate(int left, int right);

Function definitions could also use modern syntax with K&R brace style.

int calculate(int left, int right) {
    return left + right;
}

The compiler could now check the number and types of arguments passed in a call.

int result = calculate(10, 20);

C89 standardized void, void *, const, and volatile.

#include <stddef.h>

static int sum(const int *values, size_t count);

int main(void) {
    int values[] = { 1, 2, 3 };

    return sum(values, 3) == 6 ? 0 : 1;
}

static int sum(const int *values, size_t count) {
    int result = 0;

    while (count != 0) {
        result += *values++;
        --count;
    }

    return result;
}

main(void) clearly indicates that the function accepts no parameters. const int * expresses a type constraint stating that the elements will not be modified through the pointer.

The general-purpose object pointer void * was also standardized.

void *memory;
int *numbers;

memory = numbers;
numbers = memory;

In C, conversions between void * and object pointers can be performed without an explicit cast. The same rule does not apply to function pointers.

C89 also specified preprocessor behavior in detail and standardized the stringification operator # and token-pasting operator ##.

#define STRINGIFY(value) #value
#define CONCAT(left, right) left ## right

int CONCAT(user_, id);

The standard library organized common interfaces for input and output, strings, memory allocation, mathematics, time, signal handling, and other functions.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>

For compatibility with existing code, old-style function definition syntax continued to be permitted. This syntax remained for a long period before being removed in C23.

The Second Edition of K&R

The second edition of 《The C Programming Language》, published in 1988, reflected the new form of C that emerged during ANSI standardization. It explained modern declaration forms including function prototypes, void, and const, and became widely used in C education and documentation.

A function following the syntax of the second edition takes the following form.

int maximum(int left, int right) {
    return left > right ? left : right;
}

This form, with the opening brace on the same line as the declaration, is K&R style.

C95

The 1990 international standard was amended in 1995 by ISO/IEC 9899:1990/Amd 1:1995. This edition is informally called C95. Rather than being an entirely new edition of the standard, it was an amendment applied to C90.^[15]

C95 added digraphs so that C punctuation tokens could be represented even with limited character sets.

int values<:3:> = <% 10, 20, 30 %>;

The code above has the following meaning.

int values[3] = { 10, 20, 30 };

<iso646.h> provided macros that represented certain operators as words.

#include <iso646.h>

int check(int enabled, int failed) {
    if (enabled and not failed) {
        return 1;
    }

    return 0;
}

Multibyte and wide-character processing was also extended, and <wchar.h> and <wctype.h> were added.

#include <wchar.h>
#include <wctype.h>

int main(void) {
    wchar_t character = L'A';

    return iswalpha(character) ? 0 : 1;
}

The __STDC_VERSION__ macro made it possible to determine the standard edition supported by an implementation.

#if defined(__STDC_VERSION__) && \
    __STDC_VERSION__ >= 199409L
/* C95 or later implementation */
#endif

C99

The second complete international standard edition, ISO/IEC 9899:1999, was published in December 1999 and is called C99. C99 incorporated a large set of compiler extensions, numerical-computing features, internationalization support, and modern programming practices that had developed since C89.^[16]

C99 allowed variables to be declared in the middle of a block and in the initialization clause of a for statement.

int sum_values(const int *values, int count) {
    int total = 0;

    for (int index = 0; index < count; ++index) {
        total += values[index];
    }

    return total;
}

In C89, declarations generally had to be grouped before executable statements in a block.

int sum_values(const int *values, int count) {
    int total;
    int index;

    total = 0;

    for (index = 0; index < count; ++index) {
        total += values[index];
    }

    return total;
}

Single-line // comments were also incorporated into the standard.

int count = 10; // Number of elements to process

Designated initializers made it possible to name structure members and array indexes explicitly.

struct point {
    int x;
    int y;
};

struct point position = {
    .y = 20,
    .x = 10
};

int values[8] = {
    [0] = 10,
    [7] = 80
};

Compound literals made it possible to express unnamed objects.

struct point *create_origin(void) {
    static struct point origin = {
        .x = 0,
        .y = 0
    };

    return &origin;
}

A compound literal could also be used directly as a function argument.

draw_point((struct point) {
    .x = 10,
    .y = 20
});

C99 introduced long long int and the integer types in <stdint.h>.

#include <stdint.h>

uint32_t flags = UINT32_C(0x80000000);
int64_t distance = INT64_C(9000000000);

Variable-length arrays, whose length is determined at runtime, were also added.

void clear_values(int count) {
    int values[count];

    for (int index = 0; index < count; ++index) {
        values[index] = 0;
    }
}

The restrict pointer qualifier provided the implementation with information about aliasing relationships among pointers used by a function.

#include <stddef.h>

void add_arrays(
    size_t count,
    float *restrict result,
    const float *restrict left,
    const float *restrict right
) {
    for (size_t index = 0; index < count; ++index) {
        result[index] = left[index] + right[index];
    }
}

The inline function specifier was also added.

inline int square(int value) {
    return value * value;
}

inline does not force actual inlining, and the implementation decides whether to perform the optimization.

Variadic macros were added as well.

#define LOG(format, ...) \
    fprintf(stderr, format, __VA_ARGS__)

C99 introduced _Bool and <stdbool.h>.

#include <stdbool.h>

static bool running = true;

void stop(void) {
    running = false;
}

Complex-number types and <complex.h> were also standardized.

#include <complex.h>

double complex multiply(
    double complex left,
    double complex right
) {
    return left * right;
}

A flexible array member, which allows variably sized data to be placed at the end of a structure, was also added.

#include <stddef.h>

struct packet {
    size_t size;
    unsigned char data[];
};

C99 removed implicit int and implicit function declarations. Code such as the following is no longer a valid modern C program.

main() {
    undeclared_function();
}

The return type and function declaration must be specified.

int declared_function(void);

int main(void) {
    return declared_function();
}

C99 also included the following features.

• __func__
• Hexadecimal floating-point constants
• <inttypes.h>
• <tgmath.h>
• <fenv.h>
• Universal character names
• Clarification of integer division rules
• Extended structure and union initialization

Three Technical Corrigenda for C99 were published in 2001, 2004, and 2007. WG14 N1256 is a publicly available working document incorporating these corrections.^[17]

C11

The third international standard edition, ISO/IEC 9899:2011, was published in 2011 and is called C11. C11 incorporated requirements relating to multicore execution, concurrency, memory alignment, Unicode, and static verification into the language and standard library.^[18]

The largest change was the standardization of multithreaded execution and the memory model. _Atomic and <stdatomic.h> made it possible to express atomic objects.

#include <stdatomic.h>

static _Atomic unsigned int job_count = 0;

void add_job(void) {
    atomic_fetch_add(&job_count, 1);
}

The standard specified the ordering of atomic operations, memory visibility between threads, and the meaning of data races.

<threads.h> included interfaces for threads, mutexes, condition variables, and thread-specific storage.

#include <threads.h>

int worker(void *context) {
    return context != 0;
}

int main(void) {
    thrd_t thread;
    int result;

    if (thrd_create(&thread, worker, 0) != thrd_success) {
        return 1;
    }

    thrd_join(thread, &result);
    return result;
}

_Static_assert made it possible to verify a condition at translation time.

#include <stdint.h>

_Static_assert(
    sizeof(uint32_t) == 4,
    "uint32_t must be four bytes"
);

_Generic made it possible to select different results according to the type of an expression.

#define TYPE_NAME(value) \
    _Generic((value), \
        int: "int", \
        double: "double", \
        default: "other")

const char *get_type_name(void) {
    return TYPE_NAME(10);
}

_Alignas and _Alignof were introduced to express memory alignment.

_Alignas(64) static unsigned char cache_line[64];

_Static_assert(
    _Alignof(cache_line) >= 64,
    "insufficient alignment"
);

Anonymous structures and anonymous union objects were also supported.

struct color {
    union {
        struct {
            unsigned char red;
            unsigned char green;
            unsigned char blue;
            unsigned char alpha;
        };

        unsigned int value;
    };
};

_Noreturn was added to represent functions that do not return.

#include <stdlib.h>

_Noreturn void fatal_error(void) {
    quick_exit(EXIT_FAILURE);
}

C11 also added the following features.

• <uchar.h>
• UTF-16 and UTF-32 character types
• aligned_alloc
• quick_exit
• Exclusive file-creation mode
• An optional bounds-checking interface
• Thread storage duration

Some features could be provided optionally by implementations. Support for variable-length arrays, threads, atomic operations, and parts of complex-number functionality could differ according to the implementation environment.

C17

After C11, work focused on correcting defects and ambiguities in the standard rather than adding large-scale language features. This resulted in the publication of ISO/IEC 9899:2018.

This edition is sometimes called C17 according to its working year and C18 according to its publication year. WG14 generally uses the name C17.^[19]

C17 did not add major new language syntax. It corrected and clarified the rules for atomic operations, alignment, threads, and library facilities introduced in C11.

Therefore, C11 code is used in the same form under C17.

#include <stdatomic.h>

static _Atomic int ready = 0;

int main(void) {
    atomic_store(&ready, 1);

    return atomic_load(&ready) == 1 ? 0 : 1;
}

A program can use __STDC_VERSION__ to check whether the implementation supports C17 or later.

#if !defined(__STDC_VERSION__) || \
    __STDC_VERSION__ < 201710L
#error "C17 or later is required"
#endif

Rather than introducing new syntax, C17 organized and stabilized C11 and established a basis for the next large-scale revision.

C23

WG14 developed the next major revision after C11 under the working name C2x. The final standard was completed as C23 and published by ISO and IEC in 2024 as ISO/IEC 9899:2024. The difference between the common name C23 and the official publication year 2024 results from the difference between the committee’s development cycle and the ISO publication process.^[20]

C23 included broader language changes than C11 and C17. Ordinary keyword forms were added for several names and macros that had previously begun with underscores.

bool enabled = true;

static_assert(sizeof(int) >= 2);

thread_local unsigned int worker_id;

Earlier standards used forms such as the following.

_Bool enabled = 1;

_Static_assert(
    sizeof(int) >= 2,
    "int is too small"
);

_Thread_local unsigned int worker_id;

C23 introduced typeof and typeof_unqual.

int value = 10;

typeof(value) another_value = 20;
typeof_unqual(value) copy = value;

constexpr objects were also introduced.

constexpr unsigned int buffer_size = 4096;

static_assert(buffer_size > 0);

Binary integer literals and apostrophe digit separators became available.

unsigned int mask = 0b1111'0000;
long population = 50'000'000;

Objects could be initialized to zero-equivalent values using an empty initializer list.

struct point {
    int x;
    int y;
};

struct point position = {};
int values[8] = {};

Standard attribute syntax was also added.

[[nodiscard]]
int parse_document(const char *source) {
    return source != nullptr;
}

[[deprecated]]
void legacy_function(void) {
}

C23 features can be combined in code such as the following.

[[nodiscard]]
int calculate_mask(void) {
    constexpr unsigned int mask = 0b1111'0000;
    bool enabled = true;
    typeof_unqual(mask) copy = mask;

    static_assert(mask == 240);

    return enabled ? (int)copy : 0;
}

The preprocessor gained #elifdef, #elifndef, #warning, and #embed.

#if defined(_WIN32)
#define PLATFORM_NAME "Windows"
#elifdef __linux__
#define PLATFORM_NAME "Linux"
#else
#warning "Unknown platform"
#endif

#embed allows external binary data to be included during translation.

static const unsigned char icon_data[] = {
#embed "icon.bin"
};

C23 also introduced nullptr and nullptr_t.

#include <stddef.h>

int *pointer = nullptr;
nullptr_t null_value = nullptr;

Old-style identifier-list function definitions were removed.

/* Old-style function definition removed in C23 */
int add(a, b)
int a, b;
{
    return a + b;
}

Modern declarations and K&R brace style must be used.

int add(int a, int b) {
    return a + b;
}

The meaning of a function declaration with empty parentheses also changed.

int function();

In earlier standards, this was a declaration with unspecified parameter information, but in C23 it is interpreted as a declaration of a function with no parameters.

C23 also added bit-precise integer types based on _BitInt.

_BitInt(24) signed_value = 0;
unsigned _BitInt(7) small_value = 100;

Object type inference using auto was also introduced.

auto integer = 42;
auto floating = 3.14;

C23 also included the following changes.

• Two’s-complement representation for signed integers
• Enumerations with fixed underlying types
• Improved UTF-8, UTF-16, and UTF-32 processing
• Rules for u8 characters and strings
• strdup and strndup
• memccpy
• gmtime_r and localtime_r
• Integration of floating-point extensions
• Declarations before labels and compound statements at the end of labels
• Removal of several obsolete syntactic forms

The publicly available WG14 working document N3220 organizes the syntax, semantics, library, and major changes from previous editions of ISO/IEC 9899:2024.^[21]

After C23

After the C23 revision cycle ended, WG14 began work on the next standard edition under the working name C2y. C2y is not the final name of the standard, but a working name for the next edition of C. N3220 records that work on the next edition began in January 2024 after the end of the C23 cycle.^[22]

The following areas are under discussion for the next revision.

• Pointer provenance
• The memory-object model
• Reduction and diagnosis of undefined behavior
• Type safety
• Expression of array sizes
• Function calls and variadic arguments
• Expansion of constexpr
• String and memory APIs
• Compatibility with earlier standard editions
• Interoperability with C++ and other languages

Because C2y remains under development, not every proposed feature can be assumed to appear in the final standard. The final contents will be determined through WG14 discussion and voting, followed by review by national standards bodies.

Changes in Code Form

The historical development of C can also be observed in how the same computation is expressed in code.

In early C during the 1970s, old-style function definitions and compound assignment operators were used.

main(argc, argv)
int argv[];
{
    value =+ 1;
}

A function from the K&R C period had the following form.

int add(a, b)
int a, b;
{
    return a + b;
}

ANSI C made it possible to place parameter types inside the function declaration.

int add(int a, int b) {
    return a + b;
}

C99 made it possible to use declarations inside loop statements and single-line comments.

int sum(int count) {
    int result = 0;

    for (int index = 0; index < count; ++index) {
        result += index;
    }

    return result;
}

C11 made it possible to express atomic operations and static verification.

#include <stdatomic.h>

static _Atomic int ready = 0;

int initialize(void) {
    _Static_assert(
        sizeof(int) >= 2,
        "invalid int"
    );

    atomic_store(&ready, 1);
    return 0;
}

C23 allows the use of new keywords, literals, and attributes.

[[nodiscard]]
int create_mask(void) {
    constexpr unsigned int mask = 0b1111'0000;
    bool ready = true;

    static_assert(mask == 240);

    return ready ? (int)mask : 0;
}

These changes do not represent a sequence of entirely different languages replacing one another. They are the result of gradually adding stronger type checking, portability, numerical-computing facilities, concurrency, internationalization, and modern syntax while preserving the functions, expressions, pointers, arrays, structures, and direct memory model of early C.

Historical Significance

C began as a small systems language for implementing early UNIX, but through standardization it became an international standard language belonging to no particular operating system or processor.

The pointer and array model inherited from early BCPL and B, the type system created under the constraints of the PDP-11, the stronger type checking and Portable C Compiler developed through UNIX porting, the dissemination of the language through K&R, and the conservative standardization principles of ANSI and ISO remain directly present in modern C.

C’s historical continuity is also one reason why older syntax and certain irregularities remain in the language. At the same time, it provides the foundation that allows code written decades ago to connect with modern compilers, operating systems, and hardware.

Dennis Ritchie characterized C as a language with defects and peculiarities, but one efficient enough to replace assembly language and sufficiently abstract to express algorithms and system interactions across diverse environments.^[23]

The history of C can be understood as a continuing process of balancing automated safety with direct control, abstraction with machine dependence, and new functionality with compatibility with existing code.

C is both a general-purpose high-level programming language and a system programming language capable of performing tasks close to hardware and operating systems. It provides control structures, functions, and compound data types for expressing general computation, data processing, and application programs, while also providing facilities for directly handling memory addresses, bit-level data, hardware registers, and external functions. WG14 describes C as a general-purpose high-level language suitable for low-level programming and identifies portability, interoperability, efficiency, and stability as prominent characteristics of the language.^[24]

The characteristics of C cannot be fully explained merely by describing it as a language “close to machine code.” C programs are written for an abstract machine defined by the standard, while actual instructions, register allocation, calling conventions, and executable file formats are determined by the implementation and platform. However, C integers, arrays, structures, pointers, and explicit memory-management model were designed to correspond relatively directly to the data representations of actual computers. For this reason, the same language can be used not only for operating system kernels, device drivers, and embedded firmware, but also for databases, graphics libraries, and general-purpose applications.

General-Purpose and System Programming Language

C does not target only one specific kind of program. It is classified as a general-purpose programming language because it can be used to write ordinary applications through functions, conditional statements, loops, structures, arrays, arithmetic operations, and the standard library.

At the same time, C can express the following system-level operations.

• Manipulating memory addresses through pointers
• Controlling the layout and alignment of memory regions
• Examining and modifying individual bits of integers
• Accessing memory corresponding to hardware registers
• Calling operating system system calls and native libraries
• Running on constrained devices without a separate runtime environment
• Using extensions designed for particular processors and operating systems

The classification of C as a system programming language does not mean that a C program must necessarily be an operating system or device driver. C is a general-purpose language, but it is suitable for system implementation because programmers can control data representation and execution costs beneath abstractions relatively directly.

The low-level facilities provided by C are not completely identical to actual machine instructions either. For example, a pointer is a language-level value that refers to an object or function in an implementation-defined manner, and it is not guaranteed to be equivalent to a simple integer physical address on every platform. The C standard defines the syntax and semantics of programs, but does not specify the concrete manner in which programs are translated and called on actual systems.^[25]

Imperative and Procedural Language

C is an imperative programming language in which the commands and state changes that a program must perform are described sequentially. It changes variable values, selects execution paths according to conditions, repeats commands through loops, and separates tasks through function calls.

int total = 0;

for (int i = 0; i < count; ++i) {
    total += values[i];
}

This code reads each element of an array in sequence and changes the state of total. Instead of declaring the same computation as a mathematical relationship, it explicitly expresses how values are read and modified.

C organizes programs around functions in accordance with procedural programming. A function receives input through parameters and may return a value or modify external state. Related functions and data types can be divided across multiple source files and headers to modularize a program.

Arguments to function calls are passed by value by default. When a called function must directly modify an object belonging to the caller, a pointer referring to that object is passed.

void increment(int *value)
{
    ++*value;
}

C has no separate pass-by-reference syntax comparable to reference parameters in C++. Array parameters are adjusted to pointer types in function declarations, so although an array may appear to be passed, what is actually passed is a pointer referring to its elements.

Structured Programming

C is a structured programming language that can organize control flow hierarchically through statements, blocks, functions, conditional statements, and loops.

Its major control structures include the following.

• if and else
• switch
• while
• do
• for
• Function calls and returns
• Compound statements enclosed in braces

These structures allow programs to be expressed as hierarchies of conditions, repetition, and functions rather than as simple sequences of instruction addresses and unconditional branches.

C also provides goto. Therefore, the language does not enforce structured programming exclusively. goto can make ordinary control flow unnecessarily complicated, but it is sometimes used to reduce duplication in limited situations such as multi-stage resource cleanup and error handling.

FILE *file = fopen(path, "rb");

if (file == NULL) {
    return ERROR_OPEN;
}

void *buffer = malloc(size);

if (buffer == NULL) {
    goto cleanup_file;
}

/* Perform operation */

free(buffer);
fclose(file);
return SUCCESS;

cleanup_file:
fclose(file);
return ERROR_MEMORY;

C provides tools for expressing program structure but does not impose a particular design methodology or object model. By combining functions, structures, pointers, and separate translation units, programmers can directly design procedural interfaces, object-oriented-like structures, data-oriented structures, and other models.

Small Language Core

C consists of a relatively small language core and a separate standard library. File input and output, string processing, dynamic memory allocation, mathematical functions, and time processing are provided mostly through standard library functions and macros rather than as language syntax.

C language
├── Types and declarations
├── Expressions and operators
├── Statements and control flow
├── Functions
├── Objects and storage duration
├── Pointers and arrays
├── Structures, unions, and enumerations
└── Preprocessing directives

C standard library
├── Input and output
├── Strings and memory
├── Dynamic memory allocation
├── Mathematics
├── Time
├── Character classification and conversion
├── Atomic operations
└── Threads and synchronization

Describing the language as small does not mean that the entire C standard is simple. Precise and complex rules exist for array-to-pointer conversion, integer promotion, object lifetimes, effective types and aliasing, evaluation order, and preprocessing. Rather, it means that the number of keywords and fundamental abstractions used by the syntax is relatively small and that the language does not embed a large number of high-level facilities directly into the language itself.

C does not include the following facilities as fundamental language elements.

• Classes and inheritance
• Exception handling
• Automatic garbage collection
• Built-in arrays with bounds checking
• A dedicated built-in string type
• General-purpose containers
• A package and module distribution system
• Reflection
• Coroutine and asynchronous syntax
• Language-level networking and graphics APIs

Required functionality is implemented through libraries, code-generation tools, platform APIs, or designs within the program itself. This structure can keep the language and execution environment small, but it can also lead different projects to use different implementations and conventions.

Static Type System

C is a statically typed programming language in which the types of variables, functions, and expressions are primarily determined at translation time. Declarations specify the data types of objects and the parameter and return types of functions, and the compiler can diagnose expressions that do not follow the type rules.

int count;
double average;
char *text;
int calculate(int lhs, int rhs);

C types can broadly be divided into the following categories.

• Integer types
• Floating-point types
• Enumerations
• Pointer types
• Array types
• Function types
• Structures
• union
• Atomic types
• void

Types determine value representation, permitted operations, object size and alignment, the unit of pointer arithmetic, and function-call rules. Structures, union, arrays, and pointers can be combined to represent data structures corresponding to hardware, file formats, and communication protocols.

However, C type checking is relatively flexible compared with modern strongly typed static languages. Automatic conversions and promotions occur between integer types, and explicit casts can express conversions among various pointer and integer types.

double value = 3.75;
int integer = (int)value;

Such conversions are necessary when dealing with hardware and external interfaces, but they may cause information loss and incorrect interpretation. A cast is not a guarantee that a type error has been resolved; it is syntax that explicitly requests a particular conversion from the compiler.

Value Representation and Implementation Dependence

C does not assume that all computers use the same integer sizes, byte order, or floating-point representation. It specifies relative minimum ranges and ordering for types such as char, short, int, and long, but some exact bit widths and representations are determined by the implementation.

The following properties may differ depending on the environment.

• Sizes of fundamental integer types
• Whether plain char is signed by default
• Pointer size and representation
• Alignment and padding of structure members
• Byte order
• Results of certain integer conversions
• Floating-point range and precision
• Function calling conventions
• Object-file and executable-file formats

This allows C to be implemented across systems ranging from 8-bit microcontrollers to 64-bit servers and special-purpose processors. On the other hand, code that implicitly assumes the sizes and representations of a particular environment may fail when ported to another platform.

Programs requiring exact widths can use types such as int32_t and uint64_t from <stdint.h>. However, some exact-width types may not be defined by implementations that cannot provide the corresponding width exactly.

The objectives of the C standard include promoting the portability, reliability, maintainability, and efficient execution of programs across different data-processing systems.^[26] Portability does not mean that machine-level behavior is identical in every implementation, but rather that programs can distinguish between behavior guaranteed by the standard and behavior that implementations must document.

Pointers and Direct Memory Access

A pointer represents a value referring to the location of an object or function. C programs use pointers to access memory indirectly, traverse arrays, manage dynamically allocated objects and linked data structures, and connect functions with external system interfaces.

int number = 10;
int *pointer = &number;

*pointer = 20;

&number creates a pointer referring to the object number, while *pointer accesses the object to which the pointer refers.

Pointer arithmetic operates according to the size of the pointed-to type.

int values[4] = { 10, 20, 30, 40 };
int *pointer = values;

pointer += 2;

pointer += 2 does not simply add two bytes to a numeric address. It represents a position two int elements beyond the original location.

Arrays and pointers are closely related, but they are not the same type or object. An array is an object containing a fixed number of elements, while an array name is converted in most expressions into a pointer to its first element. This conversion does not occur in certain contexts, including sizeof and the address operator.

Pointers are a central element of C’s expressiveness and efficiency, but they can also cause the following errors.

• Dereferencing a null pointer
• Accessing beyond array bounds
• Using a pointer after the lifetime of its object has ended
• Using an uninitialized pointer
• Accessing an object through an incompatible type
• Incorrect alignment
• Freeing the same memory more than once
• Incorrect conversions between integers and pointers

C does not require automatic validation of object validity and array bounds for every ordinary pointer access. Programs requiring such checks must use explicit length information, validation, safe abstractions, and analysis tools.

Explicit Resource Management

C does not require a garbage collector that automatically reclaims dynamically allocated memory. A program allocates storage using malloc, calloc, and realloc, and returns it with free when it is no longer needed.

int *values = malloc(count * sizeof(*values));

if (values == NULL) {
    return ERROR_MEMORY;
}

/* Use values */

free(values);

Files, sockets, mutexes, operating system handles, and graphics resources are also generally acquired and released explicitly.

Acquire resource
    ↓
Check for errors
    ↓
Use resource
    ↓
Release it on every execution path

Explicit resource management allows precise control over when resources are created, how long they live, and how much it costs to release them. In real-time systems, kernels, and embedded devices, this can be advantageous because it avoids unpredictable automatic reclamation work.

However, failure to manage resource lifetimes correctly can produce the following problems.

• Memory leaks
• Double frees
• Use after free
• Resource-handle leaks
• Missing cleanup on error paths
• Unclear ownership
• Incorrect destruction of partially initialized objects

C has no integrated language facility comparable to C++ destructors or Rust’s ownership system that automatically releases general resources when a scope ends. Programs manage lifetimes through functions, conventions, single cleanup paths, and separate libraries.

Direct Control over Execution Costs

C’s fundamental operations and data structures can be translated relatively directly into actual processor instructions and memory representations. Integer operations, pointer accesses, arrays, and structures do not require a complex object runtime imposed by the language, and programs are not required to automatically pay the costs of unused high-level facilities.

These characteristics allow programmers to control the following elements relatively clearly.

• Memory size of objects
• Structure composition
• Timing of memory allocation
• Function calls and the possibility of inlining
• Memory copying
• Contiguous data layout
• Bit-level representation
• Timing of system calls and library calls

However, one C statement does not always correspond to one particular machine instruction. Within the limits of preserving the observable behavior guaranteed by the language, a compiler may reorder or remove code, combine multiple operations, and use registers and vector instructions.

inline is also not a command requiring the elimination of a function call. The implementation determines how much the inline function specifier actually reduces calling costs under the standard.^[27]

Performance is not automatically guaranteed merely by the name of the language. Results depend on algorithms, data structures, memory-access patterns, compilers, optimization options, and target hardware. C provides means for controlling performance, but also places responsibility for using those means correctly on the programmer.

Abstract Machine

Instead of directly defining a particular CPU, the C standard specifies the behavior of a conceptual abstract machine on which C programs execute. An implementation must translate a program so that the observable results required by the standard appear on actual hardware.

The abstract machine provides the basis for defining the following elements.

• Meaning of expressions
• Values and lifetimes of objects
• Storage duration
• Function calls and returns
• Side effects and evaluation
• Observable input and output behavior
• Threads and atomic operations
• Program startup and termination

A compiler does not have to execute every intermediate calculation in the source code literally. If externally observable behavior remains the same, it may remove calculations, replace them with constants, inline function calls, or transform loops.

int square(int value)
{
    return value * value;
}

int result = square(4);

At runtime, the compiler may store 16 directly in result without performing an actual function call or multiplication. This is possible because the observable meaning of the program is preserved.

This model makes it possible to implement C on different hardware while also providing the theoretical foundation for optimization. Conversely, when a program depends on behavior whose meaning is not guaranteed by the standard, the compiler may produce results different from what the programmer expects.

Undefined Behavior

Undefined behavior is behavior for which the C standard imposes no requirements when an incorrect or nonportable program construct or data value is used. Dereferencing a null pointer is a representative example.^[28]

Examples of undefined behavior include the following.

• Accessing an object outside array bounds
• Dereferencing a null pointer
• Integer division by zero
• Accessing an object after its lifetime has ended
• Signed integer overflow
• Modifying a string literal that cannot be modified
• Calling through an incompatible function-pointer type
• An unsynchronized data race

When undefined behavior occurs, the implementation is under no obligation to print an error message or terminate the program. The program may coincidentally produce the expected result, corrupt other data, or have relevant code removed through optimization.

This does not mean that the compiler deliberately destroys the program. The compiler may optimize under the assumption that a defined program follows the language rules. For example, it may simplify comparisons and loops under the assumption that signed integer overflow does not occur.

Undefined behavior allows varied implementations and optimizations without forcing the language to handle every hardware-specific condition whose checking cost may be high. However, it creates substantial risks for memory safety and security, so C programs must use input validation, static analysis, dynamic checking tools, and safe APIs.

Implementation-Defined and Unspecified Behavior

In addition to undefined behavior, C uses several categories to describe differences among implementations.

Implementation-defined properties, such as whether plain char is signed, can be checked in compiler and platform documentation. When multiple orders are permitted, such as the order of function-argument evaluation, programs must not assume one particular order.

These distinctions are part of the way C supports diverse machines. Instead of fixing every detail to one virtual hardware architecture, the language allows implementations to choose efficient approaches while requiring documentation where necessary.

Balance between Portability and Machine Dependence

One of the primary goals of C standardization is to improve the portability of user programs across multiple execution environments. However, C does not eliminate every machine-dependent characteristic. WG14 describes the effort to improve portability while retaining some machine-dependent properties, avoiding the invalidation of existing programs, and preserving the basic structure and simplicity of the language as a balance among conflicting requirements.^[29]

The portability of C programs can be divided into several levels.

Strictly portable code
    ↓
Uses only features guaranteed by the standard

Implementation-defined code
    ↓
Assumes implementation documentation

Platform-dependent code
    ↓
Uses operating system APIs and ABIs

Hardware-dependent code
    ↓
Uses registers, instructions, and memory maps

General-purpose libraries can use only types and behavior guaranteed by the standard whenever possible. In contrast, operating system kernels and device drivers inherently depend on particular CPUs, devices, and compiler extensions. C permits standard regions and implementation-extension regions together so that both kinds of code can be written in the same language.

The C89 and later standards committees considered it important to clarify already widespread practices rather than designing an entirely new language. Standardization rationale documents explain that established practices were retained when clear precedent existed and that improvements proven across multiple dialects were selected for standardization.^[30]

Hosted and Freestanding Implementations

The C standard divides conforming implementations into hosted implementations and freestanding implementations.

A hosted implementation generally provides a complete program environment running on top of an operating system. It provides the standard-defined program startup method and a broad standard library. Ordinary C compilation environments on desktops and servers fall into this category.

A freestanding implementation targets environments where an operating system may not exist or where the ordinary program-startup method and complete standard library cannot be provided. Bootloaders, operating system kernels, and microcontroller firmware may fall into this category.

Hosted implementation
├── Operating system environment
├── Ordinary startup through main
└── Full standard library available

Freestanding implementation
├── May have no operating system
├── Entry point differs by implementation
└── Required standard-library scope is limited

The C23 standard distinguishes the two forms of conforming implementation as hosted and freestanding, and requires only a limited set of standard headers and facilities in freestanding implementations.^[31]

This distinction provides the basis for using C not only for operating-system applications, but also for operating systems themselves and software that executes before an operating system. The language does not necessarily require one fixed runtime or execution environment.

Separate Compilation

A C program can be created by independently translating multiple translation units and then linking them into a single program. In general, one source file and the headers included during preprocessing form a preprocessing translation unit.

main.c ──────→ main.o ───┐
                          │
network.c ───→ network.o ─┼─→ Executable program
                          │
storage.c ───→ storage.o ─┘

Because each source file can be compiled independently, modifying one part of a program does not require retranslating all of its code. Previously translated code can be stored as static or dynamic libraries.

Translation units interact through functions and objects with external linkage, data files, and similar mechanisms. The C standard specifies that translation units may be translated independently and later linked to form an executable program.^[32]

Header files provide declarations, types, and macros shared among multiple translation units. However, because header contents are textually included in each source file during preprocessing, the program and build system must maintain consistency between declarations and definitions.

Preprocessor

C provides the C preprocessor, which processes source text before full language translation. The preprocessor performs file inclusion, macro replacement, conditional compilation, and other operations.

#include <stdint.h>

#define BUFFER_SIZE 4096

#if defined(_WIN32)
    #include <windows.h>
#else
    #include <unistd.h>
#endif

The preprocessor provides the following facilities.

• Header-file inclusion
• Object-like macros
• Function-like macros
• Conditional compilation
• Token stringification
• Token pasting
• Implementation-specific pragmas
• Binary data inclusion in C23

The preprocessor is not a general function system that understands the meanings of types and variables, but a separate translation stage that transforms tokens. As a result, macro arguments may be evaluated multiple times, or operator precedence may differ from what is expected.

#define SQUARE(x) ((x) * (x))

When this macro is used with an expression containing side effects, such as SQUARE(value++), value may be incremented twice. Even when a preprocessing macro resembles a function, it does not automatically provide the same evaluation rules and type checking as a function.

The preprocessor is useful for managing platform differences and compilation settings within a single source tree, but excessive use can make the code actually being compiled difficult to understand.

Combination with Libraries

C delegates many facilities to libraries rather than including them in the language itself. The standard library defines a common API that every conforming hosted implementation must provide, while operating systems and platforms provide additional APIs above it.

C program
├── C language facilities
├── C standard library
├── Operating system APIs
├── External C libraries
└── Native interfaces of other languages

Strings are also represented not as independent high-level objects built into the language, but by convention as arrays of char elements terminated by a null character. String length, memory size, and buffer capacity are managed by the program and library caller.

This organization allows only the required facilities to be selected even in small execution environments. On the other hand, networking, graphics, and some threading facilities not provided by the standard library must depend on operating-system-specific APIs and separate libraries.

Interoperability and ABI

C is widely used as a language for expressing public interfaces of operating systems and libraries. On many platforms, C function-calling conventions and the layout of fundamental data types form the basis of the application binary interface, and other programming languages provide interfaces that can call C functions or be called from C.

The following languages and runtimes can use C interfaces.

• C++
• Objective-C
• Rust
• Python
• Lua
• Java
• C#
• Go (programming language)
• Swift
• Zig

This interoperability is not completely defined by the C standard alone. Structure alignment, function calling conventions, name mangling, and dynamic-library formats are determined by platform ABIs and compilers.

When using C interfaces between different languages, the following matters must be agreed upon.

• Sizes and representations of data types
• Function calling convention
• Structure layout and alignment
• Memory ownership
• String encoding and termination
• Error propagation method
• Lifetime of callback functions
• Thread safety
• Boundaries for exceptions and panics

C interfaces are widely used because the language provides simple, long-lived data-type and function models, and because C compilers and ABIs exist on most native platforms. WG14 also explains that C is used as a common language connecting systems and languages, as a compiler target language, an implementation language for interpreters, and a language for operating-system and embedded programming.^[33]

Conservative Standardization and Compatibility

C has source code, libraries, and operating system APIs that have been used for decades. Therefore, when new features are added, not only the consistency of the language but also their effects on existing programs and implementations are considered important.

WG14 standardization principles include balancing the following requirements.

• Improve portability.
• Retain some machine-dependent characteristics.
• Avoid damaging the basic structure of the language through new features.
• Avoid unnecessarily invalidating existing programs.
• Improve clarity and consistency.
• Preserve the simplicity of C.
• Consider implementation experience and actual practice.

This policy improves compatibility between old C code and new compilers, but can also make it difficult to remove historically inherited irregularities and dangerous features quickly. C23 removed some old function-declaration forms and obsolete facilities, but the overall language model remains continuous with earlier C.

Distinction between the Language and Its Implementations

The C language must be distinguished from the features of particular compilers. Implementations such as GCC, Clang, and MSVC may provide the following extensions in addition to standard C.

• Vector types for particular CPUs
• Inline assembly
• Function and variable attributes
• Operating-system-specific calling conventions
• Nonstandard built-in functions
• Extended integer types
• Diagnostic and static-analysis facilities
• Statement expressions not defined by the standard
• Extensions for kernel development

Extensions allow the use of platform facilities that are difficult to express in standard C, but may not operate under other implementations. Separating portable code from platform-dependent code makes it possible to reuse common logic across environments while replacing only the required implementation-specific parts.

Common standard C code
    +
Operating-system-specific code
    +
Processor-specific code
    +
Compiler-specific extensions

The fact that a compiler accepts particular syntax does not mean that the feature is part of the C standard. Build settings and documentation must clearly record which C standard edition and implementation extensions a program depends on.

Programmer Responsibility

C allows programmers to directly control data layout, resource lifetimes, pointers, buffer sizes, and error handling. At the same time, many matters are not automatically checked by the language or implementation.

C programmers may need to manage the following items directly.

• Lengths of arrays and buffers
• Pointer validity
• Object lifetimes
• Ownership of memory and resources
• Ranges of integer operations
• Function return values and error codes
• Synchronization of concurrent access
• String termination and encoding
• Implementation-defined behavior
• Platform-specific ABI differences

This design is often described by saying that C trusts the programmer. However, this does not mean that incorrect programs are considered correct. It means that various checking and resource-management policies are assigned to implementations, tools, and program design rather than always being enforced by the language runtime.

Knowing the language syntax alone is not enough to write safe and maintainable C programs. Compiler warnings, static analysis, address sanitizers, undefined-behavior sanitizers, fuzzing, code review, clear ownership rules, and restricted APIs must be used together.

Summary of Characteristics

C is a high-level language providing ordinary control flow, functions, and static typing, while also allowing the data and execution costs of actual systems to be handled directly through pointers, bitwise operations, and explicit resource management. Its small language core, library-centered structure, and distinction between hosted and freestanding environments allow it to be implemented across a broad range of systems, from machines with operating systems to small embedded devices.

C provides portability not by hiding all hardware differences, but by distinguishing behavior guaranteed by the standard from behavior that implementations may determine. Separate compilation and stable function-centered interfaces support large-scale system and library development as well as interoperability with other programming languages.

These characteristics provide high efficiency and a broad range of applications, while also creating the limitation that programmers must rigorously manage memory safety, resource lifetimes, and undefined behavior. The design of C is the result of continuously balancing automated safety with direct control, abstraction with machine dependence, and new functionality with compatibility with existing code.

A C program has a structure in which source files written as sequences of characters are preprocessed and translated into an executable program or library. Source code is divided into tokens such as keywords, identifiers, constants, string literals, operators, and punctuators, and these tokens form declarations, expressions, statements, function definitions, and preprocessing directives.

C syntax is designed by combining a relatively small number of fundamental elements. Variables, functions, and types are declared, values are calculated through expressions, and execution flow is constructed through statements. Complex data types can be expressed by combining type constructors such as arrays, pointers, functions, and structures.

#include <stdio.h>

struct point {
    int x;
    int y;
};

static int add_coordinates(const struct point *point) {
    return point->x + point->y;
}

int main(void) {
    struct point position = {
        .x = 10,
        .y = 20
    };

    printf("%d\n", add_coordinates(&position));
    return 0;
}

This program contains the following major components of C.

• The #include preprocessing directive
• A structure declaration using struct
• The fundamental int type
• Object and function declarations
• A pointer and the const qualifier
• A function call
• Member access operators
• Designated initialization
• A return statement
• Compound statements

The C standard defines the syntax and meaning of these elements, but the arrangement of source files, build commands, object file formats, and executable file formats are determined by the implementation and operating system.^[34]

Translation Units

A C program consists of one or more translation units. In general, one .c source file together with the contents of the headers included by that file during preprocessing forms a preprocessing translation unit.

main.c
    + included headers
    ↓
preprocessing translation unit
    ↓
compilation
    ↓
object file

Multiple translation units can each be translated independently and then linked into one program.

main.c     → main.o ───┐
                       │
math.c     → math.o ───┼→ executable program
                       │
storage.c  → storage.o ┘

Functions and objects with external linkage can be shared between translation units. Header files provide types, function declarations, and macros that can be used in common by multiple translation units.

/* calculator.h */

#ifndef CALCULATOR_H
#define CALCULATOR_H

int add(int left, int right);
int subtract(int left, int right);

#endif

/* calculator.c */

#include "calculator.h"

int add(int left, int right) {
    return left + right;
}

int subtract(int left, int right) {
    return left - right;
}

/* main.c */

#include <stdio.h>

#include "calculator.h"

int main(void) {
    printf("%d\n", add(10, 20));
    return 0;
}

Each source file is compiled independently, but the types of function declarations and definitions must be compatible with one another. Declaring int add(int, int) in one translation unit and defining it with a different type in another does not form a correct program.

Translation Phases

The C standard conceptually divides the processing of source files into translation phases. An actual compiler does not have to execute every phase as a separate program, but the final result must have the same meaning as the order specified by the standard.

The major process can be summarized as follows.

source file characters
    ↓
character and line-break processing
    ↓
comment removal
    ↓
preprocessing token recognition
    ↓
preprocessing directives and macro expansion
    ↓
string literal concatenation
    ↓
translation unit analysis
    ↓
external reference linking

Comments are replaced with whitespace during preprocessing.

int value = 10; /* This comment is replaced with whitespace. */

Adjacent string literals are combined into one string.

const char *message =
    "TechPedia "
    "Wiki Engine";

This declaration represents the following string.

const char *message = "TechPedia Wiki Engine";

String concatenation can be used to divide a long sentence across multiple source lines or combine macros with strings.

Character Sets

C source is written using letters, digits, punctuation, and whitespace characters. The standard defines a basic source character set and a basic execution character set, and an implementation maps the actual character encoding of a source file to the C character set during translation.

Characters fundamentally used in C source include the following.

• Latin uppercase letters from A through Z
• Latin lowercase letters from a through z
• Digits from 0 through 9
• Spaces, horizontal tabs, and line breaks
• Special characters used for operators and punctuators

Identifiers may use extended characters permitted by the implementation and standard in addition to basic Latin letters. However, considering compatibility with source code, tools, operating systems, and other languages, public API identifiers often use a restricted character set.

Comments

C supports block comments and line comments.

A block comment begins with /* and ends with */.

/*
 * An explanation can be written
 * across multiple lines.
 */
int value = 10;

A line comment extends from // to the end of the current line.

int count = 10; // Number of elements to process

Block comments cannot be nested.

/*
    Outer comment

    /* Inner comment */

    The outer comment may already be treated as ended at this point.
*/

Nesting block comments to temporarily remove code can produce unexpected syntax errors. When conditional compilation is needed, #if 0 can be used.

#if 0
int disabled_function(void) {
    return 10;
}
#endif

Tokens

During preprocessing and translation, source code is divided into tokens. The major token categories are as follows.

Whitespace separates tokens, but in most contexts the exact amount of whitespace does not affect meaning.

int value = 10;

The following code has the same token structure.

int
value
=
10
;

However, arbitrary whitespace cannot be inserted inside string and character literals, preprocessing directives, or multi-character operators.

value += 1;

The following contains separate + and = tokens rather than the += operator, so it forms different syntax.

value + = 1;

Keywords

Keywords have predefined meanings in C syntax and cannot be used as ordinary identifiers.

C keywords serve as data types, type qualifiers, storage classes, control statements, operators, and other language elements.

Representative keywords include the following.

The keyword set differs by C standard edition. For example, inline and restrict were included in the standard in C99, _Atomic and _Generic in C11, and typeof, constexpr, and nullptr in C23.

constexpr unsigned int buffer_size = 4096;
bool initialized = false;
int *pointer = nullptr;

This code can be used in C23, but in earlier standard editions the same identifiers are not standard keywords or the facilities themselves are unavailable.

Identifiers

Identifiers are names assigned to variables, functions, type aliases, structure tags, enumeration constants, labels, macros, and other entities.

int item_count;
double calculate_average(void);
struct network_packet;
typedef unsigned long object_id;

An identifier begins with a letter or permitted extended character and may contain digits afterward.

int value;
int value2;
int network_packet_count;

The following name cannot be an identifier because it begins with a digit.

int 2nd_value;

C is case-sensitive.

int value;
int Value;
int VALUE;

These are three different identifiers.

Reserved Identifiers

Some identifiers are reserved for the implementation and standard library. If a program arbitrarily defines reserved names, it may conflict with the standard library or compiler implementation.

Names that should generally be avoided include the following.

• Names beginning with two underscores
• Names beginning with an underscore followed by an uppercase letter
• Names beginning with an underscore at file scope
• Names reserved by the standard library in particular headers
• Names of standard functions and macros

int __internal_value;
int _SystemValue;

These names are reserved for the implementation.

Identifiers within a program are safer in forms such as the following.

int internal_value;
int system_value;

An implementation must support a sufficiently large maximum significant length for identifiers, but names with external linkage may also be constrained by the linker and object file format.

Name Spaces

C does not manage all identifiers within a single name space. Several kinds of names are managed separately according to their syntactic position.

The major name spaces are as follows.

• Label names
• Structure, union, and enumeration tags
• Members of structures and unions
• Other ordinary identifiers
• Preprocessing macro names

Therefore, the following declarations do not conflict.

struct item {
    int item;
};

int item;

The item in struct item belongs to the tag name space, while the global variable item belongs to the ordinary identifier name space. The structure member item belongs to the member name space of that structure.

Labels also use a separate name space.

int process(void) {
    int cleanup = 0;

cleanup:
    return cleanup;
}

The variable cleanup and label cleanup belong to different name spaces and can therefore coexist syntactically. However, reusing the same name is generally avoided for readability.

Constants

Constants represent fixed values written directly in source code. C has integer constants, floating-point constants, enumeration constants, character constants, and other constant forms.

Integer Constants

Integer constants can use different prefixes according to their radix.

int decimal = 42;
int octal = 052;
int hexadecimal = 0x2A;
int binary = 0b101010;

• No prefix indicates decimal
• A leading 0 indicates octal
• 0x or 0X indicates hexadecimal
• 0b or 0B indicates binary in C23

C23 permits apostrophes to be inserted as separators between digits.

unsigned int mask = 0b1111'0000;
long population = 50'000'000;

Digit separators do not affect the value.

The type of an integer constant is determined by its value, radix, and suffix.

10
10U
10L
10UL
10LL
10ULL

• U or u indicates an unsigned type
• L or l indicates long
• LL or ll indicates long long

Because lowercase l can be confused with the digit 1, uppercase L is generally easier to read.

long distance = 1000L;
unsigned long flags = 0x8000UL;

Floating-Point Constants

Floating-point constants use a decimal point or exponent notation.

double first = 3.14;
double second = 1.0e-6;
float third = 2.5F;
long double fourth = 1.0L;

Without a suffix, the type is double; with F, it is float; and with L, it is long double.

Hexadecimal floating-point constants can also be used.

double value = 0x1.8p+1;

The exponent following p represents a power of two. The value above is hexadecimal 1.8 multiplied by (2^1), so it represents 3.0.

Character Constants

Character constants are written with single quotation marks.

int letter = 'A';
int newline = '\n';
int tab = '\t';

An ordinary character constant has type int. An object storing a character value usually uses char.

char letter = 'A';

A character constant containing multiple characters may be syntactically permitted, but its value is implementation-defined and it has low portability.

int value = 'AB';

Such multicharacter constants are generally avoided in ordinary programs.

Escape Sequences

Characters that are difficult to write directly in character and string literals are represented by escape sequences beginning with a backslash.

const char *path = "C:\\Program Files\\Example";
const char *message = "first line\nsecond line\n";

Characters can also be represented by octal and hexadecimal values.

char letter_a = '\101';
char another_a = '\x41';

Universal character names can be used to represent Unicode code points in source code.

const char *copyright = "\u00A9";

The actual encoding of an execution string depends on the string prefix and the implementation’s character encoding rules.

String Literals

A string literal represents an array of characters enclosed in double quotation marks.

"hello"

An ordinary string literal creates an array of char with a null character automatically appended at the end.

'h' 'e' 'l' 'l' 'o' '\0'

Therefore, the size of the following array is 6.

char message[] = "hello";

A pointer can also refer to a string literal.

const char *message = "hello";

In C, the element type of an ordinary string literal is historically char, but attempting to modify its contents has undefined behavior.

char *message = "hello";
message[0] = 'H';

Because string literals must not be modified, using const char * is safer when referring to one through a pointer.

const char *message = "hello";

When a modifiable string is needed, it can be copied into an array.

char message[] = "hello";

message[0] = 'H';

String literals may have prefixes indicating character encoding.

"ordinary string"
u8"UTF-8 string"
u"UTF-16 string"
U"UTF-32 string"
L"wide string"

The element type and encoding rules of each string differ according to the prefix.

Punctuators

Punctuators delimit the structure of declarations, expressions, statements, and preprocessing syntax.

Representative punctuators include the following.

A semicolon can also form an empty statement.

while (is_device_busy()) {
}

The semicolon in the following code is the empty statement forming the body of while.

while (is_device_busy())
    ;

An unintended semicolon can make a control statement contain an empty body.

if (ready); {
    process();
}

In this code, the block executes unconditionally regardless of the if.

Declarations

A declaration specifies the meaning and type of an identifier, its storage properties, and other attributes.

int count;

This declaration declares the name count as an object of type int.

Functions can also be declared.

int calculate(int left, int right);

A declaration generally consists of the following elements.

declaration specifiers + declarator + initializer

static const unsigned long count = 10UL;

The elements in this declaration have the following roles.

• static: storage-class specifier
• const: type qualifier
• unsigned long: type specifier
• count: declarator
• = 10UL: initializer

Multiple identifiers can be declared in one declaration.

int left, right, result;

However, when pointers are involved, it is important to note that * belongs to each individual declarator.

int *left, right;

Only left is an int *; right is an int.

To declare two pointers, each declarator must contain *.

int *left;
int *right;

They can also be written as follows.

int *left, *right;

For readability and ease of modification, some projects use a rule of placing only one object in each declaration.

Declarators

A declarator combines an identifier with type structures such as pointers, arrays, and functions.

int value;
int *pointer;
int values[10];
int function(int value);
int (*callback)(int value);

A declaration can be read similarly to the form in which its identifier is used in an expression.

int *pointer;

This means that *pointer has type int.

int values[10];

This means that values[index] has type int.

int function(int value);

This means that function(value) returns an int.

int (*callback)(int value);

Because (*callback)(value) returns an int, callback is a function pointer.

Parentheses change the binding order of a declarator.

int *functions[4];

functions is an array whose elements are int *.

int (*function)(void);

function is a pointer to a function returning int.

int *function(void);

function is a function returning int *.

Complex declarations can be divided into stages with typedef.

typedef int (*comparison_function)(
    const void *left,
    const void *right
);

comparison_function comparator;

Definitions

A declaration introduces a name and type, while a definition creates storage for an object or provides the body of a function.

The following is an object definition.

int global_count;

The following declares an object but does not define it in this translation unit.

extern int global_count;

A function prototype is a function declaration.

int calculate(int left, int right);

Including a function body makes it a definition.

int calculate(int left, int right) {
    return left + right;
}

Duplicating definitions of objects or functions with external linkage within one program can produce linker errors or violate definition rules.

Types

C types determine the kinds of values represented by objects and functions and the operations that can be applied to them.

The major type categories are as follows.

types
├── object types
│   ├── fundamental types
│   │   ├── integer types
│   │   ├── floating-point types
│   │   └── enumerations
│   ├── pointer types
│   ├── array types
│   ├── structures
│   ├── unions
│   └── atomic types
├── function types
└── void type

A type affects an object’s size and alignment, the range of its values, its representation, and the operations permitted on it.

Integer Types

The standard integer types include the following.

_Bool
char
signed char
unsigned char
short
unsigned short
int
unsigned int
long
unsigned long
long long
unsigned long long

C23 allows bool to be used alongside _Bool.

bool enabled = true;

The exact bit widths of integer types are not the same in every implementation. The standard specifies minimum representable ranges and ordering relationships among their sizes.

sizeof(char) ≤ sizeof(short) ≤ sizeof(int)
             ≤ sizeof(long) ≤ sizeof(long long)

sizeof(char) is always 1, but this does not mean that one C byte must contain exactly eight bits. The number of bits in one byte can be checked through CHAR_BIT.

#include <limits.h>

static_assert(CHAR_BIT >= 8);

char, signed char, and unsigned char are distinct types. Whether plain char is signed or unsigned is determined by the implementation.

When an exact width is required, the types in <stdint.h> can be used.

#include <stdint.h>

uint8_t byte;
int32_t coordinate;
uint64_t identifier;

An exact-width type is defined only when the implementation can provide precisely that number of bits.

Floating-Point Types

The real floating-point types are as follows.

float
double
long double

The range and precision of each type can differ according to the implementation and floating-point format.

float single_precision = 1.0F;
double double_precision = 1.0;
long double extended_precision = 1.0L;

C can also support complex types.

#include <complex.h>

double complex value = 1.0 + 2.0 * I;

Floating-point computation is not completely identical to ordinary real-number mathematics. It can be affected by rounding, infinities, NaN values, and the floating-point environment.

void

void indicates the absence of a value or the absence of a specified complete object type.

A function that returns no value uses void as its return type.

void print_message(void) {
    puts("hello");
}

void * is used as a general-purpose pointer to an object.

void *memory = malloc(1024);

void itself is not an object type, so an object such as the following cannot be created.

void value;

To access the object referred to by a void *, it must be converted to a specific object pointer type.

int value = 10;
void *memory = &value;
int *integer = memory;

printf("%d\n", *integer);

Enumerations

An enumeration defines a set of named integer constants.

enum connection_state {
    CONNECTION_DISCONNECTED,
    CONNECTION_CONNECTING,
    CONNECTION_CONNECTED
};

An enumeration object can be used to represent one of the defined states.

enum connection_state state = CONNECTION_CONNECTING;

Enumeration constants can be used as integer constant expressions.

int counters[CONNECTION_CONNECTED + 1];

C23 allows an enumeration to specify a fixed underlying type.

enum packet_type : unsigned char {
    PACKET_CONNECT = 1,
    PACKET_DATA = 2,
    PACKET_DISCONNECT = 3
};

This syntax is unavailable in standard editions before C23.

Structures

A structure places members of different types sequentially within one object.

struct point {
    int x;
    int y;
};

A structure object is defined as follows.

struct point position;

It can also be initialized.

struct point position = {
    .x = 10,
    .y = 20
};

Members of a structure object are accessed with ..

position.x = 30;

When using a pointer to a structure, -> is used.

struct point *pointer = &position;

pointer->y = 40;

The following two expressions have the same meaning.

pointer->x
(*pointer).x

Padding for alignment can be inserted between structure members. Therefore, the size of a structure must not be assumed to equal the simple sum of the sizes of its members.

struct example {
    char tag;
    int value;
};

Padding may be inserted between char and int.

union

A union allows several members to share the same storage.

union number {
    int integer;
    float floating;
};

The size of a union is generally sufficient to satisfy the size and alignment requirements of its largest member.

union number value;

value.integer = 10;

Reading one member after storing a value in another involves detailed standard rules and implementation characteristics. It must not be assumed to be an unconditionally safe means of arbitrary type conversion.

A separate tag can be stored to distinguish the currently active member.

enum value_type {
    VALUE_INTEGER,
    VALUE_FLOATING
};

struct value {
    enum value_type type;

    union {
        int integer;
        float floating;
    } data;
};

Arrays

An array stores elements of the same type contiguously.

int values[4];

Elements are accessed with indexes beginning at zero.

values[0] = 10;
values[1] = 20;

The number of elements in an array can be calculated as follows.

size_t count = sizeof(values) / sizeof(values[0]);

This method is valid only in a scope where values is an actual array. An array declaration used as a function parameter is adjusted to a pointer type.

void clear_values(int values[10]) {
    /* The type of values is adjusted to int * inside the function. */
}

Therefore, inside the function, sizeof(values) yields the size of a pointer rather than the size of the original complete array.

The array size must be passed separately.

void clear_values(int *values, size_t count) {
    for (size_t index = 0; index < count; ++index) {
        values[index] = 0;
    }
}

C99 variable-length arrays can use a size determined at runtime.

void process(size_t count) {
    int values[count];

    /* ... */
}

Support for variable-length arrays and the contexts in which they can be used can differ according to the standard edition and implementation.

Pointers

A pointer represents a value referring to an object or function.

int value = 10;
int *pointer = &value;

& obtains the address of an object, and * accesses the object referred to by a pointer.

*pointer = 20;

A null pointer does not refer to a valid object or function.

int *pointer = NULL;

C23 allows nullptr to be used.

int *pointer = nullptr;

Dereferencing a null pointer causes undefined behavior.

*pointer = 10;

Pointer arithmetic operates in units of elements of the pointed-to type.

int values[] = { 10, 20, 30 };
int *pointer = values;

pointer += 2;

pointer refers to the third int element.

Pointer arithmetic is defined only within the bounds of the same array object and the position immediately beyond its end. Arbitrarily adding or subtracting pointers to unrelated objects is not permitted.

Function Types

A function type includes a return type and parameter types.

int add(int left, int right);

add is a function that accepts two int values and returns an int.

A pointer to a function can be created.

int (*operation)(int left, int right) = add;

A function pointer can be called.

int result = operation(10, 20);

The following form represents the same call.

int result = (*operation)(10, 20);

Function pointers are used for callbacks, strategy selection, event processing, and dynamic library interfaces.

Type Qualifiers

Type qualifiers express additional constraints concerning how an object is accessed, optimization, and concurrency.

const

const indicates that an object cannot be modified through the corresponding identifier.

const int value = 10;

The following assignment is not permitted.

value = 20;

In a pointer declaration, the meaning differs according to the position of const.

const int *pointer;

The int referred to by pointer cannot be modified through this pointer.

int *const pointer = &value;

The pointer itself cannot be changed to refer to another address.

const int *const pointer = &value;

Neither the pointer itself nor the pointed-to value can be changed through the corresponding identifier.

const does not always mean that an object can never physically change. The possibility of modification through another unqualified pointer, hardware, or another thread depends on the object and program structure.

volatile

volatile indicates that access to an object may have side effects that the implementation must observe.

volatile unsigned int *status_register;

It can be used for memory-mapped hardware registers and certain signal-processing objects.

while ((*status_register & READY_BIT) == 0) {
}

The compiler treats each access as one that must actually be performed.

volatile is not a thread synchronization mechanism. When multiple threads access the same object, appropriate synchronization such as atomic types or mutexes is required.

restrict

restrict expresses a promise that a particular pointer is a primary means of accessing an object.

void copy_values(
    int *restrict destination,
    const int *restrict source,
    size_t count
) {
    for (size_t index = 0; index < count; ++index) {
        destination[index] = source[index];
    }
}

If the caller violates the aliasing rules associated with restrict, undefined behavior can occur. restrict is not merely an optimization request, but a semantic rule that the program must obey.

_Atomic

Atomic types provide indivisible atomic accesses between multiple threads.

#include <stdatomic.h>

_Atomic int counter = 0;

An atomic type specifier can also be used.

atomic_int counter = 0;

Standard atomic operations can be applied to atomic objects.

atomic_fetch_add(&counter, 1);

Atomicity alone does not automatically solve synchronization for an entire algorithm. Memory ordering and the consistency of compound state must also be designed.

Storage Classes

Storage class specifiers affect the storage duration and linkage of objects and functions and the nature of a declaration.

auto

An ordinary local variable at block scope has automatic storage duration by default.

void function(void) {
    auto int value = 10;
}

auto traditionally represented the storage class of a local object, but it has almost always been omitted.

void function(void) {
    int value = 10;
}

In C23, auto can also infer an object type from its initializer.

auto value = 42;
auto ratio = 3.14;

register

register was a storage class suggesting that an implementation provide fast access to an object.

register int index;

Modern compilers determine register allocation through their own analysis, so this specifier does not guarantee performance. Traditionally, there was also a restriction preventing the address operator from being applied to a register object.

static

At file scope, static gives an identifier internal linkage.

static int internal_count;

This object can be accessed by name only within the same translation unit.

It can also give a function internal linkage.

static int calculate_internal_value(void) {
    return 10;
}

When used with a local object at block scope, it gives the object static storage duration.

int next_identifier(void) {
    static int identifier = 0;

    return ++identifier;
}

identifier retains its lifetime after a function call ends.

extern

extern indicates that an object or function may be defined elsewhere.

extern int global_count;

Another translation unit can contain the following definition.

int global_count = 0;

A function declaration has external linkage by default.

extern int calculate(void);

Normally, extern is omitted.

int calculate(void);

typedef

typedef assigns a new name to an existing type.

typedef unsigned long object_id;

object_id identifier = 10;

It can simplify the representation of a structure type.

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

point position = {
    .x = 10,
    .y = 20
};

typedef does not create a new incompatible type; it creates an alias for an existing type.

typedef int meter;
typedef int second;

meter and second are both the same type as int and are not automatically distinguished from each other.

Scope

Scope indicates the region of source code in which an identifier introduced by a declaration can be used.

The major scopes are as follows.

• File scope
• Block scope
• Function prototype scope
• Function scope

File Scope

An identifier declared outside a function has file scope.

static int global_count;

int calculate(void) {
    return global_count;
}

The name can be used from its declaration point to the end of the translation unit.

Block Scope

An identifier declared inside a block can be used in that block and its nested blocks.

int calculate(void) {
    int result = 10;

    if (result > 0) {
        int doubled = result * 2;
        return doubled;
    }

    return result;
}

doubled cannot be used outside the if block.

An inner declaration can hide an outer name.

int value = 10;

void function(void) {
    int value = 20;

    printf("%d\n", value);
}

The value inside the function hides the global value.

Function Scope

A label name has function scope extending across the entire function.

int process(int failed) {
    if (failed) {
        goto cleanup;
    }

    return 0;

cleanup:
    return -1;
}

A label can be referenced within the same function even when it appears after the goto.

Linkage

Linkage determines whether identical names in different scopes or translation units refer to the same object or function.

Linkage is divided as follows.

• External linkage
• Internal linkage
• No linkage

A function with external linkage can denote the same function in multiple translation units.

int calculate(void);

Declaring it with static at file scope gives it internal linkage.

static int calculate_internal(void);

A local variable has no linkage.

void function(void) {
    int local_value;
}

Linkage and scope are different concepts. Scope is the source region in which a name can be used, while linkage determines whether multiple declarations are connected to the same entity.

Storage Duration

Storage duration indicates the period during which storage for an object exists.

The major storage durations are as follows.

• Static storage duration
• Thread storage duration
• Automatic storage duration
• Allocated storage duration

Static Storage Duration

File-scope objects and static local objects exist throughout the entire execution of a program.

static int global_count;

int next_value(void) {
    static int local_count;

    return ++local_count;
}

Thread Storage Duration

A thread_local or _Thread_local object has a separate instance for each thread.

thread_local int current_worker_id;

The object’s lifetime is associated with the execution period of the corresponding thread.

Automatic Storage Duration

Ordinary local variables and function parameters have automatic storage duration associated with execution of the block.

int calculate(int input) {
    int result = input * 2;

    return result;
}

When the function returns, the lifetimes of input and result end. Returning a pointer to such an object produces an invalid pointer.

int *invalid_pointer(void) {
    int value = 10;

    return &value;
}

Allocated Storage Duration

Storage obtained from a dynamic memory allocation function remains until it is explicitly released.

int *value = malloc(sizeof(*value));

if (value != NULL) {
    *value = 10;
    free(value);
}

Failing to release allocated memory causes a memory leak. Accessing storage after it has been released causes undefined behavior.

Initialization

Initialization establishes the initial value of an object when it is created.

int value = 10;

An array can use an initializer list.

int values[4] = { 10, 20, 30, 40 };

If only some elements are provided, the remaining elements are initialized to values equivalent to zero.

int values[4] = { 10 };

The array contains the following values.

10, 0, 0, 0

A structure can also be initialized in order.

struct point {
    int x;
    int y;
};

struct point position = { 10, 20 };

Designated initialization can explicitly name members.

struct point position = {
    .y = 20,
    .x = 10
};

Array indexes can also be designated.

int values[10] = {
    [0] = 10,
    [9] = 100
};

C23 allows an empty initializer list.

struct point position = {};
int values[10] = {};

Objects are initialized to values equivalent to zero for their respective types.

An object with static storage duration is zero-initialized even without an explicit initializer.

static int global_count;
static int *global_pointer;

An object with automatic storage duration can contain an indeterminate value when it is not explicitly initialized.

void function(void) {
    int value;

    printf("%d\n", value);
}

Reading the value of an uninitialized automatic object can produce undefined behavior or an indeterminate result depending on the object, type, and context, so the object must be assigned a value before use.

Type Conversions

C converts values to other types in many situations. A conversion can occur implicitly or be explicitly requested through a cast.

Integer Promotions

char, short, _Bool, and some enumeration types are promoted to int or unsigned int in arithmetic operations.

unsigned char left = 200;
unsigned char right = 100;

int result = left + right;

The addition is not performed directly in the original unsigned char type, but after integer promotion.

Usual Arithmetic Conversions

When values of different arithmetic types are used together in an operation, conversions determine a common type.

int integer = 10;
double floating = 2.5;

double result = integer + floating;

integer is converted to double before the addition.

Mixing signed and unsigned integers can produce unexpected results.

int signed_value = -1;
unsigned int unsigned_value = 1;

if (signed_value < unsigned_value) {
    /* The environment and conversion rules must be understood. */
}

Before the comparison, signed_value can be converted to an unsigned type, causing -1 to be interpreted as a very large positive value.

Explicit Casts

A cast writes the destination type in parentheses.

double value = 3.75;
int integer = (int)value;

The fractional part is discarded and integer becomes 3.

Pointer types can also be converted.

void *memory = malloc(sizeof(int));
int *integer = (int *)memory;

In C, a conversion from void * to an object pointer type does not require a cast.

int *integer = memory;

An unnecessary cast can hide type errors. In particular, casting the return value of malloc can conceal a missing declaration caused by failing to include <stdlib.h>, so the cast is generally omitted in C.

A cast does not resolve invalid data, alignment, or object lifetime problems. It merely specifies a type conversion permitted by the standard.

Expressions

An expression is a syntactic element that computes a value, reads or modifies an object, or calls a function.

left + right

An expression has a value and type, and some expressions produce side effects.

count += 1;

This expression computes a value while also modifying count.

Expressions can be combined as parts of larger expressions.

result = left + right * scale;

Operator precedence causes multiplication to bind first.

result = left + (right * scale);

Evaluation order is a different concept from precedence. Precedence determines which operators bind to which operands syntactically, while separate rules determine the order in which the operands are actually evaluated.

Value Categories

C expressions can have different properties, such as designating an object or merely computing a value.

An expression designating an object can sometimes appear on the left side of an assignment.

int value;
value = 10;

An expression that does not designate a modifiable object cannot be assigned to.

10 = value;

Array and function expressions are converted in most contexts to pointers.

int values[4];
int *pointer = values;

A function name can also be converted to a function pointer.

int calculate(int value);

int (*callback)(int) = calculate;

Arithmetic Operators

Arithmetic operators are used for numerical computation.

int sum = left + right;
int difference = left - right;
int product = left * right;
int quotient = left / right;
int remainder = left % right;

Integer division truncates toward zero.

int value = 7 / 2;

The result is 3.

int value = -7 / 2;

The result is -3.

Integer division by zero causes undefined behavior.

int value = 10 / 0;

An operation whose result exceeds the representable range of a signed integer also causes undefined behavior.

int value = INT_MAX;
value += 1;

Unsigned integers perform modular arithmetic according to the range of their type.

unsigned int value = UINT_MAX;
value += 1;

The result is 0.

Increment and Decrement

++ and -- increase or decrease an object’s value by one.

++count;
--count;

A prefix operation yields the modified value as its result.

int result = ++count;

A postfix operation yields the original value and then modifies the object.

int result = count++;

Combining expressions with side effects in a complicated way within one statement can cause evaluation-order problems.

values[index++] = index;

An expression that reads and modifies the same object without the required sequencing can have undefined behavior. Separating the modifications into different statements is clearer.

values[index] = index;
++index;

Comparison Operators

Comparison operators compare two values and produce an int value of 1 when true and 0 when false.

if (left == right) {
    /* ... */
}

Confusing the assignment operator = with the equality operator == can cause errors.

if (value = 10) {
    /* Assigns 10 to value and then evaluates as true. */
}

Use == for comparison.

if (value == 10) {
    /* ... */
}

Enabling compiler warnings can diagnose suspicious assignments inside conditions.

Logical Operators

Logical operators combine conditions.

| Operator | Meaning | | | | -------- | ----------- | - | ---------- | | ! | Logical NOT | | | | && | Logical AND | | | | | | | Logical OR |

if (pointer != NULL && *pointer > 0) {
    process(*pointer);
}

&& and || perform short-circuit evaluation.

• && does not evaluate the right operand when the left operand is false.
• || does not evaluate the right operand when the left operand is true.

Therefore, in the code above, *pointer is not evaluated when pointer is a null pointer.

A logical operation produces either 0 or 1.

int result = left < right && ready;

Bitwise Operators

Bitwise operators process individual bits of integer values.

unsigned int flags = 0;

flags |= FLAG_VISIBLE;
flags &= ~FLAG_DISABLED;
flags ^= FLAG_SELECTED;

A particular bit can be tested as follows.

if ((flags & FLAG_VISIBLE) != 0) {
    /* ... */
}

Shift operations move bit positions.

unsigned int mask = 1U << 5;

If the shift count is negative or greater than or equal to the width of the type, undefined behavior occurs. Care is also required with shifts of negative signed values and left shifts beyond the representable range. Using unsigned integer types for bit manipulation usually makes the rules easier to understand.

Assignment Operators

Simple assignment stores the right-hand value in the left-hand object.

value = 10;

Compound assignment operators combine the existing value with an operation and store the result again.

value += 10;
value -= 10;
value *= 2;
value /= 2;
value %= 3;
flags &= mask;
flags |= mask;
flags ^= mask;
value <<= 1;
value >>= 1;

Compound assignment differs from simple textual replacement in that the left operand is evaluated only once.

values[index++] += 10;

index++ is evaluated once.

An assignment expression itself also has a value.

left = right = 0;

First, 0 is assigned to right, and then the resulting value is assigned to left.

The result of an assignment can be used in a condition, but parentheses and an explicit comparison should be used when the intent could otherwise be unclear.

while ((character = getchar()) != EOF) {
    putchar(character);
}

Conditional Operator

The conditional operator ?: evaluates one of two expressions according to a condition.

int maximum = left > right ? left : right;

This is similar to the following if statement.

int maximum;

if (left > right) {
    maximum = left;
} else {
    maximum = right;
}

The conditional operator is suitable for short expressions that select a value. Readability can decrease when it contains multiple side effects or nested conditions.

Comma Operator

The comma operator evaluates the left expression, then evaluates the right expression, and uses the right result as the value of the complete expression.

int result = (prepare(), calculate());

Commas used in function argument lists and declarator lists have different syntactic roles from the comma operator.

function(left, right);

The evaluation order of the two function arguments is not guaranteed to be left-to-right merely because they are separated by a comma.

The comma operator is often used in a for statement to update multiple expressions together.

for (
    size_t left = 0, right = count - 1;
    left < right;
    ++left, --right
) {
    /* ... */
}

sizeof

sizeof yields the size of a type or object representation in bytes.

size_t integer_size = sizeof(int);
size_t value_size = sizeof value;

Parentheses are required around a type name.

sizeof(int)

Parentheses can be omitted for an expression.

sizeof value

The size of an entire array can be obtained.

int values[10];

size_t size = sizeof(values);
size_t count = sizeof(values) / sizeof(values[0]);

Most expressions inside sizeof are not actually evaluated.

size_t size = sizeof(value++);

Except in some situations involving variable-length arrays, value is not incremented.

When allocating dynamic memory, calculating the size from the destination object makes the code resilient to type changes.

int *values = malloc(count * sizeof(*values));

Alignment Operators

_Alignof, or alignof in C23, yields the alignment requirement of a type.

size_t alignment = alignof(double);

_Alignas, or alignas, specifies an alignment requirement for an object.

alignas(64) unsigned char cache_line[64];

Alignment can be important for structure layout, SIMD, atomic access, and hardware interfaces.

Member Access

Members of structure and union objects are accessed with ..

position.x

Member access through a pointer uses ->.

pointer->x

-> combines dereferencing with ..

pointer->x
(*pointer).x

Parentheses are required because of the precedence of the dereference operator.

*pointer.x

This expression is interpreted as *(pointer.x), so it has a different meaning from structure pointer access.

Array Subscripting

Array subscripting combines pointer arithmetic with dereferencing.

values[index]

It is equivalent to the following expression.

*(values + index)

Syntactically, the following expression can produce the same result.

index[values]

However, it is not used because it violates convention and reduces readability.

C does not automatically check bounds for ordinary array subscripting.

int values[4];

values[4] = 10;

The valid indexes are 0 through 3, so this out-of-bounds access causes undefined behavior.

Function Calls

A function is called by writing parentheses and an argument list after a function name or function pointer.

int result = add(10, 20);

Argument expressions are converted according to the function’s parameter types.

double square(double value);

double result = square(10);

The integer 10 is converted to double.

Function arguments are generally not guaranteed to be evaluated from left to right.

function(first(), second());

It must not be assumed whether first or second is called first. When execution order matters, the calls should be separated into statements.

int first_result = first();
int second_result = second();

function(first_result, second_result);

Compound Literals

A C99 compound literal creates an unnamed object from a type name and initializer list.

struct point {
    int x;
    int y;
};

draw_point((struct point) {
    .x = 10,
    .y = 20
});

An array compound literal can also be created.

process_values(
    (int[]) { 10, 20, 30 },
    3
);

The storage duration of a compound literal is determined by its location of use and the rules of the corresponding standard edition.

Generic Selection

C11 _Generic selects one expression according to the type of a controlling expression.

#define TYPE_NAME(value) \
    _Generic((value), \
        int: "int", \
        float: "float", \
        double: "double", \
        default: "other")

printf("%s\n", TYPE_NAME(10));

The result is "int".

A macro can also select a type-specific function.

#define ABSOLUTE(value) \
    _Generic((value), \
        int: abs, \
        long: labs, \
        float: fabsf, \
        double: fabs \
    )(value)

_Generic performs type selection at translation time rather than runtime branching.

Constant Expressions

A constant expression is a restricted expression that can be evaluated at translation time. It is used for array sizes, enumeration constants, case labels, static verification, and other contexts.

enum {
    BUFFER_SIZE = 1024
};

int buffer[BUFFER_SIZE];

switch (value) {
case BUFFER_SIZE:
    break;
}

A C23 constexpr object can define a named constant.

constexpr size_t buffer_size = 4096;

static_assert(buffer_size > 0);

A const object is not always accepted as an integer constant expression.

const int size = 10;

Depending on the standard edition and context, it may not be usable as a constant expression for an array size or similar construct. An enum, macro, or C23 constexpr can be used instead.

Statements

Statements construct the execution flow of a program.

The major statement categories are as follows.

• Labeled statements
• Compound statements
• Expression statements
• Selection statements
• Iteration statements
• Jump statements

Expression Statements

An expression followed by a semicolon forms an expression statement.

value = 10;
function();
++count;

A semicolon without an expression forms an empty statement.

;

Compound Statements

A group of declarations and statements enclosed in braces is called a compound statement or block.

{
    int value = 10;

    process(value);
}

Compound statements are used as function bodies and control statement bodies.

if Statement

if executes a statement according to a condition.

if (value > 0) {
    process_positive(value);
}

else specifies a statement to execute when the condition is false.

if (value > 0) {
    process_positive(value);
} else {
    process_non_positive(value);
}

Multiple conditions can be connected.

if (value > 0) {
    result = 1;
} else if (value < 0) {
    result = -1;
} else {
    result = 0;
}

In C, zero is treated as false and a nonzero value as true.

if (pointer) {
    /* pointer is not a null pointer */
}

An explicit comparison can also be used.

if (pointer != NULL) {
    /* ... */
}

When braces are omitted, only the next single statement belongs to the condition.

if (ready)
    start();

Because additional statements may be added during maintenance, explanatory code in TechPedia uses braces by default even when the body contains only one statement.

if (ready) {
    start();
}

switch Statement

switch selects one of several execution paths according to the value of an integer or enumeration expression.

switch (command) {
case COMMAND_START:
    start();
    break;

case COMMAND_STOP:
    stop();
    break;

default:
    report_unknown_command();
    break;
}

A case label requires an integer constant expression.

Without break, execution continues into the following case.

switch (level) {
case LEVEL_ERROR:
    log_error();

case LEVEL_WARNING:
    increase_warning_count();
    break;
}

When such fallthrough is intentional, a C23 attribute or explicit comment can be used.

switch (level) {
case LEVEL_ERROR:
    log_error();
    [[fallthrough]];

case LEVEL_WARNING:
    increase_warning_count();
    break;
}

case values cannot be duplicated within the same switch.

while Statement

while repeats its body while the condition is true.

while (count > 0) {
    process();
    --count;
}

The condition is evaluated before each iteration, so the body is not executed at all when the condition is false initially.

An infinite loop can be written as follows.

while (true) {
    process_events();
}

Before C23, true from <stdbool.h> or the integer 1 can be used.

while (1) {
    process_events();
}

do Statement

A do statement executes its body first and checks the condition afterward.

do {
    read_input();
} while (!input_is_valid());

The body executes at least once. A semicolon is required after the final while.

for Statement

for places initialization, a condition, and a post-iteration expression together.

for (size_t index = 0; index < count; ++index) {
    process(values[index]);
}

Its structure is as follows.

for (initialization; condition; post-iteration expression)

Initialization executes once before the loop begins. The condition is evaluated before each iteration, and the post-iteration expression executes after the body.

Each part can be omitted.

for (;;) {
    process_events();
}

This forms an infinite loop.

Multiple values can also be updated.

for (
    size_t left = 0, right = count - 1;
    left < right;
    ++left, --right
) {
    swap(&values[left], &values[right]);
}

break

break terminates the nearest loop or switch statement.

while (true) {
    if (should_stop()) {
        break;
    }

    process();
}

Within nested loops, only the innermost loop is terminated.

continue

continue skips the remainder of the current iteration and proceeds to the next one.

for (size_t index = 0; index < count; ++index) {
    if (!is_valid(values[index])) {
        continue;
    }

    process(values[index]);
}

In a for statement, control moves to the post-iteration expression. In while and do, it moves to condition evaluation.

return

return terminates the current function and returns control to the calling location.

A value-returning function uses a return expression.

int add(int left, int right) {
    return left + right;
}

A void function can return without a value.

void process(int value) {
    if (value < 0) {
        return;
    }

    /* ... */
}

The return expression is converted to the function’s return type.

double calculate(void) {
    return 10;
}

The integer 10 is converted to double.

A problem occurs when a function that must return a value reaches the end of a normal execution path without one. As an exception, reaching the end of main has the same meaning as return 0;.

goto and Labels

goto transfers execution to a label within the same function.

int process(const char *path) {
    FILE *file = fopen(path, "rb");

    if (file == NULL) {
        return -1;
    }

    void *buffer = malloc(4096);

    if (buffer == NULL) {
        goto cleanup_file;
    }

    free(buffer);
    fclose(file);
    return 0;

cleanup_file:
    fclose(file);
    return -1;
}

Because C has no integrated facility that automatically releases general resources when a scope ends, goto is sometimes used in a limited manner for error handling that releases several resources in reverse order.

int process(const char *path) {
    int result = -1;
    FILE *input = NULL;
    FILE *output = NULL;
    void *buffer = NULL;

    input = fopen(path, "rb");

    if (input == NULL) {
        goto cleanup;
    }

    output = fopen("output.bin", "wb");

    if (output == NULL) {
        goto cleanup;
    }

    buffer = malloc(4096);

    if (buffer == NULL) {
        goto cleanup;
    }

    result = 0;

cleanup:
    free(buffer);

    if (output != NULL) {
        fclose(output);
    }

    if (input != NULL) {
        fclose(input);
    }

    return result;
}

goto cannot transfer control outside the function or to a label in another function.

Functions

A function is a program unit that accepts input through parameters, performs work, and optionally returns a value.

A function declaration specifies a return type, name, and parameter types.

int add(int left, int right);

A function definition includes a body.

int add(int left, int right) {
    return left + right;
}

An appropriate declaration must be visible before a function is called.

int calculate(int value);

int main(void) {
    return calculate(10);
}

int calculate(int value) {
    return value * 2;
}

Since C99, an undeclared function is no longer implicitly treated as a function returning int.

Parameters

Function parameters are local objects initialized from argument values when the function is called.

int multiply(int left, int right) {
    return left * right;
}

C passes arguments by value by default.

void set_value(int value) {
    value = 10;
}

The caller’s object is not modified.

int value = 0;

set_value(value);

To modify the caller’s object, a pointer is passed.

void set_value(int *value) {
    *value = 10;
}

int value = 0;

set_value(&value);

A structure can also be passed by value.

struct point move_point(struct point point, int x, int y) {
    point.x += x;
    point.y += y;

    return point;
}

The original structure is not modified; the copied parameter is changed.

A large structure can be passed through a pointer when considering copying costs and the intention to modify it.

void move_point(struct point *point, int x, int y) {
    point->x += x;
    point->y += y;
}

Array Parameters

Array syntax in a function parameter is adjusted to a pointer type.

void process(int values[10]);

In the function type, this is compatible with the following declaration.

void process(int *values);

The array length is not passed automatically.

void process(const int *values, size_t count) {
    for (size_t index = 0; index < count; ++index) {
        printf("%d\n", values[index]);
    }
}

C99 array parameter syntax can express qualifiers or a minimum element count.

void process(
    size_t count,
    int values[static count]
) {
    /* The caller must provide at least count elements. */
}

This syntax supplies contract information to the caller and implementation, but it does not mean that runtime bounds checking is automatically performed.

Variadic Functions

Using ... as the last parameter declares a function accepting a variable number of arguments.

int printf(const char *restrict format, ...);

A user-defined variadic function uses <stdarg.h>.

#include <stdarg.h>

int sum_values(size_t count, ...) {
    va_list arguments;
    int result = 0;

    va_start(arguments, count);

    for (size_t index = 0; index < count; ++index) {
        result += va_arg(arguments, int);
    }

    va_end(arguments);
    return result;
}

The caller must provide exactly the number and types of arguments expected by the function.

int result = sum_values(3, 10, 20, 30);

Individual type checking through a function prototype does not apply to the variadic part. Reading an argument with the wrong type can cause undefined behavior.

Recursion

A C function can call itself directly or indirectly.

unsigned long long factorial(unsigned int value) {
    if (value <= 1) {
        return 1;
    }

    return value * factorial(value - 1);
}

Each recursive call may create new automatic objects and call information. Excessively deep recursion can exhaust the call stack of the execution environment.

inline

inline indicates that a function call can be implemented in inline form and also affects C linkage and definition rules.

static inline int square(int value) {
    return value * value;
}

The compiler determines whether actual inlining occurs. inline alone does not guarantee elimination of call overhead.

When a short function is defined in a header, the static inline form with internal linkage is commonly used.

#ifndef VECTOR_H
#define VECTOR_H

struct vector2 {
    float x;
    float y;
};

static inline struct vector2 vector2_add(
    struct vector2 left,
    struct vector2 right
) {
    return (struct vector2) {
        .x = left.x + right.x,
        .y = left.y + right.y
    };
}

#endif

Function Pointers and Callbacks

A function pointer allows a function to be selected and passed like a value.

typedef int (*operation_function)(int left, int right);

int add(int left, int right) {
    return left + right;
}

int subtract(int left, int right) {
    return left - right;
}

int calculate(
    operation_function operation,
    int left,
    int right
) {
    return operation(left, right);
}

int result = calculate(add, 10, 20);

An array of function pointers can select a function according to a command.

static operation_function operations[] = {
    add,
    subtract
};

If a function pointer type is incompatible with the actual function, calling through it can cause undefined behavior.

Preprocessor

The C preprocessor processes preprocessing tokens in source code before ordinary C parsing.

Its major facilities are as follows.

• Header and file inclusion
• Macro definition and expansion
• Conditional compilation
• Translation diagnostics
• Implementation directives
• Source line information control
• Binary data inclusion in C23

A preprocessing directive generally begins with # as the first preprocessing token of a line.

#include <stdio.h>
#define BUFFER_SIZE 4096

#include

#include includes the contents of a specified header or file in the current preprocessing translation unit.

#include <stdio.h>

The angle bracket form generally uses the implementation’s and system’s header search paths.

#include "project.h"

The quoted form generally searches the current source and project paths first, and if the file is not found, may continue with the system header search method. The implementation determines the exact search rules.

Because header text is included directly, an include guard is used to prevent the same declarations from being processed multiple times.

#ifndef PROJECT_H
#define PROJECT_H

int project_initialize(void);

#endif

When supported by an implementation, #pragma once can also be used, but it is not an ISO C standard preprocessing directive.

Object-Like Macros

An object-like macro replaces a name with other preprocessing tokens.

#define BUFFER_SIZE 4096
#define APPLICATION_NAME "TechPedia"

The tokens are expanded where the macro is used.

char buffer[BUFFER_SIZE];

A macro is not a typed object. Enumeration constants or C23 constexpr objects can also be used for integer constants.

enum {
    BUFFER_SIZE = 4096
};

constexpr size_t buffer_size = 4096;

Function-Like Macros

A function-like macro accepts arguments and substitutes tokens.

#define MAXIMUM(left, right) \
    ((left) > (right) ? (left) : (right))

Failing to parenthesize a macro body and its arguments can cause operator precedence problems.

#define SQUARE(value) value * value

int result = SQUARE(1 + 2);

The expansion is as follows.

int result = 1 + 2 * 1 + 2;

A safer form is as follows.

#define SQUARE(value) ((value) * (value))

However, the problem of evaluating an argument multiple times remains.

int result = SQUARE(index++);

Because index++ is expanded twice, undefined behavior or an unexpected result can occur. When types and evaluation rules are required, an inline function is safer.

static inline int square(int value) {
    return value * value;
}

Stringification

Placing # before a parameter of a function-like macro converts the supplied tokens to a string.

#define STRINGIFY(value) #value

const char *text = STRINGIFY(hello);

The result is "hello".

When a macro must be expanded before stringification, a helper macro is required.

#define STRINGIFY_DIRECT(value) #value
#define STRINGIFY(value) STRINGIFY_DIRECT(value)

#define VERSION 23

const char *version = STRINGIFY(VERSION);

Token Pasting

## combines two preprocessing tokens into one.

#define DECLARE_VARIABLE(name) int variable_##name

DECLARE_VARIABLE(count);

The expansion is as follows.

int variable_count;

Token pasting can be used for repetitive declarations and code generation, but excessive use can make generated identifiers difficult to trace.

Variadic Macros

A variadic macro uses ... and __VA_ARGS__.

#define LOG(format, ...) \
    fprintf(stderr, format, __VA_ARGS__)

LOG("value: %d\n", value);

C23 provides __VA_OPT__ to handle an empty variadic argument list.

#define LOG(format, ...) \
    fprintf( \
        stderr, \
        format __VA_OPT__(,) __VA_ARGS__ \
    )

LOG("started\n");
LOG("value: %d\n", value);

Conditional Compilation

Conditional compilation includes or excludes portions of source according to preprocessing conditions.

#if defined(_WIN32)
#define PLATFORM_NAME "Windows"
#elif defined(__linux__)
#define PLATFORM_NAME "Linux"
#elif defined(__APPLE__)
#define PLATFORM_NAME "Apple"
#else
#define PLATFORM_NAME "Unknown"
#endif

#ifdef and #ifndef test whether a macro is defined.

#ifdef DEBUG
log_debug_information();
#endif

#ifndef BUFFER_SIZE
#define BUFFER_SIZE 4096
#endif

C23 allows #elifdef and #elifndef.

#if defined(_WIN32)
#define PLATFORM_WINDOWS
#elifdef __linux__
#define PLATFORM_LINUX
#endif

A preprocessing conditional expression does not provide every facility of an ordinary C expression. It uses integer constant expressions and the defined operator available during preprocessing.

#error and #warning

#error produces a diagnostic that causes translation to fail.

#ifndef REQUIRED_FEATURE
#error "REQUIRED_FEATURE must be defined"
#endif

C23 #warning requests a warning diagnostic.

#ifndef OPTIMIZED_BUILD
#warning "Building without optimization"
#endif

#line

#line changes the line number and file name information for subsequent source.

#line 100 "generated.c"

Code generators and preprocessing tools can use it to map diagnostic locations back to original source.

#pragma

#pragma requests implementation-specific behavior.

#pragma STDC FENV_ACCESS ON

The standard defines some STDC pragmas, but many pragmas are compiler-specific extensions.

#pragma once

The handling of an unsupported pragma follows implementation rules. Portable code must consider pragma support and fallback paths.

_Pragma

_Pragma is a unary-operator-like form that represents a pragma using a string literal.

_Pragma("STDC FENV_ACCESS ON")

It has the advantage that a pragma can be generated within a macro.

#define ENABLE_FLOATING_ENVIRONMENT \
    _Pragma("STDC FENV_ACCESS ON")

#embed

C23 #embed includes bytes from an external resource during preprocessing.

static const unsigned char icon_data[] = {
#embed "icon.bin"
};

The file’s data is inserted as array initializer elements. This can be used to include binary resources in an executable, such as embedded firmware data, game and graphics resources, and test data.

How #embed locates a file and which resource paths it supports are also affected by the implementation environment and options.

Predefined Macros

An implementation predefines several macros specified by the standard.

Representative macros include the following.

printf(
    "%s:%d\n",
    __FILE__,
    __LINE__
);

The standard edition can be checked.

#if defined(__STDC_VERSION__) && \
    __STDC_VERSION__ >= 202311L
#define HAS_C23 1
#else
#define HAS_C23 0
#endif

Because __DATE__ and __TIME__ can produce different results for every build, reproducible builds may avoid them or control them through the build system.

Attributes

C23 attributes are standard syntax for attaching additional information to declarations, statements, and other constructs.

[[nodiscard]]
int create_resource(void);

An implementation can issue a diagnostic when the return value is not used.

[[deprecated]]
void legacy_function(void);

This indicates that use of the facility is discouraged.

switch (value) {
case 1:
    process_first();
    [[fallthrough]];

case 2:
    process_second();
    break;
}

Major attributes defined in C23 include the following.

• deprecated
• fallthrough
• maybe_unused
• nodiscard
• noreturn
• reproducible
• unsequenced

An implementation can also provide extension attributes in separate attribute name spaces. Programs can preserve portability by considering the standard rules for handling unknown attributes.

Static Verification

static_assert checks a condition at translation time.

static_assert(sizeof(unsigned int) >= 4);

If the condition is false, a required diagnostic is produced during translation.

It can verify assumptions about structures and binary interfaces.

struct packet_header {
    uint32_t type;
    uint32_t size;
};

static_assert(
    sizeof(struct packet_header) == 8,
    "unexpected packet header size"
);

However, a simple size check alone cannot guarantee every property of structure padding and byte order.

The earlier C11 syntax is _Static_assert.

_Static_assert(
    sizeof(int) >= 2,
    "int is too small"
);

C23 allows static_assert to be used directly.

Complete Example

The following code combines several C syntactic elements and components in one small program.

#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

#define INITIAL_CAPACITY 8

struct integer_list {
    int *values;
    size_t count;
    size_t capacity;
};

static bool integer_list_reserve(
    struct integer_list *list,
    size_t capacity
) {
    if (capacity <= list->capacity) {
        return true;
    }

    int *new_values = realloc(
        list->values,
        capacity * sizeof(*new_values)
    );

    if (new_values == NULL) {
        return false;
    }

    list->values = new_values;
    list->capacity = capacity;
    return true;
}

static bool integer_list_push(
    struct integer_list *list,
    int value
) {
    if (list->count == list->capacity) {
        size_t new_capacity = list->capacity == 0
            ? INITIAL_CAPACITY
            : list->capacity * 2;

        if (!integer_list_reserve(list, new_capacity)) {
            return false;
        }
    }

    list->values[list->count++] = value;
    return true;
}

static void integer_list_destroy(
    struct integer_list *list
) {
    free(list->values);

    *list = (struct integer_list) {
        .values = NULL,
        .count = 0,
        .capacity = 0
    };
}

int main(void) {
    struct integer_list list = { 0 };

    for (int value = 1; value <= 10; ++value) {
        if (!integer_list_push(&list, value)) {
            fprintf(stderr, "memory allocation failed\n");
            integer_list_destroy(&list);
            return EXIT_FAILURE;
        }
    }

    for (size_t index = 0; index < list.count; ++index) {
        printf("%d\n", list.values[index]);
    }

    integer_list_destroy(&list);
    return EXIT_SUCCESS;
}

This program uses the following elements.

• Standard headers and a macro
• A structure
• Pointers
• size_t
• Functions with internal linkage
• Function prototypes and parameters
• Dynamic memory allocation
• sizeof
• Conditional statements and loops
• The conditional operator
• Designated structure initialization
• A compound literal
• Error return values
• Explicit resource release

Each individual syntactic element of C is relatively simple, but the meaning of a program can become complex when types, object lifetimes, conversions, evaluation order, and pointer rules are combined. Writing a correct C program requires understanding not only its syntactic form, but also the type and value of each expression, when each object exists, and which accesses are permitted.^[35]