book

Learn C Programming

Name: Learn C Programming
Author: Jeff Szuhay
ISBN: 9781789349917

by Jeff Szuhay

June 2020

Beginner

646 pages

14h 58m

English

Packt Publishing

Read now

Unlock full access

Title Page
Copyright and Credits
Learn C Programming
Dedication
About Packt
Why subscribe?
Contributors
About the authorAbout the reviewerPackt is searching for authors like you
Preface
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
Section 1: C Fundamentals
Running Hello, World!
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
Understanding Program Structure
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
Working with Basic Data Types
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

Using Variables and Assignment
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
Exploring Operators and Expressions
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
Exploring Conditional Program Flow
Technical requirementsUnderstanding conditional expressionsIntroducing the if()… else… complex statementUsing a switch()… complex statementIntroducing multiple if()… statementsUsing nested if()… else… statementsThe dangling else… problemSummary
Exploring Loops and Iteration
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
Creating and Using Enumerations
Technical requirementsIntroducing enumerationsDefining enumerationsUsing enumerationsThe switch()… statement revisitedSummary
Section 2: Complex Data Types
Creating and Using Structures
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
Creating Custom Data Types with typedef
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
Working with Arrays
Technical requirementsDeclaring and initializing arraysInitializing arraysAccessing array elementsAssigning values to array elementsOperating on arrays with loopsUsing functions that operate on arraysSummary
Working with Multi-Dimensional Arrays
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
Using Pointers
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
Understanding Arrays and Pointers
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
Working with Strings
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
Creating and Using More Complex Structures
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
Section 3: Memory Manipulation
Understanding Memory Allocation and Lifetime
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
Using Dynamic Memory Allocation
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
Section 4: Input and Output
Exploring Formatted Output
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
Getting Input from the Command Line
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
Exploring Formatted Input
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
Working with Files
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
Using File Input and File Output
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
Section 5: Building Blocks for Larger Programs
Working with Multi-File Programs
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
Understanding Scope
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
Appendix
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
Other Books You May Enjoy
Leave a review - let other readers know what you think

Content preview from Learn C Programming

Exploring Conditional Program Flow

Not only do the values of variables change when a program runs, but the flow of execution can also change through a program. The order of statement execution can be altered depending upon the results of conditional expressions. In a conditional program flow, there is one mandatory branch and one optional branch. If the condition is met, the first branch, or path, will be taken; if not, the second path will be taken.

We can illustrate such a branching with the following simple example:

Is today Saturday? If so, do the laundry. Else, go for a walk.

In this conditional statement, we are instructed to do the laundry if today is Saturday. For the remaining days that are not Saturday, we are instructed to go for ...

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.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781789349917

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learn C Programming

by Jeff Szuhay

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.