Snacks - modernc

Modern C: Basic values and data

2026-09-27T00:00:00+00:00

Here is a detailed breakdown of the most important concepts and key takeaways from Chapter 5: Basic values and data in Jens Gustedt’s Modern C: A Guide to the C23 Standard.

1. The Abstract State Machine (Section 5.1)

Value-centric thinking: C programs primarily reason about abstract mathematical values rather than concrete machine representations. All basic C values are either numbers or translate directly to numbers (e.g., characters, truth values, array positions).
Types determine behavior: Every value has a statically determined type that dictates allowable operations, their results, and optimization opportunities.
The “As-if” Rule: Compilers execute programs as if strictly following the abstract state machine. The compiler is permitted to reorder or optimize instructions freely as long as observable behavior (e.g., stored state in addressable memory or I/O calls like printf) remains identical.

2. Basic Types (Section 5.2)

Four Base Classes: Base types belong to four fundamental classes: unsigned integers, signed integers, real floating-point numbers, and complex floating-point numbers.
Integer Promotion for Narrow Types: Narrow integer types (bool, char, signed char, unsigned char, short, unsigned short) cannot undergo arithmetic directly; they are automatically promoted to signed int prior to arithmetic calculations.
Type Choice Best Practices:
- Use size_t for object sizes, cardinalities, array indices, and ordinal numbers.
- Use unsigned for small non-negative quantities.
- Use signed for small quantities that require negative values, and ptrdiff_t for signed pointer or index differences.
- Use double for general floating-point calculations and double complex for complex numbers.

3. Specifying Values & Literals (Section 5.3)

Numerical Literals are Positive: Literal values are strictly non-negative. A minus sign in front of a literal (e.g., -42) is a unary negation operator applied to a positive value, not part of the literal syntax itself.
Decimal Integer Literals: Decimal literals default to the first signed integer type (int, long, long long) into which the value fits.
C23 Literals & Suffixes:
- Supports binary literals starting with 0b or 0B (e.g., 0b1010).
- Uses exact suffixes to force types: u/U for unsigned, l/L for long, ll/LL for long long, and C23’s wb/WB for bit-precise _BitInt(N) literals.
- Floating-point constants default to double unless given an f/F (float) or l/L (long double) suffix.
Complex Unit I: Includes the standard macro I (from <complex.h>) representing the imaginary unit \(\sqrt{-1}\).

4. Implicit Conversions (Section 5.4)

Avoid Narrowing Conversions: Converting a value to a narrower type can silently lose information or trigger implementation-defined behavior.
Dangers of Mixed Signedness: Operations combining signed and unsigned values force conversion to unsigned types. For example, the comparison -1 < 0U evaluates to false because -1 is converted to UINT_MAX.
Type Consistency: Design types across expressions so that implicit conversions remain completely harmless and predictable.

5. Initializers (Section 5.5)

Initialize Everything: All variables must be initialized upon definition to keep the abstract state machine in a valid, deterministic state.
C23 Universal Default Initializer {}: The empty initializer {} is valid for all object types (including aggregate types and variable-length arrays), zeroing out all memory/fields.
Designated Initializers: Aggregate structures and arrays should use designated initializers (e.g., = 1 or .member = val) for explicit and maintenance-safe initialization.

6. Named Constants (Section 5.6)

Distinguish Read-Only vs. Constants: const-qualified variables define read-only objects in memory, not true compile-time constants.
Enumerations (enum): Modern enumerations provide typed integer constants. C23 introduces fixed underlying type syntax for enumerations (e.g., enum code : unsigned char).
constexpr in C23: Introduces true compile-time constant objects that are checked at compile time to ensure the initializer fits the declared type without value alteration.

7. Binary Representations (Section 5.7)

Unsigned Integers: Represented via modular arithmetic modulo \(2^p\) (where \(p\) is precision). Unsigned integer arithmetic is strictly well-defined and safely wraps around on overflow.
Signed Integers & Two’s Complement: C23 strictly standardizes two’s complement signed integer representation. Overflow in signed arithmetic is undefined behavior and must be avoided.
Bit Manipulation & Shifts: Unsigned types should always be used for bitwise set operations (&, |, ^, ~) and shift operations (<<, >>).
Fixed-Width & Bit-Precise Integers:
- Exact-width integers (int32_t, uint64_t) from <stdint.h> provide guaranteed bit widths.
- C23 introduces bit-precise integers _BitInt(N) and unsigned _BitInt(N) for arbitrary bit widths.
Floating-Point Realities: Floating-point operations represent real number approximations. They are non-associative, non-commutative, and must never be checked for exact equality (==).

Modern C: Expressing computations

2026-09-27T00:00:00+00:00

Here is a detailed breakdown of the key takeaways and fundamental concepts from Chapter 4: Expressing computations in Jens Gustedt’s Modern C: A Guide to the C23 Standard.

1. Operands and Operators (Section 4.1)

Value vs. Object distinction: In C computations, operators (e.g., +, !=) act upon operands (values or objects). A value is a mathematical quantity, while an object is a named memory location holding a value.
Types of Operators: The C standard distinguishes three operator categories: value operators (compute new values), object operators (modify or inspect stored objects), and type operators (sizeof, alignof, offsetof).
Bounded Non-Negative Integers: The fundamental unsigned type size_t represents non-negative quantities up to a platform-defined upper bound SIZE_MAX.

2. Arithmetic and Modular Rules (Section 4.2)

Unsigned Arithmetic is Always Well-Defined: Unsigned integer operations (+, -, *) never generate undefined behavior on their own. As long as the mathematical result fits in [0, SIZE_MAX], the result is exact.
Modular Wrap-Around: Arithmetic on size_t implicitly operates modulo \(\text{SIZE_MAX} + 1\). When an operation overflows, it safely wraps around (e.g., SIZE_MAX + 1 wraps to 0, and 0 - 1 evaluates to SIZE_MAX).
Integer Division and Remainder:
- For unsigned integers, division / (quotient) and remainder % satisfy: \(\text{a} == (\text{a} / \text{b}) * \text{b} + (\text{a} % \text{b})\).
- Both / and % can never overflow, and their outputs are always smaller than or equal to the inputs.
- Division by Zero is strictly forbidden and results in runtime failure.

3. Operators That Modify Objects & Side Effects (Section 4.3)

Assignment Operators: In assignments (a = 42 or +=, -=, *=, /=, %=), the left side must be an addressable object (lvalue), and the right side is a value (rvalue).
Prefix vs. Postfix Modifications:
- Prefix (++a, --a) modifies the object first and yields the new value to the surrounding expression.
- Postfix (a++, a--) modifies the object but yields the original value prior to modification.
Golden Rules for Clean Code:
- “Side effects in value expressions are evil.” Avoid embedding variable modifications inside complex arithmetic.
- “Never modify more than one object in a single statement.” Combining multiple object modifications in one statement obscures control flow and causes bugs.

4. Boolean Context: Comparisons & Logic (Section 4.4)

Truth Values as Arithmetic Integers:
- Comparison (==, !=, <, >, <=, >=) and logic (!, &&, ||) operators strictly return false (0) or true (1).
- Because false and true are numeric (0 and 1), these boolean results can be directly used as arithmetic terms or array indices.
Short-Circuit Evaluation:
- Logical AND (&&) and logical OR (||) evaluate left-to-right and skip evaluation of the second operand if the first operand fully determines the result.
- For instance, if (b != 0 && (a / b > 1)) safely avoids division by zero because (a / b) is evaluated only when b != 0 is true.

5. The Ternary Operator (Section 4.5)

Conditional Expressions: The ternary operator cond ? A : B evaluates cond first, then evaluates only one of the two branches (A or B) based on whether cond is true or false.
Unlike an if statement, the ternary operator is an expression that yields a value, making it suitable for clean return statements or inline initializations (e.g., return (a < b) ? a : b;).

6. Evaluation Order and Sequencing (Section 4.6)

Sequenced vs. Unsequenced Operators:
- Only four operators strictly sequence their operands from left to right: &&, ||, ?:, and the comma operator ,.
- Most operators do not sequence their operands. In f(a) + g(b), the compiler may evaluate f(a) or g(b) in any arbitrary order.
Function Arguments are Unsequenced: Function argument lists do not guarantee an evaluation order (e.g., in printf("%g %g", f(a), f(b)), either function may run first).
Banning Side Effects in Function Expressions: Because operand evaluation order is non-deterministic across compilers, function calls placed within expressions must never rely on side effects.
The Comma Operator Trap: Avoid using the comma operator , in value expressions. For example, A[i, j] is not a 2D matrix index in C; it evaluates i, discards it, and indexes A[j].