C in a Nutshell, 2nd Edition: The Definitive Reference

Copyright
Table of Contents
Preface
	How This Book Is Organized
		Part I
		Part II
		Part III
	Further Reading
	Conventions Used in This Book
	Using Code Examples
	Safari® Books Online
	How to Contact Us
	Acknowledgments
		Peter
		Tony
Part I. Language
Chapter 1. Language Basics
	Characteristics of C
	The Structure of C Programs
	Source Files
	Comments
	Character Sets
		Wide Characters and Multibyte Characters
		Universal Character Names
		Digraphs and Trigraphs
	Identifiers
		Identifier Name Spaces
		Identifier Scope
	How the C Compiler Works
		The C Compiler’s Translation Phases
		Tokens
Chapter 2. Types
	Typology
	Integer Types
		Integer Types Defined in Standard Headers
	Floating-Point Types
	Complex Floating-Point Types
	Enumerated Types
	The Type void
		void in Function Declarations
		Expressions of Type void
		Pointers to void
	The Alignment of Objects in Memory
Chapter 3. Literals
	Integer Constants
	Floating-Point Constants
		Decimal Floating-Point Constants
		Hexadecimal Floating-Point Constants
	Character Constants
		Types and Values of Character Constants
		Escape Sequences
	String Literals
Chapter 4. Type Conversions
	Conversion of Arithmetic Types
		Hierarchy of Types
		Integer Promotion
		Usual Arithmetic Conversions
		Other Implicit Type Conversions
		The Results of Arithmetic Type Conversions
	Conversion of Nonarithmetic Types
		Array and Function Designators
		Explicit Pointer Conversions
		Implicit Pointer Conversions
		Conversions Between Pointer and Integer Types
Chapter 5. Expressions and Operators
	How Expressions Are Evaluated
		Generic Selections (C11)
		Lvalues
		Side Effects and Sequence Points
		Operator Precedence and Associativity
	Operators in Detail
		Arithmetic Operators
		Assignment Operators
		Increment and Decrement Operators
		Comparative Operators
		Logical Operators
		Bitwise Operators
		Memory Addressing Operators
		Other Operators
	Constant Expressions
		Integer Constant Expressions
		Other Constant Expressions
Chapter 6. Statements
	Expression Statements
	Block Statements
	Loops
		while Statements
		for Statements
		do…while Statements
		Nested Loops
	Selection Statements
		if Statements
		switch Statements
	Unconditional Jumps
		The break Statement
		The continue Statement
		The goto Statement
		The return Statement
Chapter 7. Functions
	Function Definitions
		Functions and Storage Class Specifiers
		K&R-Style Function Definitions
		Function Parameters
		Arrays as Function Parameters
		The main() Function
	Function Declarations
		Declaring Optional Parameters
		Declaring Variable-Length Array Parameters
	How Functions Are Executed
	Pointers as Arguments and Return Values
	Inline Functions
	Non-Returning Functions
	Recursive Functions
	Variable Numbers of Arguments
Chapter 8. Arrays
	Defining Arrays
		Fixed-Length Arrays
		Variable-Length Arrays
	Accessing Array Elements
	Initializing Arrays
		Writing Initialization Lists
		Initializing Specific Elements
	Strings
	Multidimensional Arrays
		Matrices
		Declaring Multidimensional Arrays
		Initializing Multidimensional Arrays
	Arrays as Arguments of Functions
Chapter 9. Pointers
	Declaring Pointers
		Null Pointers
		void Pointers
		Initializing Pointers
	Operations with Pointers
		Using Pointers to Read and Modify Objects
		Modifying and Comparing Pointers
	Pointers and Type Qualifiers
		Constant Pointers and Pointers to Constant Objects
		Restricted Pointers
	Pointers to Arrays and Arrays of Pointers
		Array Pointers
		Pointer Arrays
	Pointers to Functions
Chapter 10. Structures, Unions, and Bit-Fields
	Structures
		Defining Structure Types
		Structure Objects and typedef Names
		Incomplete Structure Types
		Accessing Structure Members
		Initializing Structures
		Initializing Specific Members
		Structure Members in Memory
		Flexible Structure Members
		Pointers as Structure Members
	Unions
		Defining Union Types
		Initializing Unions
	Anonymous Structures and Unions
	Bit-Fields
Chapter 11. Declarations
	Object and Function Declarations
		Examples
		Storage Class Specifiers
		Type Qualifiers
		Declarations and Definitions
		Complex Declarators
	Type Names
	typedef Declarations
	_Static_assert Declarations
	Linkage of Identifiers
		External Linkage
		Internal Linkage
		No Linkage
	Storage Duration of Objects
		Static Storage Duration
		Thread Storage Duration
		Automatic Storage Duration
	Initialization
		Implicit Initialization
		Explicit Initialization
Chapter 12. Dynamic Memory Management
	Allocating Memory Dynamically
	Characteristics of Allocated Memory
	Resizing and Releasing Memory
	An All-Purpose Binary Tree
	Characteristics
	Implementation
		Generating an Empty Tree
		Inserting New Data
		Finding Data in the Tree
		Removing Data from the Tree
		Traversing a Tree
		A Sample Application
Chapter 13. Input and Output
	Streams
		Text Streams
		Binary Streams
	Files
		File Position
		Buffers
		The Standard Streams
	Opening and Closing Files
		Opening a File
		Access Modes
		Closing a File
	Reading and Writing
		Byte-Oriented and Wide-Oriented Streams
		Error Handling
		Unformatted I/O
		Formatted Output
		Formatted Input
	Random File Access
		Obtaining the Current File Position
		Setting the File Access Position
Chapter 14. Multithreading
	Threads
		Creating Threads
		Other Thread Functions
	Accessing Shared Data
		Mutual Exclusion
		Atomic Objects
		Atomic Operations
		Memory Ordering
		Fences
	Communication Between Threads: Condition Variables
	Thread-Local Objects and Thread-Specific Storage
		Using Thread-Local Objects
		Using Thread-Specific Storage
Chapter 15. Preprocessing Directives
	Inserting the Contents of Header Files
		How the Preprocessor Finds Header Files
		Nested #include Directives
	Defining and Using Macros
		Macros Without Parameters
		Macros with Parameters
		Using Macros Within Macros
		Macro Scope and Redefinition
	Type-generic Macros
	Conditional Compiling
		The #if and #elif Directives
		The defined Operator
		The #ifdef and #ifndef Directives
	Defining Line Numbers
	Generating Error Messages
	The #pragma Directive
	The _Pragma Operator
	Predefined Macros
		Conditionally Defined Macros
Part II. Standard Library
Chapter 16. The Standard Headers
	Using the Standard Headers
		Execution Environments
		Function and Macro Calls
		Reserved Identifiers
	Functions with Bounds-Checking
		Availability
		Runtime Constraints
	Contents of the Standard Headers
		assert.h
		complex.h
		ctype.h
		errno.h
		fenv.h
		float.h
		inttypes.h
		iso646.h
		limits.h
		locale.h
		math.h
		setjmp.h
		signal.h
		stdalign.h
		stdarg.h
		stdatomic.h
		stdbool.h
		stddef.h
		stdint.h
		stdio.h
		stdlib.h
		stdnoreturn.h
		string.h
		tgmath.h
		threads.h
		time.h
		uchar.h
		wchar.h
		wctype.h
Chapter 17. Functions at a Glance
	Input and Output
	Mathematical Functions
		Mathematical Functions for Integer Types
		Floating-Point Functions
		Function-Like Macros
		Pragmas for Arithmetic Operations
		The Floating-Point Environment
		Error Handling
	Character Classification and Conversion
		Character Classification
		Case Mapping
	String Processing
	Multibyte Characters
	Converting Between Numbers and Strings
	Searching and Sorting
	Memory Block Handling
	Dynamic Memory Management
	Date and Time
	Process Control
		Communication with the Operating System
		Signals
	Internationalization
	Nonlocal Jumps
	Multithreading (C11)
		Thread Functions
		Atomic Operations
	Debugging
	Error Messages
Chapter 18. Standard Library Functions
Part III. Basic Tools
Chapter 19. Compiling with GCC
	The GNU Compiler Collection
	Obtaining and Installing GCC
	Compiling C Programs with GCC
		Step by Step
		Multiple Input Files
		Dynamic Linking and Shared Object Files
		Freestanding Programs
	C Dialects
	Compiler Warnings
	Optimization
		The -O Levels
		The -f Flags
		Floating-Point Optimization
		Architecture-Specific Optimization
		Why Not Optimize?
	Debugging
	Profiling
	Option and Environment Variable Summary
		Command-Line Options
		Environment Variables
Chapter 20. Using make to Build C Programs
	Targets, Prerequisites, and Commands
	The Makefile
	Rules
		The Command Script
		Pattern Rules
		Suffix Rules
		Built-In Rules
		Implicit Rule Chains
		Double-Colon Rules
	Comments
	Variables
		Assignment Operators
		Variables and Whitespace
		Target-Specific Variable Assignments
		The Automatic Variables
		Other Built-In Variables
		Environment Variables
	Phony Targets
	Other Target Attributes
	Macros
	Functions
		Built-In Functions
		User-Defined Functions
	Directives
		Conditionals
		Includes
		Other Directives
	Running make
		Generating Header Dependencies
		Recursive make Commands
		Command-Line Options
		Special Targets Used as Runtime Options
		GCC Options for Generating Makefile Rules
Chapter 21. Debugging C Programs with GDB
	Installing GDB
	A Sample Debugging Session
		Symbol Information
		Finding a Bug
	Starting GDB
		Command-Line Arguments
		Command-Line Options
		Initialization Files
	Using GDB Commands
		Command Completion
		Displaying Help for Commands
		Status Information
		Running a Program in the Debugger
		Displaying Source Code
		Working with Breakpoints
		Resuming Execution After a Break
		Analyzing the Stack
		Displaying Data
		Watchpoints: Observing Operations on Variables
	Analyzing Core Files in GDB
Chapter 22. Using an IDE with C
	IDEs for C
	The Eclipse IDE for C/C++
		Installing Eclipse CDT
		Running Eclipse
		Perspectives and Views
	Developing a C Program with Eclipse
		Creating a New C Project
		Editing
		Compiling and Running a Program
		Project Properties
	Debugging a C Program in Eclipse
		Starting the Debugger
		Setting Breakpoints
		Controlling Program Execution in the Debugger
	Further Information on Eclipse
Index