book

Learn C Programming - Second Edition

Name: Learn C Programming - Second Edition
Author: Jeff Szuhay
ISBN: 9781801078450

by Jeff Szuhay

August 2022

Beginner

742 pages

18h 3m

English

Packt Publishing

Read now

Unlock full access

Learn C Programming Second Edition
Contributors
About the authorAbout the reviewers
Preface
Preface to the Second EditionPreface to the First EditionWho this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your Thoughts
Part 1: C Fundamentals
Chapter 1: Running Hello, World!
Technical requirementsWriting your first C programHello, world!Understanding the program development cycleEditCompileRunVerifyRepeatCreating, 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
Chapter 2: 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 declarationsSummaryQuestions
Chapter 3: 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 fractionsRepresenting single charactersRepresenting Boolean true/falseUnderstanding the sizes of data typesThe sizeof() operatorRanges of valuesSummaryQuestions
Chapter 4: Using Variables and Assignments
Technical requirementsUnderstanding data types and valuesIntroducing variablesNaming variablesIntroducing explicit types of variablesUsing explicit typing with initializationExploring constantsLiteral constantsDefined valuesExplicitly typed constantsNaming constant variablesUsing types and assignmentsUsing explicit assignment – the simplest statementAssigning values by passing function parametersAssignment by the function return valueSummaryQuestions
Chapter 5: Exploring Operators and Expressions
Technical requirementsUnderstanding expressions and operationsIntroducing operations on numbersConsidering the special issues resulting from operations on numbersExploring type conversionUnderstanding implicit type conversion and valuesUsing explicit type conversion – castingIntroducing operations on charactersLogical operatorsRelational operatorsBitwise operatorsThe conditional operatorThe sequence operatorCompound assignment operatorsIncremental operatorsOrder of operations and groupingSummaryQuestions
Chapter 6: 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 problemSummaryQuestions

Chapter 7: Exploring Loops and Iterations
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 loopsSummaryQuestions
Chapter 8: Creating and Using Enumerations
Technical requirementsIntroducing enumerationsDefining enumerationsUsing enumerationsThe switch()… statement revisitedUsing enumerated item values as literal integer constantsSummaryQuestions
Part 2: Complex Data Types
Chapter 9: 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 OOPSummaryQuestions
Chapter 10: 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 typedefExploring some more useful compiler optionsUsing a header file for custom types and the typedef specifiersSummaryQuestions
Chapter 11: Working with Arrays
Technical requirementsDeclaring and initializing arraysInitializing arraysUnderstanding variable-length arraysAccessing array elementsAssigning values to array elementsOperating on arrays with loopsUsing functions that operate on arraysSummaryQuestions
Chapter 12: Working with Multi-Dimensional Arrays
Technical requirementsGoing beyond 1D arrays to multi-dimensional arraysRevisiting 1D arraysMoving on to 2D arraysMoving on to 3D arraysConsidering N-dimensional arraysDeclaring and initializing multi-dimensional arrays of various dimensionsDeclaring 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 arrays of various dimensionsManipulating multi-dimensional arrays using loops within loopsUsing nested loops to traverse a 2D arrayUsing nested loops to traverse a 3D arrayUsing multi-dimensional arrays in functionsSummaryQuestions
Chapter 13: 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*Accessing pointer targetsUnderstanding the void* typePointer 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 functionsSummaryQuestions
Chapter 14: Understanding Arrays and Pointers
Technical requirementsUnderstanding array names and pointersUnderstanding array elements and pointersAccessing array elements via pointersOperations on arrays using pointersUsing pointer arithmeticPassing arrays as function pointers revisitedInterchangeability of array names and pointersIntroducing an array of pointers to arrays SummaryQuestions
Chapter 15: 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 operationsSummaryQuestions
Chapter 16: 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 structureUsing 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.cSummaryQuestions
Part 3: Memory Manipulation
Chapter 17: 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 storageSummaryQuestions
Chapter 18: 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 managementThe 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 structuresSummaryQuestions
Part 4: Input and Output
Chapter 19: 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 the 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 substring outputUsing single character formattingSummaryQuestions
Chapter 20: Getting Input from the Command Line
Technical requirementsRevisiting the main() functionThe special features of main()The two forms of main()Using argc and argvSimple use of argc and argvCommand-line switches and command-line processorsSummaryQuestions
Chapter 21: 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 I/OGetting the string I/O to/from the consoleUsing the simple I/O of strings with gets() and puts()Creating a sorted list of names with fgets() and fputs()SummaryQuestions
Chapter 22: Working with Files
Technical requirementsUnderstanding basic file conceptsRevisiting file streamsUnderstanding the properties of FILE streamsOpening and closing a fileUnderstanding file operations for each type of streamIntroducing the filesystem essentialsGetting acquainted with the filesystemOpening files for reading and writingGetting filenames from within a programGetting filenames from the command line SummaryQuestions
Chapter 23: Using File Input and File Output
Technical requirementsFile processingProcessing filenames from 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 orderSummaryQuestions
Part 5: Building Blocks for Larger Programs
Chapter 24: Working with Multi-File Programs
Technical requirementsUnderstanding multi-file programsUsing header files for declarations and source files for definitionsCreating source filesThinking about multiple source filesCreating header filesRevisiting the preprocessorIntroducing preprocessor directivesUnderstanding the limits and 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 programSummaryQuestions
Chapter 25: Understanding Scope
Technical requirementsDefining scope – visibility, extent, and linkageExploring visibilityExploring extentExploring linkagePutting visibility, extent, and linkage all togetherExploring variable scopeUnderstanding the block scope of variablesUnderstanding function parameter scopeUnderstanding file scopeUnderstanding global scopeUnderstanding scope for functionsUnderstanding scope and information hidingUsing the static specifier for functionsSummaryQuestions
Chapter 26: Building Multi-File Programs with Make
Technical requirementsPreparing dealer.c for makeIntroducing the make utilityUsing macrosUsing special macrosCreating rules – targets, dependencies, and actionsCreating useful rules that have only actionsPattern rules and %Built-in functionsCaveman debugging in your makefileA general makefile for simple projectsGoing further with makeSummaryQuestions
Chapter 27: Creating Two Card Programs
Technical requirementsGame one – BlackjackIntroducing BlackjackDetermining which structures and functions will be neededConsidering user interaction and the limits of a console interfacePreparing source files for BlackjackImplementing BlackjackConsidering ways Blackjack could be extendedGame two – One-Handed SolitaireIntroducing One-Handed SolitaireDetermining which structures and functions will be neededConsidering user interactions and the limits of a console interfacePreparing source files for One-Handed SolitaireImplementing One-Handed SolitaireConsidering ways One-Handed Solitaire could be extendedSummary
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
Epilogue
Taking the next steps
Assessments
Chapter 2 – Understanding Program StructureChapter 3 – Working with Basic Data TypesChapter 4 – Using Variables and AssignmentsChapter 5 – Exploring Operators and ExpressionsChapter 6 – Exploring Conditional Program FlowChapter 7 – Exploring Loops and IterationChapter 8 – Creating and Using EnumerationsChapter 9 – Creating and Using StructuresChapter 10 – Creating Custom Data Types with typedefChapter 11 – Working with ArraysChapter 12 – Working with Multi-Dimensional ArraysChapter 13 – Using PointersChapter 14 – Understanding Arrays and PointersChapter 15 – Working with StringsChapter 16 – Creating and Using More Complex StructuresChapter 17 – Understanding Memory Allocation and LifetimeChapter 18 – Using Dynamic Memory AllocationChapter 19 – Exploring Formatted OutputChapter 20 – Getting Input from the Command LineChapter 21 – Exploring Formatted InputChapter 22 – Working with FilesChapter 23 – Using File Input and File OutputChapter 24 – Working with Multi-File ProgramsChapter 25 – Understanding Scope
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Learn C Programming - Second Edition

17 Understanding Memory Allocation and Lifetime

Every instance of a value—be it a literal, an intrinsic data type, or a complex data type—exists in memory. Here, we will explore various ways in which memory is allocated. The different mechanisms for memory allocation are called storage classes. In this chapter, we will review the storage class we've been using thus far, that of automatic storage, as well as introducing the static storage class. We will also explore the lifetime of each storage class, as well as introduce the scope of a storage class—internal versus external storage.

After exploring automatic and static storage classes, this chapter paves the way for a special and extremely flexible storage class—that of dynamic memory allocation. ...

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: 9781801078450

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learn C Programming - Second Edition

by Jeff Szuhay

17

Understanding Memory Allocation and Lifetime

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.