https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Return to 21st Century C, 21st Century C Glossary

Index

Symbols

1. (octothorp), The Preprocessor

1. define, OpenMP

1. endif, Header Guards

1. if 0, Header Guards

1. ifdef, Header Guards

1. ifndef, Header Guards

1. include, Which Way to the Library?

1. pragma, OpenMP

1. pragma once, Header Guards

$*, Setting Variables

$<, Setting Variables

$@, Setting Variables

–pedantic flag, Externally Linked Variables in Header Files

-g flag, Using a Debugger

-liberty flag, Making String Handling Less Painful with asprintf

. (dot) (see source shell command)

_Bool type, The char const

• Issue

_Exit function, goto Considered

_Generic keyword, _Generic

_POSIX_C_SOURCE macro, Test Macros

_Pragma, OpenMP

_Thread_local keyword, Persistent State Variables, Thread Local

_WINDOWS macro, Test Macros

__attribute__ , Declare Your Function as printf-Style

__MACOSX__ macro, Test Macros

__STDC_HOSTED__ macro, Test Macros

__STDC_IEC_559__ macro, Test Macros

__STDC_NO_ATOMICS__ macro, Test Macros

__STDC_NO_COMPLEX__ macro, Test Macros

__STDC_NO_THREADS__ macro, Test Macros

__STDC_NO_VLA__ macro, Test Macros

__STDC_VERSION__ macro, Test Macros

__VA_ARGS__ keyword, Variadic Macros

aliases vs. copies, Pointers Without malloc

alignment, All the Pointer Arithmetic You Need to Know, Glossary

American National Standards Institute (ANSI), Standards: So Many to Choose From

ANSI C89 standard, Standards: So Many to Choose From

arguments, in macros, The Preprocessor

arrayscreating, Basic types can be aggregated into arrays and structs

designated initializers, Designated Initializer]]s

initialization via compound literals, Initialization via Compound Literals

initializing with zeros, Initialize Arrays and Structs with Zeros

memory management and, Structures Get Copied, Arrays Get Aliased

multidimensional, All the Pointer Arithmetic You Need to Know

notating, All the Pointer Arithmetic You Need to Know

setting size at runtime, Set Array Size at Runtime

ASCII (American Standard Code for Information Interchange), Unicode, Glossary

asprintf functionconstant string, Constant Strings

extending strings with, Extending Strings with asprintf

sensitive information and, Security

string allocation with, Making String Handling Less Painful with asprintf

atof function, Safely Parse Strings to Numbers

atoi function, Safely Parse Strings to Numbers

atomic structs, Atomic structs

atomic variables, Shared Resources, C atoms

atoms, Atoms

at_exit function, goto Considered

at_quick_exit function, goto Considered

autocasting, Cast Less

Autoconf, macro generation by, Test Macros

Automake, conditional subdirectory for, The Conditional Subdirectory for Automake(see also Libtool)

automatic allocation, Glossary

automatic memory management, Automatic, Static, and Manual Memory

Autotoolscontingency hooks in, The Conditional Subdirectory for Automake

Distutils, Distutils Backed with Autotools

interfacing with, Linking, The Conditional Subdirectory for Automake

packaging withbenefits of, Packaging Your Code with Autotools

configure.ac shell script, The configure Script

content variables, Content variables

example run, An Autotools Demo

flowchart for, An Autotools Demo

form variables, Form variables

makefile bits, Adding makefile bits

testing, Adding testing

using libraries from source with, Using Libraries from Source

backtraces, Using a Debugger, A Debugging Detective Story, Using Valgrind to Check for Errors

basic environment setupcompiling via here documentbenefits of, Here Documents

compilation pattern, Compiling C Programs via Here Document

compiling from stdin, Compiling from stdin

including header files, Include Header Files from the Command Line

unified headers, The Unified Header

compiling with WindowsPOSIX for Windows, POSIX for Windows

with POSIX, Compiling C with POSIX

without POSIX, Compiling C Without POSIX

librariescompiler flags, A Few of My Favorite Flags

compiler warnings, A Few of My Favorite Flags

generating shared, The Rules

locating, Paths

paths, Paths

private root directory for, Using Libraries from Source (Even if Your Sysadmin Doesn't Want You To)

runtime linking, Runtime Linking

using, Which Way to the Library?

using from source, Using Libraries from Source

makefilesbenefits of, Using Makefiles

built-in variables, Setting Variables

environment variables, Setting Variables

rules for, The Rules

setting variables, Setting Variables

overview of, Set Yourself Up for Easy Compilation

package manager, Use a Package Manager

Basic Linear Algebra Subprograms (BLAS) library, Paths

basic regular expressions (BREs), Parsing Regular Expressions

Benford's law, Glossary

blank tokens, A Pæan to strtok

block scope variables, Linkage with static and extern

blocking, Shared Resources

blocks, Even functions have to be declared or defined

Boolean arguments, The char const

• Issue, Glossary

Bourne shell, Setting Variables

BSD (Berkeley Software Distribution), The POSIX Standard, Glossary

BSD License, The POSIX Standard

C languagebasic packages for development, Use a Package Manager

Boolean arguments and, The char const

• Issue

comparing unsigned integers, Comparing Unsigned Integers

concurrent C code (see parallel threads)

const keywordas type qualifier, The const Keyword

char const** issue, The char const

• Issue

depth of, Depth

noun-adjective form of, Noun-Adjective Form

tension created by, Tension

declarations in, Let Declarations Flow

double vs. float, Deprecate Float

easier text handling in (see text handling)

enums and strings, Enums and Strings

explicitly returning from main, Don't Bother Explicitly Returning from main

externally linked variables in header files, Externally Linked Variables in Header Files

goto function, goto Considered

inessential concepts in, Inessential C Syntax that Textbooks Spend a Lot of Time Covering

linkage with static and extern, Linkage with static and extern

macros inarguments and, The Preprocessor

basic principle, Cultivate Robust and Flourishing Macros

commenting out code, Header Guards

commonly defined, Test Macros

cultivating robust, Cultivate Robust and Flourishing Macros

debuging, Cultivate Robust and Flourishing Macros

do-while loops, Cultivate Robust and Flourishing Macros

header guards, Header Guards

preprocessor tricks, The Preprocessor

syntax rules, Cultivate Robust and Flourishing Macros

test macros, Test Macros

text substitutions with, Cultivate Robust and Flourishing Macros

types of, Cultivate Robust and Flourishing Macros

object-oriented programming in (see object-oriented programming (OOP))

parsing strings to numbers, Safely Parse Strings to Numbers

restrict vs. inline keywords, Noun-Adjective Form

setting array size at runtime, Set Array Size at Runtime

switch function, switch

syntax for variables, Setting Variables

tutorialfunctions and expressions, The scoping rules for C are very simple

language structure, The Structure

pointers, Pointers

variable declarations, Variable Declarations

type-casting syntax in, Cast Less

useful concepts in, Important C Syntax that Textbooks Often Do Not Cover

UTF encoding for, The Encoding for C Code

void pointer in malloc, Cast Less

while keyword, Labels, gotos, switches, and breaks

C standardsANSI C89, Standards: So Many to Choose From

ISO C11, Standards: So Many to Choose From

ISO C99, Standards: So Many to Choose From

K & R (ca. 1978), Standards: So Many to Choose From

C threads, C atoms

C11 standard, Standards: So Many to Choose From

C99 standard, Standards: So Many to Choose From

call graphs, Doxygen, Glossary

call stack, Using a Debugger

callback function, Functions with Generic Inputs, Glossary

casting, Cast Less

char const

• , The char const ** Issue

check_name function, The char const

• Issue

Church, Alonso, Extending Structures and Dictionaries

commit objects, Git's Objects

compilationbasic process, C requires a compilation step, which consists of running a single command

compiler flags, A Few of My Favorite Flags, Dynamic Loading, Linking

librariescompiler warnings, A Few of My Favorite Flags

generating shared, The Rules

locating, Paths

paths, Paths

private root directory for, Using Libraries from Source (Even if Your Sysadmin Doesn't Want You To)

runtime linking, Runtime Linking

using, Which Way to the Library?

using from source, Using Libraries from Source

linkage advice in, Linkage with static and extern

makefilesbenefits of, Using Makefiles

built-in variables, Setting Variables

rules for, The Rules

setting variables, Setting Variables

Python example, Compiling and Linking

setup foroverview of, Set Yourself Up for Easy Compilation

package managers/packages, Use a Package Manager

via here documentbenefits of, Here Documents

compilation pattern, Compiling C Programs via Here Document

compiling via stdin, Compiling from stdin

including header files, Include Header Files from the Command Line

unified headers, The Unified Header

with Windowsusing POSIX, Compiling C with Windows

without POSIX, Compiling C Without POSIX

compiler flags, Linking

complex numbers, Standards: So Many to Choose From, Overload

compound data types, Reporting Errors

compound literals, Compound Literals

concurrent programming (see parallel threads)

conditional subdirectories, The Conditional Subdirectory for Automake

configure.ac shell script, The configure Script

const keywordas type qualifier, The const Keyword

char const** issue, The char const

• Issue

depth of, Depth

noun-adjective form of, Noun-Adjective Form

tension created by, Tension

constant strings, Constant Strings

content variables, Content variables

controlling expression, _Generic

copy command, Pointers Without malloc

copyright laws, The POSIX Standard

critical regions, The Ingredients, Shared Resources, Atomic structs

cURL library, libxml and cURL

CWEB documentation system, Literate Code with CWEB

Cygwin, POSIX for Windows, Compiling C Without POSIX

data structuresbridging across languages, Smuggling Data Structures Across the Border

generic, Generic Structures

memory management and, Structures Get Copied, Arrays Get Aliased

non-public, Smuggling Data Structures Across the Border

debuging/testingcompiler flag for, Using a Debugger

of Autotools packaging, Adding testing

profiling, Print Your Structures

unit testingtest coverage, Coverage

test harnesses for, Unit Testing

using programs as libraries, Using a Program as a Library

using a debuggerchoices of, Using a Debugger

common debugger commands, A Debugging Detective Story

example of, A Debugging Detective Story

GDB variables, GDB Variables

importance of, Using a Debugger

printing structures from, Print Your Structures

text editor for, Using a Debugger

using Valgrind, Using Valgrind to Check for Errors

decimal points, Deprecate Float

declarations, Let Declarations Flow, Noun-Adjective Form, Variable Declarations

deep copy, Pointers Without malloc, Structures Get Copied, Arrays Get Aliased, Glossary

designated initializers, Structures Get Copied, Arrays Get Aliased, Deprecate Float, Better Structures, Designated Initializer]]s, C, with fewer seams

dictionariesextending, Extending Structures and Dictionaries

implementing, Implementing a Dictionary

diff command, Changes via diff

distributed revision control systems, Version Control

Distutils, Distutils Backed with Autotools

dlopen function, Dynamic Loading

dlsym function, Dynamic Loading

do-while loops, Cultivate Robust and Flourishing Macros

documentationimportance of, Interweaving Documentation

using CWEB, Literate Code with CWEB

using Doxygen, Doxygen

Doxygen, Doxygen

dynamic loading, Dynamic Loading

echo command, Test for Files

egg replacer recipe, Functions in Your Structs

enumeration, Enums and Strings

enums, Enums and Strings

environment variables, Setting Variables, Replacing Shell Commands with Their Outputs, Glossary

erf function, Which Way to the Library?

error checkingapproach to, Error Checking

indication return, How Should the Error Indication Be Returned?, Reporting Errors

user's context, The Context in Which the User is Working

user's involvement, What is the User's Involvement in the Error?

exit function, goto Considered

expansions, Replacing Shell Commands with Their Outputs, Cultivate Robust and Flourishing Macros

expressions, Most of what a C program actually does is evaluate expressions

extended regular expressions (EREs), Parsing Regular Expressions

extensibility, Extending Structures and Dictionaries

Extensible Markup Language (XML), libxml and cURL

extern keyword, Linkage with static and extern, Externally Linked Variables in Header Files

external linkage, Linkage with static and extern

external pointers, Smuggling Data Structures Across the Border, Glossary

fall-through, switch

fc command, fc

filesheader files, There's a preprocessor

operating on sets of, Use the Shell's for Loops to Operate on a Set of Files

retrieving text files, Dynamic Loading

scope variables for, Linkage with static and extern

shared object files, Dynamic Loading

testing for, Test for Files

version control of, Version Control

flagscompiler, A Few of My Favorite Flags, Dynamic Loading

linker, The Rules

float function, Deprecate Float

floating-point math, Deprecate Float, Safely Parse Strings to Numbers, Glossary

for loops, Use the Shell's for Loops to Operate on a Set of Files

foreach loops, Foreach

form variables, Form variables

framesdebuging with, A Debugging Detective Story

definition of, Glossary

generating, Using a Debugger

variable handling in, Automatic, Static, and Manual Memory

free function, Vectorize a Function

Friendly Interactive shell (fish), The Shell

functionscallback functions, Functions with Generic Inputs

compound literal values and, Compound Literals

declaring, Linkage with static and extern, Even functions have to be declared or defined

evaluation of, Functions are evaluated using copies of the inputs

hash functions, The hash function

retrieving/using, Dynamic Loading

returning multiple items from, Return Multiple Items from a Function

static keyword and, Linkage with static and extern

structured inputs for, Better Structures

type-generic, _Generic

variadic, Flexible Function Inputs

vectorized, Vectorize a Function

GDB (GNU Debugger)common commands in, A Debugging Detective Story

example run of, A Debugging Detective Story

printing elements from, A Debugging Detective Story

usability of, Using a Debugger

variables for, GDB Variables

getenv, Setting Variables

getopt function, switch

GetProcAddress function, Dynamic Loading

Gettext, The Sample Code

Gitadding elements to list of changes, Git's Objects

amending commits, Git's Objects

central repository, Remote Repositories

changes via diff command, Changes via diff

cloning a repository, Git's Objects

commit messages, Git's Objects

commit objects, Git's Objects

commits in, Git's Objects

creating a repository, Git's Objects

git diff command, Git's Objects

git fetch command, Remote Repositories

git log command, Git's Objects

git push origin master command, Remote Repositories

git reflog command, Git's Objects

graphical interfaces for, Trees and Their Branches

HEADS in, Git's Objects

index in, Git's Objects

merging changes in, Merging

rebase command, The Rebase

remote repositories, Remote Repositories

snapshots, Git's Objects

stash object, The Stash

trees and branches in, Trees and Their Branches

GLibgmodules, The Limits of Dynamic Loading

samples of, GLib

global variables, Glossary

glyphs, Glossary

GNU Autoconf macro archive, More Bits of Shell

GNU C, The POSIX Standard

GNU C library, manual for, Using Libraries from Source (Even if Your Sysadmin Doesn't Want You To)

GNU Gettext, The Sample Code

GNU Libiberty library, Making String Handling Less Painful with asprintf

GNU Public License (GPL), The POSIX Standard

GNU Readline library, Dynamic Loading

GNU Scientific Library (GSL), Paths, Using Libraries from Source, Pointers Without malloc, All the Pointer Arithmetic You Need to Know, The GNU Scientific Library

GNU Screen, Test for Files

go-to-the-exit functions, goto Considered

goto function, goto Considered

Graphviz, Doxygen

hash functions, The hash function

headersexternally linked variables in, Externally Linked Variables in Header Files

header files, There's a preprocessor

header guards in macros, Header Guards

including header files, Include Header Files from the Command Line

public, The Unified Header

unified, The Unified Header

heap, definition of, Glossary

Hello, World script, An Autotools Demo

here documentscompilation viabenefits of, Here Documents

compilation pattern, Compiling C Programs via Here Document

compiling from stdin, Compiling from stdin

including header files, Include Header Files from the Command Line

unified headers, The Unified Header

iconv function, Unicode Libraries

if statements, Test for Files

include guards, Header Guards

INFINITY, Safely Parse Strings to Numbers, Test Macros

inline keyword, Noun-Adjective Form

Institute of Electrical and Electronics Engineers (IEEE), The POSIX Standard

integers, signed vs. unsigned, Comparing Unsigned Integers

integration tests, Unit Testing, Glossary

interfacesdynamic loading and, Dynamic Loading

process of writingbridging data structures, Smuggling Data Structures Across the Border

linking, Linking

to be read by nonnatives, Writing to Be Read by Nonnatives

using dlopen/dlsym, The Process

wrapper function, The Wrapper Function

Python exampleAutomake conditional subdirectory, The Conditional Subdirectory for Automake

compiling/linking, Compiling and Linking

controlling package production, Distutils Backed with Autotools

overview of, Python Host

INTERIX, POSIX for Windows

internal linkage, Linkage with static and extern

International Organization for Standardization (ISO), Standards: So Many to Choose From

internet protocols, libxml and cURL

interoperability, Packaging Your Project

ISO C11 standard, Standards: So Many to Choose From

ISO C99 standard, Standards: So Many to Choose From

ISO/IEC 8859 format, Unicode

K & R standard, Standards: So Many to Choose From

Kernighan, Brian, Standards: So Many to Choose From

keyboarding skills, Literate Code with CWEB

lambda calculus, Extending Structures and Dictionaries

Lesser GPL (LGPL), The POSIX Standard

libiconv function, Unicode Libraries

librariescommonly used C libraries, Use a Package Manager

compiler flags, A Few of My Favorite Flags

compiler warnings, A Few of My Favorite Flags

cURL, libxml and cURL

definition of, Glossary

distribution licenses, The POSIX Standard

dynamic loading of, Dynamic Loading

generating shared, The Rules

GLib, GLib

GNU C, Using Libraries from Source (Even if Your Sysadmin Doesn't Want You To)

GNU Scientific Library (GSL), The GNU Scientific Library

improvements in, Libraries

libxml, libxml and cURL

locating, Paths

paths, Paths

POSIXgigantic data sets and mmap, Using mmap for Gigantic Data Sets

parsing regular expressions with, POSIX

private root directory for, Using Libraries from Source (Even if Your Sysadmin Doesn't Want You To)

runtime linking, Runtime Linking

standard, There's a standard library, and it's part of your operating system

static vs. shared, Runtime Linking

Structured Query Language (SQL), SQLite

typical format for, Object-Oriented Programming in C

using, Which Way to the Library?

using from source, Using Libraries from Source

Libtool, The Rules, Packaging Your Code with Autotools, Adding testing(see also Autoconf; Automake)

Libxmltagged trees in, libxml and cURL

UTF-8 encoding in, Unicode Libraries

licenses, The POSIX Standard

linker flags, The Rules

linking, Linking, Compiling and Linking, Linkage with static and extern

list command, A Debugging Detective Story

listsmultiple, Multiple Lists

returning multiple values with, Return Multiple Items from a Function

safely terminated, Safely Terminated Lists

vs. block-of-memory, Extending Structures and Dictionaries

literate programming, Literate Code with CWEB

LLDB Debuggercommon commands in, A Debugging Detective Story

popularity of, Using a Debugger

printing structures from, Print Your Structures

sample run of, A Debugging Detective Story

LoadLibrary function, Dynamic Loading

long double function, Deprecate Float

macros# (octothorps) and, The Preprocessor

arguments and, The Preprocessor

basic principle of, Cultivate Robust and Flourishing Macros

commenting out code, Header Guards

commonly defined, Test Macros

cultivating robust, Cultivate Robust and Flourishing Macros

debuging, Cultivate Robust and Flourishing Macros

definition of, Glossary

do-while loops in, Cultivate Robust and Flourishing Macros

header guards, Header Guards

preprocessor tricks, The Preprocessor

SQL query, The Queries

syntax rules, Cultivate Robust and Flourishing Macros

test macros, Test Macros

text substitutions with, Cultivate Robust and Flourishing Macros

types of, Cultivate Robust and Flourishing Macros

variable-length arguments, Variadic Macros

main function, Using a Debugger, Don't Bother Explicitly Returning from main, The main function is special

makefilesbenefits of, Using Makefiles

built-in variables, Setting Variables

environment variables, Setting Variables

Makefile.amcontent variables, Content variables

form variables, Form variables

makefile bits, Adding makefile bits

rules for, The Rules

setting variables, Setting Variables

vs. shell scripts for packaging, Makefiles vs. Shell Scripts

mallocavoiding bugs related to, malloc and Memory-Twiddling

location of memory allocated via, Automatic, Static, and Manual Memory

reasons to use, malloc and Memory-Twiddling

void pointer in, Cast Less

manual memory management, Automatic, Static, and Manual Memory

math, floating point, Deprecate Float

memory leaks, Using Valgrind to Check for Errors, Extending Strings with asprintf

memory managementasprintf vs. sprintf functions, Security

automatic, Automatic, Static, and Manual Memory

basic models of, Automatic, Static, and Manual Memory

block-of-memory approach, Extending Structures and Dictionaries

disk-based memory, Using mmap for Gigantic Data Sets

heaps and, Automatic, Static, and Manual Memory

manual, Automatic, Static, and Manual Memory, Glossary

persistent state variables, Persistent State Variables

stack size limits, Automatic, Static, and Manual Memory

static, Automatic, Static, and Manual Memory

unsigned integers in, Comparing Unsigned Integers

vs. variable management, Automatic, Static, and Manual Memory

_Thread_local memory type, Persistent State Variables

memory twiddling, malloc and Memory-Twiddling

MinGW (Minimalist GNU for Windows), Compiling C Without POSIX

multibyte encoding, Unicode Libraries, Glossary

multidimensional arrays, All the Pointer Arithmetic You Need to Know

multiplexers, Test for Files

multithreadingdebuging, A Debugging Detective Story

environments for, The Environment(see also parallel threads)

mutex (see mutual exclusion)

mutual exclusions (mutexes), Shared Resources, Glossary

narrative pages, The narrative

non-const pointers, Tension

Not-a-Number (NaN), Safely Parse Strings to Numbers, Glossary

noun-adjective declarations, Noun-Adjective Form

numbers, parsing from strings, Safely Parse Strings to Numbers

numeric drift, Deprecate Float

object-oriented programming (OOP)common features of, Object-Oriented Programming in C

count referencesadding a reference counter, Count References

agent-based model of group formation, Example: An Agent-Based Model of Group Formation

substring object example, Example: A Substring Object

element-of-struct form, Functions in Your Structs

operator overload, Overload

pointer pros/cons, C, with fewer seams

structures/dictionariesextending, Extending Structures and Dictionaries

implementing a dictionary, Implementing a Dictionary

inserting new elements, C, with fewer seams

typical library format, Object-Oriented Programming in C

variable scope in C, Scope

virtual tables (vtables)adding new functions with, Vtables

benefits of, Putting it all together

hash function, The hash function

macro for, Putting it all together

type checking, Type checking

_Generic keyword, _Generic

octothorp (#), The Preprocessor

omp_set_lock function, Shared Resources

once pragma, Header Guards

opaque pointers, Smuggling Data Structures Across the Border, Glossary

OpenMPcompiling, Compiling OpenMP, pthreads, and C atoms

interference, Interference

map-reduce, Map-reduce

multiple tasks, Multiple Tasks

word-counting program example, OpenMP

operator overload, Overload

overload, Overload

package managers, Use a Package Manager

packages, basic set for C development, Use a Package Manager

packaginginteroperability principle, Packaging Your Project

makefiles vs. shell scripts, Makefiles vs. Shell Scripts

shell managementfc command, fc

POSIX-standard shell features, The Shell

replacing commands with outputs, Replacing Shell Commands with Their Outputs

testing for files, Test for Files

using shell loops, Use the Shell's for Loops to Operate on a Set of Files

with Autotoolsbenefits of, Packaging Your Code with Autotools

configure.ac shell script, The configure Script

content variables, Content variables

example run, An Autotools Demo

flowchart for, An Autotools Demo

form variables, Form variables

makefile bits, Adding makefile bits

testing, Adding testing

parallel threadsatomic structs, Atomic structs

C atoms, C atoms

listing, A Debugging Detective Story

localizing nonstatic variables, Localizing Nonstatic Variables

mechanism for, The Environment

OpenMPcompiling, Compiling OpenMP, pthreads, and C atoms

interference, Interference

map-reduce, Map-reduce

multiple tasks, Multiple Tasks

word-counting program example, OpenMP

overview of creating, Parallel Threads

pthread_create function, Pthreads

sequential consistency and, Atoms

shared resources inatoms, Atoms

blocking, Shared Resources

mutual exclusions (mutexes), Shared Resources

parallelization of, Shared Resources

thread local, Thread Local

threadprivate clause, Thread Local

parsing, strings to numbers, Safely Parse Strings to Numbers

patch command, Changes via diff

Perl, regular expressions in, Parsing Regular Expressions

persistent state variables, Persistent State Variables

pkg-config, Paths

plugin systems, Dynamic Loading

pointersbasic function of, Pointers

definition of, Your Pal the Pointer

in language interfaces, Smuggling Data Structures Across the Border

manual vs. automatic memory and, Automatic, Static, and Manual Memory

memory types and features, Automatic, Static, and Manual Memory

models of memory management, Automatic, Static, and Manual Memory

non-const, Tension

persistent state variables and, Persistent State Variables

pros/cons of, C, with fewer seams

returning multiple items with, Return Multiple Items from a Function

variable management and, Automatic, Static, and Manual Memory

void, Cast Less, Functions with Generic Inputs, Generic Structures

vs. arrays, Automatic, Static, and Manual Memory

without mallocarray notation, All the Pointer Arithmetic You Need to Know

copies and aliases, Pointers Without malloc

declaration syntax, The Fault Is in Our Stars

memory-twiddling, malloc and Memory-Twiddling

structures vs. arrays, Structures Get Copied, Arrays Get Aliased

typedef and, Typedef as a teaching tool

POSIXBSD implementation, The POSIX Standard

compiling C with, POSIX for Windows

definition of, Glossary

GNU implementation, The POSIX Standard

history of standard, The POSIX Standard

mmap for gigantic data sets, Using mmap for Gigantic Data Sets

parsing regular expressions with, POSIX

standard naming conventions, Typedefs Save the Day

standard shell features, The Shell

POSIX versionsBSD, The POSIX Standard

GNU, The POSIX Standard

POSIX, The POSIX Standard

Unix, The POSIX Standard

preprocessorcomment out code with, Header Guards

definition of, Glossary

handling diverse environments with, Test Macros

macro processing, The Preprocessor

purpose of, There's a preprocessor

printf function, There is no print keyword

profiling, Print Your Structures, Glossary

pthread, Glossary

pvnrt package, Python Host

Pythoninterfacing withcompiling/linking, Compiling and Linking

conditional subdirectory for Automake, The Conditional Subdirectory for Automake

controlling package production, Distutils Backed with Autotools

overview of, Python Host

quick_exit function, goto Considered

random number generator (RNG), The GNU Scientific Library, Glossary

Readline library, Dynamic Loading

regular expressionsbenefits of, Parsing Regular Expressions

POSIX/PCRE interfaces, Parsing Regular Expressions

types of, Parsing Regular Expressions

resources, sharing, Shared Resources

restrict keyword, Noun-Adjective Form

revision control systems (RCSes), Version Control

Ritchie, Dennis, Standards: So Many to Choose From

runtime linking, Linking

Sapir-Whorf hypothesis, Object-Oriented Programming in C, Glossary

Sasprintf macro, Extending Strings with asprintf

scope, Scope, Glossary

segfaults, Automatic, Static, and Manual Memory, Flexible Function Inputs, Glossary

seq command, Use the Shell's for Loops to Operate on a Set of Files

sequential consistency, Atoms

shared libraries, Runtime Linking, The Rules

shared object files, Dynamic Loading

shell managementchoosing shells, fc

fc command, fc

replacing commands with outputs, Replacing Shell Commands with Their Outputs

testing for files, Test for Files

using shell loops, Use the Shell's for Loops to Operate on a Set of Files

shell scriptsconfigure.ac, The configure Script

fc command, fc

vs. makefiles for packaging, Makefiles vs. Shell Scripts

signed integers, Comparing Unsigned Integers

simple command description, Setting Variables

sizeof function, Comparing Unsigned Integers, The Preprocessor, You can find out how much space a type takes

snprintf function, Basic types can be aggregated into arrays and structs

source shell command, Replacing Shell Commands with Their Outputs

stacksarbitrary size limits in, Automatic, Static, and Manual Memory

definition of, Glossary

state variables, Atomic structs

static allocation, Glossary

static keyword, Linkage with static and extern

static libraries, Runtime Linking

static memory management, Automatic, Static, and Manual Memory

static variable, Persistent State Variables, Thread Local

stdn, compiling from, Compiling from stdin

strdup function, Constant Strings

string types, There is no special string type

strings, Enums and Stringsasprintf functionconstant strings, Constant Strings

extending strings with, Extending Strings with asprintf

sensitive information and, Security

string allocation with, Making String Handling Less Painful with asprintf

creating from macros, The Preprocessor

drawbacks of C, Easier Text Handling

duplicating, Constant Strings

parsing to numbers, Safely Parse Strings to Numbers

string-handling utilities, A Pæan to strtok

strtok functionbasic working of, A Pæan to strtok

tasks possible with, A Pæan to strtok

strtod command, Safely Parse Strings to Numbers

strtok functionbasic working of, A Pæan to strtok

tasks possible with, A Pæan to strtok

strtok_r function, A Pæan to strtok

strtok_s function, A Pæan to strtok

strtol command, Safely Parse Strings to Numbers

strtoll command, Smuggling Data Structures Across the Border

structscompound literals and, Designated Initializer]]s

declaring format of, Typedefs Save the Day

designated initializers and, Better Structures

error codes and, Generic Structures

filling, Designated Initializer]]s

function-specific, Return Multiple Items from a Function

initializing with zeros, Initialize Arrays and Structs with Zeros

sending to functions, Better Structures

specifying, Designated Initializer]]s

writing new, Reporting Errors

structured inputsarray/struct initialization with zeros, Initialize Arrays and Structs with Zeros

compound literals, Compound Literals

designated initializers, Designated Initializer]]s

error code reporting, Reporting Errors

for variadic functionsimproving interface for, Polishing a Dull Function

lack of type safety in, Flexible Function Inputs

optional and named arguments, Optional and Named Arguments

printf-style declaration, Declare Your Function as printf-Style

foreach loops, Foreach

multiple lists, Multiple Lists

returning multiple items, Return Multiple Items from a Function

safely terminated lists, Safely Terminated Lists

typedef and, Typedefs Save the Day

variable-length macro arguments, Variadic Macros

vectorized functions, Vectorize a Function

void pointerfor generic inputs, Functions with Generic Inputs

generic structures, Generic Structures

working with, Better Structures

Structured Query Language (SQL), SQLite

structures, extending, Extending Structures and Dictionaries

subdirectoriesanonymous, C, with fewer seams

conditional, The Conditional Subdirectory for Automake

Subsystem for Unix-based Applications (SUA), POSIX for Windows

switch function, switch

system command, Dynamic Loading

tab completion feature, The Shell

technical documentation, The narrative

tentative definitions, Externally Linked Variables in Header Files

terminal multiplexers, Test for Files

test harnesses, Unit Testing, Glossary

TeX documentation system, Literate Code with CWEB

text files, retrieving, Dynamic Loading

text handlingasprintf functionconstant strings, Constant Strings

extending strings with, Extending Strings with asprintf

sensitive information and, Security

string allocation with, Making String Handling Less Painful with asprintf

drawbacks of C for, Easier Text Handling

string-handling utilities, A Pæan to strtok

strtok functionbasic working of, A Pæan to strtok

tasks possible with, A Pæan to strtok

translations, The Sample Code

Unicodedisplay of, Unicode

encoding for C code, The Encoding for C Code

premise of, Unicode

programming caveats, Unicode

sample program, The Sample Code

Unicode libraries, Unicode Libraries

UTF encoding, Unicode

threads (see parallel threads)

tmux multiplexer, Test for Files

tokenization, A Pæan to strtok, Glossary

translations, The Sample Code

tuples, Reporting Errors

Turing, Alan, Extending Structures and Dictionaries

two-dimensional arrays, All the Pointer Arithmetic You Need to Know

type checking, Type checking

type punning, Glossary

type qualifier, The const Keyword, Glossary

type-casting, Cast Less

typedef, Typedef as a teaching tool, Header Guards, Typedefs Save the Day

typesaggregating, Basic types can be aggregated into arrays and structs

defining, New structure types can be defined

determining size of, You can find out how much space a type takes

U.S. copyright laws, The POSIX Standard

Unicodedisplay of, Unicode

encoding for C code, The Encoding for C Code

libraries for, Unicode Libraries

premise of, Unicode

programming caveats, Unicode

sample program, The Sample Code

UTF encoding, Unicode

union keyword, C, with fewer seams

unit testingtest coverage, Coverage

test harnesses, Unit Testing

using programs as libraries, Using a Program as a Library

Unix standard, The POSIX Standard

unsigned integers, Comparing Unsigned Integers

UTF encoding, Unicode, The Encoding for C Code

Valgrind, Using Valgrind to Check for Errors

variables atomic, C atoms

automatic management of, Automatic, Static, and Manual Memory

block scope, Linkage with static and extern

built-in, Setting Variables

content variables, Content variables

convenience variables, GDB Variables

creating auxilary with preprocessor, The Preprocessor

declarations, Variable Declarations

environment, Setting Variables, Replacing Shell Commands with Their Outputs, Glossary

externally linked in header files, Externally Linked Variables in Header Files

file scope variables, Linkage with static and extern

for GDB (GNU Debugger), GDB Variables

form variables, Form variables

global, Glossary

in macros, Cultivate Robust and Flourishing Macros

in memory management, Automatic, Static, and Manual Memory

incrementing/scaling, There are many shortcuts for incrementing or scaling a variable

localizing nonstatic, Localizing Nonstatic Variables

private copies of, Thread Local

scope, Scope, The scoping rules for C are very simple

setting, Setting Variables

shell variables, Replacing Shell Commands with Their Outputs

state, Atomic structs

static, Automatic, Static, and Manual Memory, Persistent State Variables, Thread Local

undefined, Initialize Arrays and Structs with Zeros

variadic functions, Flexible Function Inputs

variadic macros, Variadic Macros

version control, Version Control

virtual tables (vtables)adding new functions with, Vtables

benefits of, Putting it all together

hash function, The hash function

macro for, Putting it all together

type checking, Type checking

Visual Studio, Compiling C with POSIX

vsnprintf function, Making String Handling Less Painful with asprintf

while keyword, Labels, gotos, switches, and breaks

whitespace, preprocessors and, The Preprocessor

wide-character types, Unicode Libraries, Glossary

Windowscompilation with, POSIX for Windows-Compiling C Without POSIX

UTF encoding in, Unicode, Unicode Libraries

wrapper function, The Wrapper Function

XML libraries, Object-Oriented Programming in C

Z shell, fc

Fair Use Sources:

• 21st Century C on DuckDuckGo
• B00NYBRH30 (21cC 2014)
• 21st Century C for Archive Access for Fair Use Preservation, quoting, paraphrasing, excerpting and/or commenting upon