liveBookmanning.com

What you will learn in Modern C

by Jens Gustedt

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• atomic typeA type is a C specification that determines the representation and permitted values or operations of an entity.
• inline functioninline is a C function specifier that permits a function definition to be suitable for direct integration into callers without changing its semantics.
• referenceAn object pointer is a pointer whose referenced entity is an object rather than a function.
• performance optimizationPerformance optimization is the systematic modification of software or its operating conditions to improve measured execution speed, responsiveness, throughput, or resource efficiency while preserving required behavior.
• identifierAn identifier is a C name assigned to a program entity such as an object, type alias, function, or constant.
• arrayAn array is a C aggregate containing a fixed sequence of items of the same type, accessed by indices.
• volatile qualificationA volatile qualification is a C type qualifier indicating that an object's value may change independently of ordinary program execution and must not be optimized away from accesses.
• encodingEncoding is the transformation of information into a representation defined by a scheme for storage, processing, transmission, or interpretation.
• objectA data object is a C entity that occupies storage for a value.
• threadA thread is an independent sequence of execution within a program that has its own control flow and can execute concurrently or by interleaving with other threads.
• timespec_gettimespec_get is a C standard library function that obtains a calendar time with a struct timespec representation for a specified time base.
• automatic storageAutomatic storage duration is a C storage duration in which an object's lifetime is associated with execution of its defining block, except for variable-length arrays and temporary objects.
• stopping criterionA controlling expression is an expression whose value determines the path taken by a conditional or other control-flow construct.
• signalAn operating-system signal is an asynchronous notification delivered to a process to report an event or request handling.
• signal handlerA signal handler is a function invoked by the C signal-handling mechanism when a specified signal is delivered.
• precisionPrecision is the C-standard property that constrains the number of distinguishable or representable digits and thereby the valid range of a type.
• declarationA declaration is a C construct that specifies the kind of entity an identifier refers to without necessarily defining the entity or providing its value.
• scopeA scope is the region of a C program in which an identifier is visible and can be referred to.
• undefined behaviorUndefined behavior is a C execution condition for which the language standard imposes no requirements on the program's behavior.
• lifetimeObject lifetime is the interval during program execution in which a C object exists and may be accessed according to the language rules.
• integersigned int is a C signed integer type capable of representing both negative and nonnegative integer values.
• escape sequenceAn escape sequence is a C source notation beginning with a backslash that encodes a character or special value.
• callA function call is an expression or statement that invokes a function and supplies any required arguments.
• aliasAn alias is an alternative name by which an entity, command, parameter, or resource can be referred to.
• function-like macroA function-like macro is a C macro defined with parameters that expands preprocessing tokens when invoked with an argument list resembling a function call.
• localeA locale is a set of environment-specific rules governing language, character classification, formatting, and encoding behavior.
• setlocalesetlocale is a C standard library function that queries or changes the locale applicable to specified categories of locale-sensitive operations.
• acquire-release semanticsA release operation is a concurrency operation that publishes preceding effects so that a corresponding acquire can observe them.
• extended character setAn extended character set is a character repertoire that includes characters beyond the C basic character set.
• initializationAn initialization function is a function conventionally responsible for putting a supplied object into a valid initial state.
• multibyte stringA multibyte string is a null-terminated C string whose character sequences may represent extended characters with multiple bytes.
• acquire semanticsAn acquire operation is a concurrency operation that establishes visibility of effects published by a corresponding release.
• numerical overflowArithmetic overflow is the condition in which an arithmetic result is outside the range representable by its type.
• measurementMeasurement is the systematic assessment of a property, behavior, or outcome that produces an observed value, score, or judgment.
• performancePerformance is the measured computational efficiency of a program, often expressed through execution time or resource consumption.
• automatic objectAn automatic variable is a C variable whose storage is created on entry to its enclosing block and released when execution leaves that block.
• macroA define directive is a C preprocessor directive that defines a macro and its replacement text.
• code pointA code point is a numeric value assigned by a character standard to a character concept.
• mbrtowcmbrtowc is a C standard library function that converts one multibyte character to a wide character while tracking conversion state.
• mbsrtowcsmbsrtowcs is a C standard library function that converts a restartable multibyte string to a wide-character string.
• mbstate_tmbstate_t is a C library type that stores the conversion state needed to interpret multibyte character sequences.
• multibyte characterA multibyte character is a sequence of bytes interpreted as one character in an extended character set.
• UnicodeUnicode is an international character standard that assigns code points and properties to a unified repertoire of characters.
• Unicode escapeA Unicode escape sequence is a C escape notation using \u or \U followed by hexadecimal digits to specify a Unicode code point.
• UTF-8UTF-8 is a Unicode Transformation Format that encodes code points as sequences of 8-bit code units.
• wide characterA wide character is a C character representation of type wchar_t intended to encode one character of an extended character set.
• wide character stringA wide character string is a null-terminated array of wchar_t elements representing a sequence of wide characters.
• recursionRecursion is a technique in which a computation is defined or performed through calls or applications that refer to the same computation.
• statisticsStatistics is the discipline and set of methods for collecting, summarizing, analyzing, and interpreting data, including numerical descriptions used to characterize observations and support inference.
• assertionassert is a C standard library macro that evaluates a runtime condition and reports a diagnostic followed by abnormal termination when the condition is false.
• clock cycleA clock cycle is one period of a processor's clock signal used as a unit of execution time.
• instrumentationInstrumentation is the insertion of measurement-related operations into a program or execution environment.
• measurement biasMeasurement bias is systematic distortion introduced by the act or method of observation.
• raw momentA raw moment is the average or aggregate power of observations measured relative to zero.
• relative standard deviationRelative standard deviation is the standard deviation divided by the mean, expressing dispersion relative to the average.
• skewSkew is a statistical measure of the asymmetry or lopsidedness of a distribution.
• standard deviationStandard deviation is a measure of the dispersion of observations around their mean.
• statistical sampleA statistical sample is a finite collection of observations drawn from a phenomenon or population.
• time measurementTime measurement is the determination of the elapsed or processor time associated with program execution.
• asynchronous signal safe functionAn asynchronous signal safe function is a function that may be called from a handler for an asynchronous signal without violating the signal-handling rules.
• sig_atomic_tsig_atomic_t is an integer C type whose object evaluations and assignments are guaranteed to be uninterruptible with respect to signal handling.
• signal.hsignal.h is the C standard header that declares signal-handling functions, constants, and related types.
• signal numberA signal number is an integer identifier representing a particular kind of C signal.
• uninterruptible operationAn uninterruptible operation appears indivisible to a signal handler, either not having started or having completed.
• function declarationA function declaration is a C declaration that specifies a function's name, parameter interface, and return type without necessarily defining its body.
• struct tmstruct tm is the C standard library structure type for decomposed calendar-time components such as seconds, days, months, and years.
• lockingMutual exclusion is a synchronization property ensuring that at most one thread accesses a protected region at a time.
• consistency modelA C memory model is the language-level model that specifies how objects occupy storage and how their locations can be accessed during execution.
• structA struct is a composite data type or structure that groups related fields or values into a single unit.
• floating-point arithmeticA floating-point value is a value represented approximately by a sign, a significand, and a power-of-two exponent.
• bindingA variable is a named C data object whose stored value can change during execution, including when its storage is local to a function invocation.
• in-memory formatAn object representation is the concrete representation of a value in an object's storage, such as memory or persistent storage.
• storage durationStorage duration is the C property that specifies how long an object exists during program execution and how its storage is managed.
• critical regionA critical section is a region of execution that accesses shared state under synchronization so that conflicting concurrent accesses are excluded.
• setjmp/longjmpsetjmp is a C library macro that saves an execution context and returns zero initially or a nonzero value when control later returns through longjmp.
• variadic macroA variadic macro is a C function-like macro whose parameter list accepts a variable number of arguments through an ellipsis.
• literalA literal is a C source notation that directly represents a fixed value.
• functionA function is a named C program unit that can be invoked to perform computation and optionally return a value.
• reallocrealloc is a C standard library function that changes the size of a previously allocated memory block while preserving its existing contents up to the applicable size.
• command-line argumentA command-line argument is a text value supplied to a program when it is invoked.
• restrictrestrict is a C type qualifier for pointer types that declares an intended exclusive access relationship for an object during a computation.
• expressionAn expression is a C syntactic construct that is evaluated to produce a value and may modify program state.
• happens-before relationA happened-before relation is an ordering relation that establishes that one evaluation or event precedes another for purposes of reasoning about concurrent execution.
• function pointer typeA function pointer is a pointer value that designates a function and can be passed to or invoked by other code.
• translation unitA translation unit is the source code produced after preprocessing one C source file together with its included material and presented to the compiler.
• memmovememmove is a C standard library function that copies bytes between memory regions while permitting the regions to overlap.
• type-generic interfaceType-generic programming is a technique for providing one interface that selects or adapts behavior according to the types of its inputs.
• allocated storage durationAllocated storage is a region of C storage obtained dynamically for use in representing objects during execution.
• stateHidden state is execution state that affects program behavior but is not directly represented as an ordinary program value.
• unsigned integerAn unsigned integer type is a C integer type whose representable values are non-negative.
• format stringA format string is a character sequence containing ordinary output text and conversion directives interpreted by a formatted-output function.
• memory allocationDynamic allocation is obtaining and releasing object storage during program execution rather than solely at translation or function-entry time.
• compound literalA compound literal is a C expression consisting of a parenthesized type name followed by an initializer that defines an unnamed object.
• hexadecimal numberA hexadecimal format is a numeric output representation using base-16 digits and, when applicable, a hexadecimal prefix.
• abstract state machineAn abstract state machine is a mathematical model of computation defined by states and transitions independently of a particular hardware implementation.
• side effectA side effect is an observable change to program state caused by evaluating an expression or executing an operation.
• register keywordThe register keyword is a C storage-class specifier that requests register storage and restricts use of the object's address in applicable contexts.
• type-generic macroA type-generic macro interface is a macro-based C interface that selects type-specific operations for its arguments.
• naming standardA naming convention is an established pattern for representing words or semantic information in identifiers.
• data conversionType conversion is the transformation of a C value from one type to another compatible type.
• entry pointAn entry point is a program location at which execution of a function or other callable unit begins.
• narrow typeA narrow type is a C integer or character type whose values undergo integer promotion before arithmetic evaluation.
• fprintffprintf is the C standard library function that writes formatted output to a specified stream.
• loopA for loop is a C iteration construct that repeatedly executes a statement while controlling initialization, continuation, and update expressions.
• read-modify-write operationA read-modify-write operation atomically reads an object, computes or applies a modification, and writes the resulting value as one indivisible operation.
• exitexit is the C standard library function that terminates normal program execution after performing the standard termination processing.
• pure functionA mathematical function is a C library function that computes a numerical or mathematical result.
• jmp_bufjmp_buf is an opaque C library-defined array type that represents a saved execution context for setjmp and longjmp.
• constantA named constant is a constant associated with an explanatory name representing a particular meaning.
• _Generic_Generic is a C11 primary expression that selects one expression from type-associated alternatives based on the type of a controlling expression.
• implementation definedImplementation-defined behavior is C behavior for which an implementation must choose and document one permitted alternative.
• modification orderModification order is the single order of all modifications to a particular atomic object that is consistent with each participating thread's sequenced-before order.
• static storagestatic is a C storage class specifier that gives an object static storage duration and can affect linkage.
• sequential consistencySequential consistency is a memory-consistency model in which all operations on atomic objects appear in one global order consistent with each thread's program order.
• preconditionA precondition is a condition that must hold before a function or operation is invoked.
• variadic argumentsA variadic function is a C function that accepts a variable number of arguments through an ellipsis in its parameter list.
• const-safetyConst-safety is the property of an interface that preserves read-only qualification when accepting or returning pointers to objects.
• snprintfsnprintf is a C standard library function that formats output into a character array subject to a specified size limit and reports the required output length.
• sprintfsprintf is a C standard library function that formats output into a character array without providing a destination-size bound.
• strtoullstrtoull is a C standard library function that converts the initial portion of a string to an unsigned long long value in a specified base and reports where parsing ends.
• stackA stack is a last-in, first-out data structure in which values are added and removed at one end.
• bit operationA bitwise operator is a C operator that independently combines or transforms corresponding bits of integer operands.
• break statementA break statement is a C control-flow statement that immediately terminates the nearest enclosing loop or switch statement.
• C99c99 is a command-line C compiler program commonly available on POSIX systems.
• function call overheadFunction call overhead is the execution cost associated with invoking a function, including possible control-flow transfers, stack handling, and value copying.
• function symbolA function symbol is a linkable binary identifier representing the address or externally resolvable entity of a function.
• inliningInlining is a compiler transformation that replaces a function call with the called function's implementation in the caller's context.
• circular bufferA circular buffer is a bounded FIFO data structure whose storage is treated as wrapping from the end back to the beginning.
• public visibilityVisibility is the property determining where a C identifier can be referred to by name.
• _Noreturn_Noreturn is a C function specifier or attribute indicating that a function does not return to its caller during normal execution.
• incompatible typesIncompatible types are C types that are not permitted to denote the same compatible type for a particular language construct.
• type expressionA type expression is a type specification appearing as an alternative association in a _Generic expression.
• indexingAn index is an integer position used to identify an item in an array.
• valueA value is data that can be evaluated as a C condition, with zero representing false and any nonzero value representing true.
• thread storage durationThread storage duration is a C storage duration in which an object's lifetime is associated with a particular thread of execution.
• cachingA cache is a storage structure containing previously computed values for reuse.
• Euclid's algorithmEuclid's algorithm is an algorithm for computing the greatest common divisor of two integers by repeatedly applying remainder operations.
• Fibonacci sequenceThe Fibonacci sequence is the integer sequence in which each term after the first two is the sum of the preceding two terms.
• multiple recursionMultiple recursion is recursion in which one invocation makes more than one recursive call.
• namespaceAn identifier namespace is a C naming domain in which identifiers are associated with distinct kinds of entities and may have separate collision rules.
• global variableA global variable is a C variable declared outside functions whose scope extends through the remainder of its source file and whose storage normally persists for the program's execution.
• naming policyA naming policy is a consistent set of rules governing how program identifiers are formed and selected.
• naming prefixA naming prefix is a distinctive initial sequence added to identifiers to reduce naming conflicts and indicate an interface or subsystem.
• atomic_flagatomic_flag is a C atomic type that supports indivisible flag operations for concurrency and signal-related contexts.
• prototypeA function prototype is a declaration that specifies a function's parameter types and return type.
• effective typeAn effective type is the C type through which an object is permitted to be accessed under the language's object-access rules.
• const qualifierA constant is a named C entity or value that does not change during program execution.
• basic typeA base type is the type from which a C derived type is formed or the type of the individual items that compose a C array.
• strtoulstrtoul is a C standard library function that converts the initial portion of a string to an unsigned long value in a specified base.
• operatorAn operator is a C symbol or token that specifies an operation on one or more operands.
• missing valueA null pointer is a pointer value that represents no valid object or function address.
• assemblerAssembler is a machine-specific programming language consisting of symbolic representations of processor instructions.
• base pointerA base pointer is a processor register used to identify a stable reference position for a function's stack-resident data.
• control flowControl flow is the order in which execution proceeds among statements and functions in a program.
• hardware registerA hardware register is a small, processor-local storage location that holds a machine value or control information.
• instruction setAn instruction set is the finite collection of operations that a processor can perform on registers, memory, and other machine components.
• machine instructionA machine instruction is a processor-level operation encoded for execution by a particular instruction set.
• machine modelA machine model is an abstract description of the computational components and operations exposed by a computer architecture.
• memoryMain memory is the linearly addressable storage that holds a running program's instructions and data.
• stack pointerA stack pointer is a processor register that identifies the current top of a call's stack storage area.
• two's complementTwo's complement representation encodes negative integers by complementing the corresponding positive representation and adding one, with the high-order bit indicating negativity.
• von Neumann modelThe von Neumann model is a computer architecture model comprising a processing unit, registers, linearly addressable main memory, and a finite instruction set.
• storage classA storage class specifier is a C declaration keyword that specifies an object's storage duration, linkage, or related declaration properties.
• complex floating-point typeA complex number is a number expressible as the sum of a real component and an imaginary component.
• structure parameterA structure parameter is a function parameter whose structure value is passed by value in C.
• hierarchyA nested structure is a structure declaration or member arrangement in which one structure type is declared within or contains another structure type.
• pointer arithmeticPointer arithmetic is the C operation of adding or subtracting an integer offset from a pointer or computing the difference between pointers into the same array.
• errnoerrno is a C standard library macro identifying the thread-local integer error indicator set by library functions.
• array lengthAn array length parameter is a function parameter that conveys the number of elements expected in an array argument.
• header fileA header file is a source file containing declarations and other material intended for inclusion before compilation.
• commentA comment is source text in a C program that the compiler ignores as non-executable documentation.
• sign representationA sign representation is a rule for encoding negative signed values using a sign bit and the remaining representation bits.
• size_tsize_t is an unsigned integer type provided by the C standard library for representing object sizes and related counts.
• bsearchbsearch is a C standard library function that searches a sorted array using a caller-provided comparison function.
• comparison functionA comparison function is a callback that determines the ordering of two values by returning a negative, zero, or positive result.
• function decayFunction decay is the C conversion in which an expression naming a function is evaluated as a pointer to that function, except in contexts that suppress the conversion.
• qsortqsort is a C standard library function that sorts an array using a caller-provided comparison function.
• compilerA compiler is a program that translates source code in a programming language into a form suitable for execution on a target platform.
• portabilityPortability is the property of software being usable across different computing environments with little or no modification.
• do statementA do-while loop is a C iteration construct that executes its dependent statement before testing whether its condition remains true.
• sequenced-before relationThe sequenced-before relation orders evaluations within a thread according to the C program's execution rules.
• synchronizes-with relationA synchronizes-with relation orders evaluations in different threads when a synchronization operation in one thread observes the result of a corresponding operation in another.
• tgmath.htgmath.h is the C standard header that provides type-generic macros for mathematical functions.
• variable-length arrayA variable-length array is a C array whose length is determined at run time and whose lifetime rules differ from those of ordinary automatic objects.
• minimum-bound array parameterA minimum-bound array parameter is a C array-parameter declaration whose static bound promises that the argument points to at least the specified number of elements.
• out-of-bounds array accessOut-of-bounds array access is accessing an array element outside the range of elements belonging to that array.
• memory boundA performance bottleneck is a program component or operation that limits overall execution performance.
• premature optimizationPremature optimization is modifying code for presumed performance gains before establishing that the gains are relevant and necessary.
• static array parameter qualifierA static array parameter is a C array-parameter declaration whose static bound promises that the argument points to at least one element.
• uninitialized objectAn uninitialized object is a C object whose stored value has not been given a valid initial value before it is read or otherwise used.
• variable-length array parameterA variable-length array parameter is a C array-parameter declaration whose element bound is determined from a runtime value.
• character classA character class is a set of characters sharing a property such as being alphabetic, numeric, or whitespace.
• null pointer constantA null pointer constant is an integer constant expression with value zero or such a value converted to void pointer, as permitted by the C standard.
• alignasalignas, also spelled _Alignas, is a C11 alignment specifier that requests a specified alignment for an object or member.
• implicit conversionAn implicit conversion is an automatic C conversion that changes a value from one type to another without an explicit cast.
• time.htime.h is the C standard header that declares facilities for representing, querying, and manipulating calendar and processor time.
• normalizationNormalization is the process of reducing a rational representation so its numerator and denominator have no unnecessary common factors.
• cnd_tcnd_t is the C standard threads type representing a condition variable used for thread waiting and notification.
• externextern is a C declaration specifier that declares an entity defined elsewhere and can be associated with external or internal linkage.
• linkerA linker is a tool that combines translated program components, resolves references, and produces an executable or linkable program image.
• opaque objectAn opaque object is an object whose representation and contents can be accessed only through operations explicitly permitted by its abstraction.
• compiler diagnosticA compiler diagnostic is a message reporting a suspected problem, warning, or other condition found while processing source code.
• calendarCalendar time is a representation of a date and time in units such as years, months, days, minutes, and seconds.
• ctype.hctype.h is the C standard header declaring character classification and character-case conversion functions and macros.
• scalarA scalar is a C value or type representing a single non-aggregate value rather than a collection of components.
• macro parameterA macro parameter is a named placeholder in a function-like macro definition that receives replacement tokens from a macro invocation.
• labelA label is a named position in assembler code that identifies a point to which control can refer or transfer.
• signednessSignedness is the property of an integer type that determines whether its representation and value range include negative values.
• alignmentAlignment is the requirement that an object be stored at an address suitable for its type's access constraints.
• abortabort is the C standard library function that causes abnormal program termination and may suppress some system cleanup processing.
• at_quick_exitat_quick_exit is the C standard library function that registers a function to be called during quick program termination.
• atexitatexit is the C standard library function that registers a function to be called during normal program termination.
• quick_exitquick_exit is the C standard library function that performs expedited program termination while invoking functions registered with at_quick_exit.
• runtime assertionA runtime assertion is a check performed during program execution that verifies a condition expected to hold at that point.
• stringification operatorStringification is the preprocessing technique of converting a macro argument's tokens into a string literal.
• return statementA return statement is a C control-flow statement that ends execution of the current function and optionally supplies a return value.
• byte streamA byte stream is an ordered flow of bytes representing binary data for storage, processing, transmission, or incremental reading without inherent message semantics.
• clockclock is a C standard library function that obtains processor time consumed by the program.
• gmtime_sgmtime_s is an Annex K C library function that converts a time_t value to a broken-down UTC time in a caller-provided object.
• localtime_slocaltime_s is an Annex K C library function that converts a time_t value to a broken-down local time in a caller-provided object.
• mktimemktime is a C standard library function that converts a broken-down local calendar time to a time_t value while normalizing its fields.
• strftimestrftime is a C standard library function that formats a broken-down time into a character string according to date-and-time conversion specifications.
• struct timespecstruct timespec is a C structure type that represents a time interval or timestamp with integral seconds and fractional nanoseconds.
• __TIME____TIME__ is a predefined C macro that expands to a string literal containing the time of compilation.
• time zoneUTC is Coordinated Universal Time, the internationally used reference time scale for civil timekeeping.
• integer wraparoundUnsigned wraparound is the reduction of an out-of-range unsigned arithmetic result into the representable range by modular reduction.
• decimal floating-point constantA decimal floating-point constant is a C floating-point literal written with decimal digits whose effective value may differ from its written mathematical value.
• decimal integer constantA decimal integer constant is a C integer literal written using decimal digits and subject to the language's decimal type-selection rules.
• effective valueAn effective value is the value actually represented by a C floating-point constant after the implementation's rounding or truncation.
• floating-point constantA floating-point constant is a C literal that represents a floating-point value and has type float, double, or long double according to its notation and suffix.
• hexadecimal floating-point constantA hexadecimal floating-point constant is a C floating-point literal written with hexadecimal significand digits and a binary power exponent.
• sign bitA sign bit is the bit in a signed representation that indicates whether the represented value is non-negative or negative.
• signed integer arithmeticSigned integer arithmetic is arithmetic performed on C integer operands whose types represent negative as well as non-negative values.
• condition variableA condition variable is a synchronization object on which threads wait for a predicate involving shared state to become true.
• external linkageExternal linkage is C identifier linkage that allows declarations in different translation units to designate the same object or function.
• internal linkageInternal linkage is C identifier linkage that restricts an entity's correspondence to a single translation unit.
• linkageLinkage is a property of a C identifier that determines whether declarations in different scopes or translation units designate the same entity.
• binary representationA binary representation is the abstract model of the values and operation results of a type on a particular platform.
• typedefA typedef is a C declaration that introduces an alias for an existing type.
• char(n)char is the C integer type used to represent characters and small integer values.
• distance matrixA distance matrix is a matrix whose entry for a pair of points records the distance from the first point to the second.
• conditional logicA conditional statement selects whether and which dependent statement or block executes based on a condition.
• shortest pathA shortest path is a path between two graph nodes whose total distance is minimal among the available paths.
• stringA string is a programming-language value representing an ordered sequence of characters or character units as text.
• string.hstring.h is the C standard library header declaring functions for manipulating character arrays and null-terminated strings.
• strlenstrlen is a C standard library function that returns the number of characters before the null terminator of a string.
• gotogoto is a C control-flow statement that transfers execution to a labeled statement within the same function.
• indeterminate resultAn indeterminate result is an outcome for which the language standard defines the behavior but does not select one completely determined value or ordering.
• initializer-list expressionAn initializer-list expression is an expression in an array or structure initializer list that supplies an initialized element or member value.
• sequence pointA sequence point is a point in C program evaluation at which specified preceding evaluations are complete before subsequent evaluation proceeds.
• sequencingSequencing is the C semantic ordering relationship that constrains when evaluations and their effects occur relative to one another.
• synchronizationSynchronization is the coordination of concurrent execution so that specified operations or events have defined ordering and visibility relationships.
• character classifierA character classifier is a C library function or macro that tests whether a character belongs to a specified character class.
• execution character setThe execution character set is the implementation-defined character set and numeric encoding used when a C program executes.
• numeric character constantA numeric character constant is a C character constant whose character code is written using octal or hexadecimal escape notation.
• tolowertolower is a C character-case conversion function or macro that converts an uppercase alphabetic character to its corresponding lowercase character.
• touppertoupper is a C character-case conversion function or macro that converts a lowercase alphabetic character to its corresponding uppercase character.
• continue statementA continue statement is a C control-flow statement that skips the remainder of the current loop iteration and proceeds with the loop's next control check.
• Heron approximationThe Heron approximation is an iterative numerical method for computing the multiplicative inverse of a number.
• resource cleanupCleanup code is code that releases resources and restores required state when an operation completes or fails.
• address-of operatorThe address-of operator is the C unary operator that produces a pointer to its operand's object or function.
• integer promotionInteger promotion is the C conversion of a narrow integer type to int or another integer type before certain operations such as arithmetic.
• ptrdiff_tptrdiff_t is a signed integer type capable of representing the difference between pointers to elements of the same array.
• data representationA representation is the concrete encoding used to express a value inside a program or in an external file.
• thread localThread-local data is data whose storage is separately associated with each executing thread.
• assignment compatibilityAssignment compatibility is the C property that a value can be assigned to an object of a specified type under the language's permitted conversions.
• comparisonA comparison operator is a C operator that compares values and produces a Boolean result represented by zero or one.
• numeric baseA number base is the radix used to interpret the positional digits of a numeric string.
• void pointerA void pointer is a C pointer value of type void* that can hold the address of an object without retaining its pointed-to type information.
• streamingStreaming is the incremental handling of a sequence of data items, including their processing, transfer, or consumption as they become available.
• __FILE____FILE__ is a predefined C macro that expands to a string literal containing the name of the current source file.
• C programA C program is a computer program expressed in the C programming language.
• thrd_tthrd_t is the C standard threads type that identifies a thread through an implementation-defined opaque representation.
• arithmetic typeAn arithmetic type is a C type representing numeric values, including integer, floating-point, and complex types.
• narrowing conversionA narrowing conversion is a conversion to a type whose representable range or precision cannot preserve all values of the source type.
• void typeThe void type is the C type that represents the absence of a value and cannot directly form an object with a usable stored value.
• opaque typeAn opaque data type is a type whose internal representation or purpose is hidden from the code that manipulates it.
• cnd_broadcastcnd_broadcast is a C11 condition-variable function that wakes all threads waiting on a condition variable.
• cnd_signalcnd_signal is a C11 condition-variable function that wakes one thread waiting on a condition variable.
• cnd_timedwaitcnd_timedwait is a C standard threads function that atomically releases a mutex while waiting on a condition variable until notification or an absolute timeout, then reacquires the mutex.
• cnd_waitcnd_wait is a C standard threads function that atomically releases a mutex while waiting on a condition variable and reacquires the mutex before returning.
• calloccalloc is a C standard library function that allocates storage for an array of elements and initializes all allocated bits to zero.
• integer constant expressionAn integer constant expression is a C expression whose value is an integer constant determined according to the language's constant-expression rules.
• va_argva_arg is a C standard library macro that retrieves the next argument from a va_list using a specified type.
• va_listva_list is the C standard library type used to represent the state of traversal through a variable argument list.
• va_startva_start is a C standard library macro that initializes a va_list for accessing a function's variable arguments.
• vfprintfvfprintf is the C standard library function that writes formatted output to a stream using a va_list of arguments.
• incrementIncrement is the operation of increasing a numeric C object or value by one.
• union typeA union is a C type whose members share the same memory location, so different members overlay one another.
• fclosefclose is the C standard library function that closes a stream and flushes its buffered output.
• fflushfflush is the C standard library function that flushes buffered output for a stream without necessarily closing it.
• read-only objectA read-only object is an object that cannot be modified through the applicable C access or type qualification.
• binary dataBinary data is data represented as uninterpreted byte sequences rather than text characters.
• freadfread is the C standard library function that reads a specified number of fixed-size items from a stream into memory.
• fwritefwrite is the C standard library function that writes a specified number of fixed-size items from memory to a stream.
• file scopeFile scope is the C scope of an identifier declared outside any function or block and extending to the end of the source file.
• predeclared identifierA predeclared identifier is an identifier whose declaration is supplied by the language or its standard library rather than written at its point of use.
• bit shiftingA shift operation is a C bitwise operation that moves the bits of an integer representation left or right by a specified operand.
• critical dataCritical data is shared program data whose concurrent access must be synchronized to avoid inconsistent or conflicting updates.
• freefree is a C standard library function that releases dynamically allocated storage previously obtained from an allocation function.
• mallocmalloc is the C standard library function that allocates a specified number of bytes of storage and returns a pointer to the storage or a null pointer on failure.
• SIZE_MAXSIZE_MAX is a C standard library macro that expands to the maximum value representable by size_t.
• booleanbool is the C standard boolean type whose values represent false or true.
• imperative programmingImperative programming is a programming paradigm in which programs specify operations and commands that change computational state to complete tasks.
• C standard libraryThe C standard library is the standardized collection of library functions, macros, and types provided for C programs.
• call_oncecall_once is a C threading function that invokes a specified function exactly once for a given once_flag, synchronizing concurrent callers until that invocation completes.
• bit patternA bit pattern is an interpretation of a value as an arrangement of binary digits.
• macro retentionMacro retention is the C preprocessing rule that leaves a function-like macro name unexpanded when it is not followed by parentheses.
• macro argumentA macro argument is a preprocessing token sequence supplied in a function-like macro call and substituted for a corresponding macro parameter.
• preprocessorA preprocessor is a source-processing component or stage that transforms input, often handling directives or expansions, before primary processing.
• textual substitutionTextual replacement is the preprocessing technique of substituting replacement tokens for macro names and parameters without first interpreting them as C expressions or statements.
• evaluation orderEvaluation order is the sequence in which a C expression's operands and subexpressions are computed.
• case statementA switch statement is a C selection construct that chooses among multiple execution paths based on the value of an expression.
• type aliasA type alias is an alternative name for an existing C type that does not create a distinct type.
• array parameterAn array parameter is a function parameter declared with array syntax whose array type is adjusted for parameter passing and whose argument is passed as a pointer to the array's first element.
• perrorperror is a C standard library function that writes a diagnostic message describing the error indicated by errno.
• aggregate data typeAn aggregate data type is a C type that groups multiple component objects, such as an array, structure, or union.
• arrow operatorThe arrow operator is the C operator that accesses a structure or union member through a pointer to that aggregate.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.