book

21st Century C, 2nd Edition

by Ben Klemens

October 2014

Intermediate to advanced

408 pages

10h 19m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

C Is Punk RockQ & A (Or, the Parameters of the Book)Standards: So Many to Choose FromThe POSIX StandardSome LogisticsThe Second EditionConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgments
Use a Package ManagerCompiling C with WindowsPOSIX for WindowsCompiling C with POSIXCompiling C Without POSIXWhich Way to the Library?A Few of My Favorite FlagsPathsRuntime LinkingUsing MakefilesSetting VariablesThe RulesUsing Libraries from SourceUsing Libraries from Source (Even if Your Sysadmin Doesn’t Want You To)Compiling C Programs via Here DocumentInclude Header Files from the Command LineThe Unified HeaderHere DocumentsCompiling from stdin
Using a DebuggerA Debugging Detective StoryGDB VariablesPrint Your StructuresUsing Valgrind to Check for ErrorsUnit TestingUsing a Program as a LibraryCoverageError CheckingWhat is the User’s Involvement in the Error?The Context in Which the User is WorkingHow Should the Error Indication Be Returned?Interweaving DocumentationDoxygenLiterate Code with CWEB
The ShellReplacing Shell Commands with Their OutputsUse the Shell’s for Loops to Operate on a Set of FilesTest for FilesfcMakefiles vs. Shell ScriptsPackaging Your Code with AutotoolsAn Autotools DemoDescribing the Makefile with Makefile.amThe configure Script
Changes via diffGit’s ObjectsThe StashTrees and Their BranchesMergingThe RebaseRemote Repositories
Dynamic LoadingThe Limits of Dynamic LoadingThe ProcessWriting to Be Read by NonnativesThe Wrapper FunctionSmuggling Data Structures Across the BorderLinkingPython HostCompiling and LinkingThe Conditional Subdirectory for AutomakeDistutils Backed with Autotools
Automatic, Static, and Manual MemoryPersistent State VariablesPointers Without mallocStructures Get Copied, Arrays Get Aliasedmalloc and Memory-TwiddlingThe Fault Is in Our StarsAll the Pointer Arithmetic You Need to KnowTypedef as a teaching tool
Don’t Bother Explicitly Returning from mainLet Declarations FlowSet Array Size at RuntimeCast LessEnums and StringsLabels, gotos, switches, and breaksgoto ConsideredswitchDeprecate FloatComparing Unsigned IntegersSafely Parse Strings to Numbers

Cultivate Robust and Flourishing MacrosThe PreprocessorTest MacrosHeader GuardsLinkage with static and externExternally Linked Variables in Header FilesThe const KeywordNoun-Adjective FormTensionDepthThe char const ** Issue
Making String Handling Less Painful with asprintfSecurityConstant StringsExtending Strings with asprintfA Pæan to strtokUnicodeThe Encoding for C CodeUnicode LibrariesThe Sample Code
Compound LiteralsInitialization via Compound LiteralsVariadic MacrosSafely Terminated ListsMultiple ListsForeachVectorize a FunctionDesignated InitializersInitialize Arrays and Structs with ZerosTypedefs Save the DayA Style NoteReturn Multiple Items from a FunctionReporting ErrorsFlexible Function InputsDeclare Your Function as printf-StyleOptional and Named ArgumentsPolishing a Dull FunctionThe Void Pointer and the Structures It Points ToFunctions with Generic InputsGeneric Structures
Extending Structures and DictionariesImplementing a DictionaryC, with fewer seamsFunctions in Your StructsVtablesScopePrivate Struct ElementsOverload_GenericCount ReferencesExample: A Substring ObjectExample: An Agent-Based Model of Group FormationConclusion
The EnvironmentThe IngredientsOpenMPCompiling OpenMP, pthreads, and C atomsInterferenceMap-reduceMultiple TasksThread LocalLocalizing Nonstatic VariablesShared ResourcesAtomsPthreadsC atomsAtomic structs
GLibPOSIXParsing Regular ExpressionsUsing mmap for Gigantic Data SetsThe GNU Scientific LibrarySQLiteThe Querieslibxml and cURL
The StructureC requires a compilation step, which consists of running a single commandThere’s a standard library, and it’s part of your operating systemThere’s a preprocessorThere are two types of commentThere is no print keywordVariable DeclarationsVariables have to be declaredEven functions have to be declared or definedBasic types can be aggregated into arrays and structsNew structure types can be definedYou can find out how much space a type takesThere is no special string typeExpressionsThe scoping rules for C are very simpleThe main function is specialMost of what a C program actually does is evaluate expressionsFunctions are evaluated using copies of the inputsExpressions are delimited by semicolonsThere are many shortcuts for incrementing or scaling a variableC has an expansive definition of truthDividing two integers always produces an integerC has a trinary conditional operatorBranching and looping expressions are not very different from any other languageThe for loop is just a compact version of the while loopPointersYou can directly request a block of memoryArrays are just blocks of memory; any block of memory can be used like an arrayA pointer to a scalar is really just a one-item arrayThere is a special notation for elements of pointed-to structsPointers let you modify function inputsEverything is somewhere, so everything can be pointed to

Content preview from 21st Century C, 2nd Edition

Chapter 5. Playing Nice with Others

The count of programming languages approaches infinity, and a huge chunk of them have a C interface. This short chapter offers some general notes about the process and demonstrates in detail the interface with one language, Python.

Every language has its own customs for packaging and distribution, which means that after you write the bridge code in C and the host language, you get to face the task of getting the packaging system to compile and link everything. This gives me a chance to present more advanced features of Autotools, such as conditionally processing a subdirectory and adding install hooks.

Dynamic Loading

Before jumping into other languages, it is worth taking a moment to appreciate the C functions that make it all possible: dlopen and dlsym. These functions open a dynamic library and extract a symbol, such as a static object or a function, from that library.

The functions are part of the POSIX standard. Windows systems have a similar setup, but the functions are named LoadLibrary and GetProcAddress; for simplicity of exposition, I’ll stick to the POSIX names.

The name “shared object file” is nicely descriptive: such a file includes a list of objects, including functions and statically defined structures, that are intended for use in other programs.

Using such a file is much like retrieving an item from a text file holding a list of items. For the text file, you would first call fopen to get a handle for the file, and then call ...