book

Learn C Programming

by Jeff Szuhay

June 2020

Beginner

646 pages

14h 58m

English

Packt Publishing

Read now

Unlock full access

Learn C Programming
Why subscribe?
About the authorAbout the reviewerPackt is searching for authors like you
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
Technical requirementsWriting your first C programHello, world!Understanding the program development cycleEditCompileMany C compilers for every OSA note about IDEsInstalling a compiler on Linux, macOS, or WindowsRunVerifyRepeatA note about debuggingCreating, typing, and saving your first C programCompiling your first C programRunning your first C programWriting comments to clarify the program laterSome guidelines on commenting codeAdding comments to the Hello, world! programLearning to experiment with codeSummary
Technical requirementsIntroducing statements and blocksExperimenting with statements and blocksUnderstanding delimitersUnderstanding whitespaceIntroducing statementsIntroducing functionsUnderstanding function definitionsExploring function identifiersExploring the function blockExploring function return valuesPassing in values with function parametersOrder of executionUnderstanding function declarationsSummary
Technical requirementsUnderstanding data typesBytes and chunks of dataRepresenting whole numbersRepresenting positive and negative whole numbersSpecifying different sizes of integersRepresenting numbers with decimalsRepresenting single charactersRepresenting Boolean true/falseUnderstanding the sizes of data typesThe sizeof() operatorRanges of valuesSummary

Technical requirementsUnderstanding types and valuesIntroducing variablesNaming variablesIntroducing explicit types of variablesUsing explicit typing with initializationExploring constantsLiteral constantsDefined valuesExplicitly typed constantsNaming constant variablesUsing types and assignmentUsing explicit assignment, the simplest statementAssigning values by passing function parametersAssignment by the function return valueSummary
Technical requirementsExpressions and operationsIntroducing operations on numbersConsidering the special issues resulting from operations on numbersUnderstanding NaNUnderstanding underflow NaNUnderstanding overflow NaNConsidering precisionExploring type conversionUnderstanding implicit type conversion and valuesUsing explicit type conversion – castingIntroducing operations on charactersExploring logical and relational operatorsBitwise operatorsThe conditional operatorThe sequence operatorCompound assignment operatorsMultiple assignments in a single expressionIncremental operatorsPostfix versus prefix incrementationOrder of operations and groupingSummary
Technical requirementsUnderstanding conditional expressionsIntroducing the if()… else… complex statementUsing a switch()… complex statementIntroducing multiple if()… statementsUsing nested if()… else… statementsThe dangling else… problemSummary
Technical requirementsUnderstanding repetitionUnderstanding brute-force repetitionIntroducing the while()… statementIntroducing the for()… statementIntroducing the do … while() statementUnderstanding loop equivalencyUnderstanding unconditional branching – the dos and (mostly) don'ts of gotoFurther controlling loops with break and continueUnderstanding infinite loopsSummary
Technical requirementsIntroducing enumerationsDefining enumerationsUsing enumerationsThe switch()… statement revisitedSummary
Technical requirementsUnderstanding structuresDeclaring structuresInitializing structures and accessing structure elementsPerforming operations on structures – functionsStructures of structuresInitializing structures with functionsPrinting a structure of structures – reusing functionsThe stepping stone to object-oriented programmingSummary
Technical requirementsRenaming intrinsic types with typedefUsing synonymsSimplifying the use of enum types with typedefSimplifying the use of struct types with typedefOther uses of typedefSome more useful compiler optionsUsing a header file for custom types and the typedef specifiersSummary
Technical requirementsDeclaring and initializing arraysInitializing arraysAccessing array elementsAssigning values to array elementsOperating on arrays with loopsUsing functions that operate on arraysSummary
Technical requirementsGoing beyond one-dimensional arrays to multi-dimensional arraysRevisiting one-dimensional arraysMoving on to two-dimensional arraysMoving on to three-dimensional arraysConsidering N-dimensional arraysDeclaring and initializing multi-dimensional arraysDeclaring arrays of two dimensionsInitializing arrays of two dimensionsDeclaring arrays of three dimensionsInitializing arrays of three dimensionsDeclaring and initializing arrays of N dimensionsAccessing elements of multi-dimensional arraysManipulating multi-dimensional arrays – loops within loopsUsing nested loops to traverse a two-dimensional arrayUsing nested loops to traverse a three-dimensional arrayUsing multi-dimensional arrays in functionsSummary
Technical requirementsAddressing pointers – the boogeyman of C programmingWhy use pointers at all?Introducing pointersUnderstanding direct addressing and indirect addressingUnderstanding memory and memory addressingManaging and accessing memoryExploring some analogies in the real worldDeclaring the pointer type, naming pointers, and assigning addressesDeclaring the pointer typeNaming pointersAssigning pointer values (addresses)Operations with pointersAssigning pointer valuesDifferentiating between the NULL pointer and void*Understanding the void* typeAccessing pointer targetsPointer arithmeticComparing pointersVerbalizing pointer operationsVariable function argumentsPassing values by referencePassing addresses to functions without pointer variables Pointers to pointersUsing pointers to structuresAccessing structures and their elements via pointersUsing pointers to structures in functionsSummary
Technical requirementsUnderstanding array names and pointersUnderstanding array elements and pointersAccessing array elements via pointersOperations on arrays using pointersUsing pointer arithmeticUsing the increment operatorPassing arrays as function pointers revisitedInterchangeability of array names and pointersIntroducing an array of pointers to arrays Summary
Technical requirementsCharacters – the building blocks of stringsThe char type and ASCIIBeyond ASCII – UTF-8 and UnicodeOperations on charactersGetting information about charactersManipulating charactersExploring C stringsAn array with a terminatorStrengths of C stringsWeaknesses of C stringsDeclaring and initializing a stringString declarationsInitializing stringsPassing a string to a functionEmpty strings versus null stringsHello, World! revisitedCreating and using an array of stringsCommon operations on strings – the standard libraryCommon functionsSafer string operationsSummary
Technical requirementsIntroducing the need for complex structures Revisiting card4.hUnderstanding an array of structuresCreating an array of structuresAccessing structure elements within an arrayManipulating an array of structuresUsing a structure with other structuresCreating a structure consisting of other structuresAccessing structure elements within the structureManipulating a structure consisting of other structuresUsing a structure with arraysUnderstanding randomness and random number generatorsCreating a structure with an arrayAccessing array elements within a structureManipulating array elements within a structureRevisiting the hand structureRevisiting hand operationsUsing a structure with an array of structuresCreating a structure with an array of structuresAccessing individual structure elements of the array within a structureManipulating a structure with an array of structuresCompleting carddeck.cRevisiting the deck structureRevisiting deck operationsA basic card programSummary
Technical requirementsDefining storage classesUnderstanding automatic versus dynamic storage classesAutomatic storageDynamic storageUnderstanding internal versus external storage classesInternal or local storage classesExternal or global storage classesThe lifetime of automatic storageExploring the static storage classInternal static storageExternal static storageThe lifetime of static storageSummary
Technical requirementsIntroducing dynamic memoryA brief tour of C's memory layoutAllocating and releasing dynamic memoryAllocating dynamic memoryReleasing dynamic memoryAccessing dynamic memoryThe lifetime of dynamic memorySpecial considerations for dynamic allocationHeap memory managementMemory leaksThe linked list dynamic data structureLinked list structuresDeclaring operations on a linked listPointers to functionsMore complex operations on a linked listA program to test our linked list structureOther dynamic data structuresSummary
Technical requirementsRevisiting printf()Understanding the general format specifier formUsing format specifiers for unsigned integersUsing unsigned integers in different basesConsidering negative numbers as unsigned integersExploring powers of 2 and 9 in different basesPrinting pointer valuesUsing format specifiers for signed integersUsing the signed integer field width, precision, alignment, and zero-fillingFormatting long-long integersPowers of 2 and 9 with different modifiersUsing format specifiers for floats and doublesUsing the floating-point field width, precision, alignment, and zero-fillingPrinting doubles in hexadecimal formatPrinting optimal field widths for doublesUsing format specifiers for strings and charactersUsing the string field width, precision, alignment, and zero-fillingExploring the sub-string outputUsing single character formattingSummary
Technical requirementsRevisiting the main() functionThe special features of main()The two forms of main()Using argc and argvA simple use of argc and argvCommand-line switches and command-line processorsSummary
Technical requirementsIntroducing streamsUnderstanding the standard output streamUnderstanding the standard input streamRevisiting the console output with printf() and fprintf()Exploring the console input with scanf()Reading formatted input with scanf()Reading numerical input with scanf()Reading string and character input with scanf()Using a scan set to limit possible input charactersControlling the scanf() input field width Using internal data conversionUsing sscanf() and sprintf() to convert values into and from stringsConverting strings into numbers with atoi() and atod()Exploring unformatted input and outputGetting the string input and output to/from the consoleUsing the simple input and output of strings with gets() and puts()Understanding why using gets() could be dangerousCreating a sorted list of names with fgets() and fputs()Summary
Technical requirementsUnderstanding basic file conceptsRevisiting file streamsUnderstanding the properties of the FILE streamsOpening and closing a fileUnderstanding file operations for each type of streamIntroducing the filesystem essentialsIntroducing the filesystemUnderstanding a file pathUnderstanding a filenameOpening files for reading and writingGetting filenames from within the programGetting filenames from the command line Summary
Technical requirementsFile processingCreating a template program to process filenames given on the command lineCreating a file of unsorted namesTrimming the input string from fgets()Reading names and writing namesReading unsorted names and sorting them for outputUsing a linked list to sort namesWriting names in sorted orderSummary
Technical requirementsUnderstanding multi-file programsUsing header files for declarations and source files for definitionsCreating source filesCreating header filesRevisiting the preprocessorUnderstanding the limits and dangers of the preprocessorKnowing some dangers of the preprocessorUsing the preprocessor effectivelyDebugging with the preprocessorCreating a multi-file programExtracting Card structures and functionsExtracting Hand structures and functionsExtracting Deck structures and functionsFinishing the dealer.c programBuilding a multi-file programSummary
Technical requirementsDefining scope – visibility, extent, and linkageExploring visibilityExploring extentExploring linkageUnderstanding compilation unitsPutting visibility, extent, and linkage all togetherExploring variable scopeUnderstanding the block scope of variablesUnderstanding function parameter scopeUnderstanding file scopeUnderstanding global scopeUnderstanding function scopeUnderstanding scope and information hidingUsing the static specifier for functionsSummaryEpilogTaking the next stepsMore advanced C topicsMore advanced programming topicsPicking a project for yourselfResources
C definition and keywordsC keywordsTable of operators and their precedenceSummary of useful GCC and Clang compiler optionsASCII character setThe Better String Library (Bstrlib)A quick introduction to BstrlibA few simple examplesUnicode and UTF-8A brief historyWhere we are todayMoving from ASCII to UTF-8A UTF-to-Unicode exampleThe C standard libraryMethod 1Method 2Method 3
Leave a review - let other readers know what you think

Content preview from Learn C Programming

Exploring Loops and Iteration

Some operations need to be repeated one or more times before their result is completely evaluated. The code to be repeated could be copied the required number of times, but this would be cumbersome. Instead, for this, there are loops—for …, while …, and do … while loops. Loops are for statements that must be evaluated multiple times. We will explore C loops. After considering loops, the much-maligned goto statement will be considered.

The following topics will be covered in this chapter:

Understanding brute-force repetition and why it might be bad
Exploring looping with the while()… statement
Exploring looping with the for()… statement
Exploring looping with the do … while() statement
Understanding when you ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

Learn C Programming - Second Edition

Jeff Szuhay

Programming in C, Fourth Edition

Stephen G. Kochan

C Programming Language, 2nd Edition

Brian W. Kernighan, Dennis Ritchie

Modern C for Absolute Beginners: A Friendly Introduction to the C Programming Language

Slobodan Dmitrović

Publisher Resources

ISBN: 9781789349917Supplemental Content