C PROGRAMMING
RUNNING HELLO, WORLD! TECHNICAL REQUIREMENTS WRITING YOUR FIRST C PROGRAM HELLO, WORLD! UNDERSTANDING THE PROGRAM DEVELOPMENT CYCLE EDIT COMPILE RUN VERIFY REPEAT CREATING, TYPING, AND SAVING YOUR FIRST C PROGRAM COMPILING YOUR FIRST C PROGRAM RUNNING YOUR FIRST C PROGRAM WRITING COMMENTS TO CLARIFY THE PROGRAM LATER SOME GUIDELINES ON COMMENTING CODE ADDING COMMENTS TO THE HELLO, WORLD! PROGRAM LEARNING TO EXPERIMENT WITH CODE SUMMARY UNDERSTANDING PROGRAM STRUCTURE TECHNICAL REQUIREMENTS INTRODUCING STATEMENTS AND BLOCKS EXPERIMENTING WITH STATEMENTS AND BLOCKS UNDERSTANDING DELIMITERS UNDERSTANDING WHITESPACE INTRODUCING STATEMENTS INTRODUCING FUNCTIONS UNDERSTANDING FUNCTION DEFINITIONS EXPLORING FUNCTION IDENTIFIERS EXPLORING THE FUNCTION BLOCK EXPLORING FUNCTION RETURN VALUES PASSING IN VALUES WITH FUNCTION PARAMETERS ORDER OF EXECUTION UNDERSTANDING FUNCTION DECLARATIONS QUESTIONS WORKING WITH BASIC DATA TYPES TECHNICAL REQUIREMENTS UNDERSTANDING DATA TYPES BYTES AND CHUNKS OF DATA REPRESENTING WHOLE NUMBERS REPRESENTING POSITIVE AND NEGATIVE WHOLE NUMBERS SPECIFYING DIFFERENT SIZES OF INTEGERS REPRESENTING NUMBERS WITH FRACTIONS REPRESENTING SINGLE CHARACTERS REPRESENTING BOOLEAN TRUE/FALSE UNDERSTANDING THE SIZES OF DATA TYPES THE SIZEOF() OPERATOR RANGES OF VALUES USING VARIABLES AND ASSIGNMENTS TECHNICAL REQUIREMENTS UNDERSTANDING DATA TYPES AND VALUES INTRODUCING VARIABLES NAMING VARIABLES INTRODUCING EXPLICIT TYPES OF VARIABLES USING EXPLICIT TYPING WITH INITIALIZATION EXPLORING CONSTANTS LITERAL CONSTANTS DEFINED VALUES EXPLICITLY TYPED CONSTANTS NAMING CONSTANT VARIABLES USING TYPES AND ASSIGNMENTS USING EXPLICIT ASSIGNMENT – THE SIMPLEST STATEMENT ASSIGNMENT BY THE FUNCTION RETURN VALUE EXPLORING OPERATORS AND EXPRESSIONS TECHNICAL REQUIREMENTS UNDERSTANDING EXPRESSIONS AND OPERATIONS INTRODUCING OPERATIONS ON NUMBERS CONSIDERING THE SPECIAL ISSUES RESULTING FROM OPERATIONS ON NUMBERS EXPLORING TYPE CONVERSION UNDERSTANDING IMPLICIT TYPE CONVERSION AND VALUES USING EXPLICIT TYPE CONVERSION – CASTING INTRODUCING OPERATIONS ON CHARACTERS LOGICAL OPERATORS RELATIONAL OPERATORS BITWISE OPERATORS THE CONDITIONAL OPERATOR THE SEQUENCE OPERATOR COMPOUND ASSIGNMENT OPERATORS INCREMENTAL OPERATORS ORDER OF OPERATIONS AND GROUPING EXPLORING CONDITIONAL PROGRAM FLOW TECHNICAL REQUIREMENTS UNDERSTANDING CONDITIONAL EXPRESSIONS INTRODUCING THE IF()… ELSE… COMPLEX STATEMENT USING NESTED IF()… ELSE… STATEMENTS THE DANGLING ELSE PROBLEM EXPLORING LOOPS AND ITERATIONS TECHNICAL REQUIREMENTS UNDERSTANDING REPETITION UNDERSTANDING BRUTE-FORCE REPETITION INTRODUCING THE WHILE()… STATEMENT INTRODUCING THE FOR()… STATEMENT INTRODUCING THE DO … WHILE() STATEMENT UNDERSTANDING LOOP EQUIVALENCY UNDERSTANDING UNCONDITIONAL BRANCHING – THE DOS AND (MOSTLY) DON'TS OF GOTO FURTHER CONTROLLING LOOPS WITH BREAK AND CONTINUE UNDERSTANDING INFINITE LOOPS CREATING AND USING ENUMERATIONS TECHNICAL REQUIREMENTS INTRODUCING ENUMERATIONS DEFINING ENUMERATIONS USING ENUMERATIONS THE SWITCH()… STATEMENT REVISITED USING ENUMERATED ITEM VALUES AS LITERAL INTEGER CONSTANTS PART 2: COMPLEX DATA TYPES CREATING AND USING STRUCTURES TECHNICAL REQUIREMENTS UNDERSTANDING STRUCTURES DECLARING STRUCTURES INITIALIZING STRUCTURES AND ACCESSING STRUCTURE ELEMENTS PERFORMING OPERATIONS ON STRUCTURES – FUNCTIONS STRUCTURES OF STRUCTURES INITIALIZING STRUCTURES WITH FUNCTIONS PRINTING A STRUCTURE OF STRUCTURES – REUSING FUNCTIONS THE STEPPING STONE TO OOP CREATING CUSTOM DATA TYPES WITH TYPEDEF TECHNICAL REQUIREMENTS USING SYNONYMS SIMPLIFYING THE USE OF ENUM TYPES WITH TYPEDEF SIMPLIFYING THE USE OF STRUCT TYPES WITH TYPEDEF OTHER USES OF TYPEDEF EXPLORING SOME MORE USEFUL COMPILER OPTIONS USING A HEADER FILE FOR CUSTOM TYPES AND THE TYPEDEF SPECIFIERS WORKING WITH ARRAYS TECHNICAL REQUIREMENTS DECLARING AND INITIALIZING ARRAYS INITIALIZING ARRAYS UNDERSTANDING VARIABLE-LENGTH ARRAYS ACCESSING ARRAY ELEMENTS ASSIGNING VALUES TO ARRAY ELEMENTS OPERATING ON ARRAYS WITH LOOPS WORKING WITH MULTI-DIMENSIONAL ARRAYS TECHNICAL REQUIREMENTS GOING BEYOND 1D ARRAYS TO MULTI- DIMENSIONAL ARRAYS REVISITING 1D ARRAYS MOVING ON TO 2D ARRAYS MOVING ON TO 3D ARRAYS CONSIDERING N-DIMENSIONAL ARRAYS DECLARING AND INITIALIZING MULTI- DIMENSIONAL ARRAYS OF VARIOUS DIMENSIONS DECLARING ARRAYS OF TWO DIMENSIONS INITIALIZING ARRAYS OF TWO DIMENSIONS DECLARING ARRAYS OF THREE DIMENSIONS INITIALIZING ARRAYS OF THREE DIMENSIONS DECLARING AND INITIALIZING ARRAYS OF N DIMENSIONS ACCESSING ELEMENTS OF MULTI- DIMENSIONAL ARRAYS OF VARIOUS DIMENSIONS MANIPULATING MULTI-DIMENSIONAL ARRAYS USING LOOPS WITHIN LOOPS USING NESTED LOOPS TO TRAVERSE A 2D ARRAY USING NESTED LOOPS TO TRAVERSE A 3D ARRAY USING MULTI-DIMENSIONAL ARRAYS IN FUNCTIONS USING POINTERS TECHNICAL REQUIREMENTS ADDRESSING POINTERS – THE BOOGEYMAN OF C PROGRAMMING WHY USE POINTERS AT ALL? INTRODUCING POINTERS UNDERSTANDING DIRECT ADDRESSING AND INDIRECT ADDRESSING UNDERSTANDING MEMORY AND MEMORY ADDRESSING MANAGING AND ACCESSING MEMORY EXPLORING SOME ANALOGIES IN THE REAL WORLD DECLARING THE POINTER TYPE, NAMING POINTERS, AND ASSIGNING ADDRESSES DECLARING THE POINTER TYPE NAMING POINTERS ASSIGNING POINTER VALUES (ADDRESSES) OPERATIONS WITH POINTERS ASSIGNING POINTER VALUES DIFFERENTIATING BETWEEN THE NULL POINTER AND VOID* ACCESSING POINTER TARGETS UNDERSTANDING THE VOID* TYPE POINTER ARITHMETIC COMPARING POINTERS VERBALIZING POINTER OPERATIONS VARIABLE FUNCTION ARGUMENTS PASSING VALUES BY REFERENCE PASSING ADDRESSES TO FUNCTIONS WITHOUT POINTER VARIABLES POINTERS TO POINTERS USING POINTERS TO STRUCTURES ACCESSING STRUCTURES AND THEIR ELEMENTS VIA POINTERS USING POINTERS TO STRUCTURES IN FUNCTIONS UNDERSTANDING ARRAYS AND POINTERS TECHNICAL REQUIREMENTS UNDERSTANDING ARRAY NAMES AND POINTERS UNDERSTANDING ARRAY ELEMENTS AND POINTERS ACCESSING ARRAY ELEMENTS VIA POINTERS OPERATIONS ON ARRAYS USING POINTERS USING POINTER ARITHMETIC PASSING ARRAYS AS FUNCTION POINTERS REVISITED INTERCHANGEABILITY OF ARRAY NAMES AND POINTERS INTRODUCING AN ARRAY OF POINTERS TO ARRAYS WORKING WITH STRINGS TECHNICAL REQUIREMENTS CHARACTERS – THE BUILDING BLOCKS OF STRINGS THE CHAR TYPE AND ASCII BEYOND ASCII – UTF-8 AND UNICODE OPERATIONS ON CHARACTERS GETTING INFORMATION ABOUT CHARACTERS MANIPULATING CHARACTERS EXPLORING C STRINGS AN ARRAY WITH A TERMINATOR STRENGTHS OF C STRINGS WEAKNESSES OF C STRINGS DECLARING AND INITIALIZING A STRING STRING DECLARATIONS INITIALIZING STRINGS PASSING A STRING TO A FUNCTION EMPTY STRINGS VERSUS NULL STRINGS HELLO, WORLD! REVISITED COMMON OPERATIONS ON STRINGS – THE STANDARD LIBRARY COMMON FUNCTIONS SAFER STRING OPERATIONS CREATING AND USING MORE COMPLEX STRUCTURES TECHNICAL REQUIREMENTS INTRODUCING THE NEED FOR COMPLEX STRUCTURES REVISITING CARD4 H UNDERSTANDING AN ARRAY OF STRUCTURES CREATING AN ARRAY OF STRUCTURES ACCESSING STRUCTURE ELEMENTS WITHIN AN ARRAY MANIPULATING AN ARRAY OF STRUCTURES USING A STRUCTURE WITH OTHER STRUCTURES CREATING A STRUCTURE CONSISTING OF OTHER STRUCTURES ACCESSING STRUCTURE ELEMENTS WITHIN THE STRUCTURE MANIPULATING A STRUCTURE CONSISTING OF OTHER STRUCTURES USING A STRUCTURE WITH ARRAYS UNDERSTANDING RANDOMNESS AND RANDOM NUMBER GENERATORS CREATING A STRUCTURE WITH AN ARRAY ACCESSING ARRAY ELEMENTS WITHIN A STRUCTURE USING A STRUCTURE WITH AN ARRAY OF STRUCTURES ACCESSING INDIVIDUAL STRUCTURE ELEMENTS OF THE ARRAY WITHIN A STRUCTURE MANIPULATING A STRUCTURE WITH AN ARRAY OF STRUCTURES COMPLETING CARDDECK C PART 3: MEMORY MANIPULATION UNDERSTANDING MEMORY ALLOCATION AND LIFETIME TECHNICAL REQUIREMENTS DEFINING STORAGE CLASSES UNDERSTANDING AUTOMATIC VERSUS DYNAMIC STORAGE CLASSES AUTOMATIC STORAGE DYNAMIC STORAGE UNDERSTANDING INTERNAL VERSUS EXTERNAL STORAGE CLASSES INTERNAL OR LOCAL STORAGE CLASSES EXTERNAL OR GLOBAL STORAGE CLASSES THE LIFETIME OF AUTOMATIC STORAGE EXPLORING THE STATIC STORAGE CLASS INTERNAL STATIC STORAGE EXTERNAL STATIC STORAGE THE LIFETIME OF STATIC STORAGE USING DYNAMIC MEMORY ALLOCATION TECHNICAL REQUIREMENTS INTRODUCING DYNAMIC MEMORY A BRIEF TOUR OF C'S MEMORY LAYOUT ALLOCATING AND RELEASING DYNAMIC MEMORY ALLOCATING DYNAMIC MEMORY RELEASING DYNAMIC MEMORY ACCESSING DYNAMIC MEMORY THE LIFETIME OF DYNAMIC MEMORY SPECIAL CONSIDERATIONS FOR DYNAMIC ALLOCATION HEAP MEMORY MANAGEMENT LINKED LIST STRUCTURES DECLARING OPERATIONS ON A LINKED LIST POINTERS TO FUNCTIONS MORE COMPLEX OPERATIONS ON A LINKED LIST A PROGRAM TO TEST OUR LINKED LIST STRUCTURE OTHER DYNAMIC DATA STRUCTURES PART 4: INPUT AND OUTPUT EXPLORING FORMATTED OUTPUT TECHNICAL REQUIREMENTS REVISITING PRINTF() UNDERSTANDING THE GENERAL FORMAT SPECIFIER FORM USING FORMAT SPECIFIERS FOR UNSIGNED INTEGERS USING UNSIGNED INTEGERS IN DIFFERENT BASES CONSIDERING NEGATIVE NUMBERS AS UNSIGNED INTEGERS EXPLORING THE POWERS OF 2 AND 9 IN DIFFERENT BASES PRINTING POINTER VALUES USING FORMAT SPECIFIERS FOR SIGNED INTEGERS USING THE SIGNED INTEGER FIELD WIDTH, PRECISION, ALIGNMENT, AND ZERO-FILLING FORMATTING LONG-LONG INTEGERS POWERS OF 2 AND 9 WITH DIFFERENT MODIFIERS USING FORMAT SPECIFIERS FOR FLOATS AND DOUBLES USING THE FLOATING-POINT FIELD WIDTH, PRECISION, ALIGNMENT, AND ZERO-FILLING PRINTING DOUBLES IN HEXADECIMAL FORMAT PRINTING OPTIMAL FIELD WIDTHS FOR DOUBLES USING FORMAT SPECIFIERS FOR STRINGS AND CHARACTERS USING THE STRING FIELD WIDTH, PRECISION, ALIGNMENT, AND ZERO-FILLING EXPLORING THE SUBSTRING OUTPUT USING SINGLE CHARACTER FORMATTING GETTING INPUT FROM THE COMMAND LINE TECHNICAL REQUIREMENTS REVISITING THE MAIN() FUNCTION THE SPECIAL FEATURES OF MAIN() THE TWO FORMS OF MAIN() USING ARGC AND ARGV SIMPLE USE OF ARGC AND ARGV COMMAND-LINE SWITCHES AND COMMAND-LINE PROCESSORS EXPLORING FORMATTED INPUT TECHNICAL REQUIREMENTS INTRODUCING STREAMS UNDERSTANDING THE STANDARD OUTPUT STREAM UNDERSTANDING THE STANDARD INPUT STREAM REVISITING THE CONSOLE OUTPUT WITH PRINTF() AND FPRINTF() EXPLORING THE CONSOLE INPUT WITH SCANF() READING FORMATTED INPUT WITH SCANF() READING NUMERICAL INPUT WITH SCANF() USING A SCAN SET TO LIMIT POSSIBLE INPUT CHARACTERS CONTROLLING THE SCANF() INPUT FIELD WIDTH USING INTERNAL DATA CONVERSION USING SSCANF() AND SPRINTF() TO CONVERT VALUES INTO AND FROM STRINGS CONVERTING STRINGS INTO NUMBERS WITH ATOI() AND ATOD() EXPLORING UNFORMATTED I/O GETTING THE STRING I/O TO/FROM THE CONSOLE USING THE SIMPLE I/O OF STRINGS WITH GETS() AND PUTS() CREATING A SORTED LIST OF NAMES WITH FGETS() AND FPUTS() WORKING WITH FILES TECHNICAL REQUIREMENTS UNDERSTANDING BASIC FILE CONCEPTS REVISITING FILE STREAMS UNDERSTANDING THE PROPERTIES OF FILE STREAMS OPENING AND CLOSING A FILE UNDERSTANDING FILE OPERATIONS FOR EACH TYPE OF STREAM INTRODUCING THE FILESYSTEM ESSENTIALS GETTING ACQUAINTED WITH THE FILESYSTEM OPENING FILES FOR READING AND WRITING GETTING FILENAMES FROM WITHIN A PROGRAM GETTING FILENAMES FROM THE COMMAND LINE USING FILE INPUT AND FILE OUTPUT TECHNICAL REQUIREMENTS FILE PROCESSING PROCESSING FILENAMES FROM THE COMMAND LINE CREATING A FILE OF UNSORTED NAMES TRIMMING THE INPUT STRING FROM FGETS() READING NAMES AND WRITING NAMES READING UNSORTED NAMES AND SORTING THEM FOR OUTPUT USING A LINKED LIST TO SORT NAMES WRITING NAMES IN SORTED ORDER PART 5: BUILDING BLOCKS FOR LARGER PROGRAMS WORKING WITH MULTI-FILE PROGRAMS TECHNICAL REQUIREMENTS UNDERSTANDING MULTI-FILE PROGRAMS USING HEADER FILES FOR DECLARATIONS AND SOURCE FILES FOR DEFINITIONS CREATING SOURCE FILES THINKING ABOUT MULTIPLE SOURCE FILES CREATING HEADER FILES REVISITING THE PREPROCESSOR INTRODUCING PREPROCESSOR DIRECTIVES UNDERSTANDING THE LIMITS AND DANGERS OF THE PREPROCESSOR USING THE PREPROCESSOR EFFECTIVELY DEBUGGING WITH THE PREPROCESSOR CREATING A MULTI-FILE PROGRAM EXTRACTING CARD STRUCTURES AND FUNCTIONS EXTRACTING HAND STRUCTURES AND FUNCTIONS EXTRACTING DECK STRUCTURES AND FUNCTIONS FINISHING THE DEALER C PROGRAM BUILDING A MULTI-FILE PROGRAM UNDERSTANDING SCOPE TECHNICAL REQUIREMENTS DEFINING SCOPE – VISIBILITY, EXTENT, AND LINKAGE EXPLORING VISIBILITY EXPLORING EXTENT EXPLORING LINKAGE PUTTING VISIBILITY, EXTENT, AND LINKAGE ALL TOGETHER EXPLORING VARIABLE SCOPE UNDERSTANDING THE BLOCK SCOPE OF VARIABLES UNDERSTANDING FUNCTION PARAMETER SCOPE UNDERSTANDING FILE SCOPE UNDERSTANDING GLOBAL SCOPE UNDERSTANDING SCOPE FOR FUNCTIONS UNDERSTANDING SCOPE AND INFORMATION HIDING USING THE STATIC SPECIFIER FOR FUNCTIONS BUILDING MULTI-FILE PROGRAMS WITH MAKE TECHNICAL REQUIREMENTS PREPARING DEALER C FOR MAKE INTRODUCING THE MAKE UTILITY USING MACROS USING SPECIAL MACROS CREATING RULES – TARGETS, DEPENDENCIES, AND ACTIONS CREATING USEFUL RULES THAT HAVE ONLY ACTIONS PATTERN RULES AND % BUILT-IN FUNCTIONS CAVEMAN DEBUGGING IN YOUR MAKEFILE GOING FURTHER WITH MAKE CREATING TWO CARD PROGRAMS TECHNICAL REQUIREMENTS GAME ONE – BLACKJACK INTRODUCING BLACKJACK DETERMINING WHICH STRUCTURES AND FUNCTIONS WILL BE NEEDED CONSIDERING USER INTERACTION AND THE LIMITS OF A CONSOLE INTERFACE PREPARING SOURCE FILES FOR BLACKJACK IMPLEMENTING BLACKJACK CONSIDERING WAYS BLACKJACK COULD BE EXTENDED GAME TWO – ONE-HANDED SOLITAIRE INTRODUCING ONE-HANDED SOLITAIRE CONSIDERING USER INTERACTIONS AND THE LIMITS OF A CONSOLE INTERFACE IMPLEMENTING ONE-HANDED SOLITAIRE CONSIDERING WAYS ONE-HANDED SOLITAIRE COULD BE EXTENDED