• c functions
• c syntax with indent like coffeescript or python
• c data types
• c memory management
• array literals in c
• possibly useful features missing in c
• return status and error handling

• c faq

• standard library

  • musl

• c data types

  • stdint.h
  • inttypes.h
• source code of musl

with a single compilation unit, a single file is compiled that includes all necessary other code to build one binary object. the main file may have .h or .c suffix, the latter especially when it contains a main function and not merely declarations for a library. this can be the most simple way for small projects.

the more common way is to compile parts of the application separately into multiple objects and maintain makefiles as well as header files with declarations for each object and then use a linker to connect references between objects. this has benefits like encapsulation and saving time in the development of big projects by only recompiling objects that changed, but introduces significant overhead and may reduce optimization opportunities.

a popular project that uses as single compilation unit is sqlite.

the style of having one file including others reminds of including javascript in html.

• structs

  • it is possible to use offsetof() to get a pointer to the beginning of a structure given only a pointer to a struct field
  • assignment of large structs copies all content automatically, even with nested array types, as long as the memory is declared as being part of the structure itself and not just a pointer
  • to set all struct members to zero '= {0}' can be used on initialization. this can be used to create a variable that can be used to set structs variables after initialization '= my_struct_null'

• functions

  • consider setting output variables only on success
  • function calls are expressions, so they can be used to wrap more complicated syntax into an expression
  • for functions to accept a variable number of arguments, the preferred solution in c is often to define _n suffix variants that take a specific number of arguments. for example, list_3(2, 3, 4)

• preprocessor

  • with #ifndef, files can be created that support macro variables set before they are included, where the macro variables only get defined inside if undefined. this can be used for configuration. the files can be included multiple times with different macro variable values set before
  • it is not usually possible to pass macro names to macros and construct other macro names from them
• string literals are usually signed integers by default. -funsigned-char changes this
• c floor is often slow
• pattern: initialize variable to zero, allocate heap memory, final function cleanup checks if non-zero/allocated and frees if necessary

• terminology for function parameters

  • parameter: formal parameter: the variables in a function declaration/definition. describes what arguments a function can take

  • argument: actual parameter: the values or variables passed during a function call

file_buffer = mmap(0, file_size, PROT_READ, MAP_SHARED, file_descriptor, 0);
md5((unsigned char*)file_buffer, file_size, result);
munmap(file_buffer, file_size);

• allocators like malloc use it internally as a low-level heap memory allocator on linux
• can be used to map files to memory addresses. the file will be read in the operating systems page size blocks. overhead occurs, for example, when addresses outside the currently loaded pages are accessed

general alignment: each type aligns to a multiple of its size, with padding added between members and at the struct’s end to maintain alignment. mixed type cases:

• small before large: placing a uint8_t before an int32_t adds padding after the uint8_t to align the int32_t.
• descending order: ordering from largest to smallest (e.g., double, int32_t, uint8_t) minimizes internal padding.
• uneven alignments: mixing types like int16_t, uint8_t, and float can create padding between members to satisfy each type’s alignment.
• arrays in structs: arrays follow their base type’s alignment, potentially adding padding before the next member if needed.
• end padding: the struct may be padded at the end to ensure its total size aligns with the largest member’s alignment, crucial for arrays of structs.

the biggest slowdown i have experienced when programming in c versus other languages comes from having to be more specific:

• specific with types - each function implementation works only for the exact type combinations it was defined for. functions that process uint32 and uint64 need two full separate definitions, float and uint functions may not be easily macro templated because of low-level details. macro templating with preprocessor syntax needs distracting line-escapes
• distraction by interleaved memory allocation code, as well as thought overhead for ownership and cleanup
• specific in what is done - more low-level options, more possible variation, more performance implications
• more has to be done. for example, declaration, allocation, deallocation, initialization, etc, but this fine-grained control may be worth the cost