Tom's wiki

C

The C programming language. The father of most modern programming languages.

Learn

• The C Programming Language (K&R)
• https://beej.us/guide/bgc
• #todo Modern C by Jens Gustedt
• #todo Deep C Secrets by Peter van der Linden

Notes

#todo Sort out.

• The most common way to build a C program is to compile each source file into an object file and then link them together.
• The char type is always 1 byte.
• Modern C programs use standard types from <stdint.h> instead of int, long, etc.
• Arrays are pointers to the first element. There is no way to calculate the length of an array passed to a function.
• All strings are \0-terminated. This is how strlen() calculates the length.
• Historically, C didn’t have a boolean type: zero meant false and non-zero meant true. Now, <stdbool.h> exists.
• There is a short form to define an array and initialize it with zeroes: int arr[100] = {0};.
• sizeof() returns the size of a type in bytes. It is a compile-time operation.
• Array/pointer equivalence rule: a[b] == *(a+b).
• Out-of-bounds array access results in undefined behavior.
• Pointer arithmetics: ptr++ moves to the next object of the same type.
• void* is a generic pointer that is used for arguments of any type (like interface{} in Go).
• There are two operators to access struct fields: . for structs and -> for struct pointers.
• Local variables are allocated on the stack, manually allocated memory - on the heap.
• int* p1, p2; caveat: unlike p1, p2 is not a pointer.
• There is no zero value concept, uninitialized variables contain garbage.
• There can be multiple declarations, but only one definition.
• A global variable from one file cannot just be used in another file, because there is no global scope, only a file scope. First, it has to be (re)declared with the extern modifier. Functions are extern by default.
• The static modifier is used to limit the visibility of a function to the file in which it is defined. Variables are static by default.
• The name of an array is a synonym for the location of its first element: int a[]; a == &a[0].
• C guarantees that zero (NULL) is never a valid address, so a return value of zero can safely be used as a signal.
• Pointer arithmetics: If two pointers point to members of the same array, then can be compared with ==, !=, >, <, etc.
• size_t is an unsigned integer type returned by the sizeof() operator. %zu is the format specifier for it.
• The header <stddef.h> defines a type ptrdiff_t that is large enough to hold the signed difference of two pointer values.
• Function pointers can be used to achieve polymorphism.
• char s[] = "...": an array of chars (modifiable); char* s = "...": a pointer to a static string (non-modifiable).
• Conventional names for command lines arguments: int argc, char* argv[].
• Any pointer can be cast to void* and back again without loss of information.
• The size of a structure is NOT the sum of the sizes of its members because of memory alignment.
• A struct can have a flexible array member (must be last).
• Returning a pointer to a local variable from a function results in a dangling pointer.
• The standard idiom to traverse a linked list: for (ptr = head; ptr != NULL; ptr = ptr->next).
• typedef does not create a new type, it just adds an alias to the existing type.
• Union is a variable that may hold objects of different types and sizes. The largest type defines the size of the union.
• Assertions: assert(): macro, runtime; static_assert(): since C23, keyword, compile time.
• For a library, the header file is the API: expose as few things as possible and hide implementation details using opaque data types.
• FILE is a wrapper around a file descriptor with internal buffering.
• VLA: generally not recommended, optional since C11.
• wchar_t is a wide (multibyte) char used to represent unicode characters (like rune in Go).
• Use static for variables and functions that should not be visible from other files.
• Use const for pointer function parameters if the function does not modify them.
• Various const tips: https://matt.sh/sytycc
• int foo; vs extern int foo; in file scope: the former is a tentative definition that may act as a definition (implicitly initialized with 0) or as a declaration, the latter is always a declaration.

Best practices

• C99 minimum
• No code in headers
• Include guards in headers
• Minimal use of typedefs
• No macros
• No compiler extensions

Standards

💡 Hint
You can force the compiler to use a specific standard with the -std flag.

Preprocessor

Modifiers

Type qualifiers:

Storage-class specifiers:

Defaults: auto for block scope objects, extern for file scope objects.

Stdlib

https://en.wikipedia.org/wiki/C_standard_library

Implementations:

• glibc: https://www.gnu.org/software/libc
• musl: https://musl.libc.org

Included in the ANSI standard:

Compilers

• GCC: https://gcc.gnu.org
• Clang: https://clang.llvm.org

Tooling

• Formatter: clang-format
• Linter: clang-tidy
• Language server: clangd (includes both clang-format and clang-tidy)
• Code sanitizers: AddressSanitizer, MemorySanitizer, etc

Code style

• Kernel
• Chris Wellons (null program blog)

See also

• https://matt.sh/howto-c
• https://pulsar17.me/2023/03/grappling-with-c
• https://text.causal.agency/003-pleasant-c.txt
• https://drewdevault.com/2016/05/28/Understanding-pointers.html