C Programming For Dummies

Dan Gookin has been writing about technology for more than 30 years—and wrote the very first For Dummies book in 1991! Since then he's written gizmo- and tech innovation-focused bestseller after bestseller, including Word 2019 For Dummies, Android For Dummies, 2nd Edition, and many more!

Introduction 1

Why the C Language? 1

The C Programming For Dummies Approach 2

How This Book Works 3

Icons Used in This Book 4

Parting Thoughts 5

Part 1: The ABs of C 7

Chapter 1: A Quick Start for the Impatient 9

What You Need to Program 9

Command Prompt Programming 10

IDE Programming 11

Installing Code::Blocks 12

Touring the Code::Blocks workspace 13

Your First Program 14

Coding at the command prompt 15

Building a new Code::Blocks project 16

Building and running 18

Chapter 2: The Programming Thing 21

The History of Programming 21

Reviewing early programming history 21

Introducing the C language 22

The Programming Process 23

Understanding programming 23

Writing source code 24

Compiling and linking 26

Running and testing 27

Chapter 3: Anatomy of C 29

Parts of the C Language 29

Keywords 30

Functions 31

Operators 33

Variables and values 33

Statements and structure 33

Comments 35

Behold the Typical C Program 37

Understanding C program structure 37

Setting the main() function 38

Returning something to the operating system 39

Adding a function 40

Part 2: C Programming 101 43

Chapter 4: Trials and Errors 45

Display Stuff on the Screen 45

Displaying a humorous message 45

Introducing the puts() function 46

Adding more text 47

Commenting out a statement 49

Goofing up on purpose 49

More Text Output Nonsense 51

Displaying text with printf() 52

Introducing the printf() function 52

Understanding the newline 53

Employing escape sequences 54

Goofing up on purpose again 55

Chapter 5: Values and Simple Math 57

A Venue for Various Values 57

Understanding values 58

Displaying values with printf() 59

Minding the extra zeros 61

The Computer Does the Math 61

Doing simple arithmetic 61

Reviewing the float-integer thing 63

Pretending integers are floats 64

Chapter 6: A Place to Put Stuff 67

Values That Vary 67

Setting up a quick example 68

Introducing data types 69

Using variables 70

Variable Madness! 73

Using more-specific data types 73

Working with several variables 75

Assigning a value upon creation 77

Reusing variables 77

Constants Always the Same 79

Using the same value over and over 79

Constants in your code 80

Putting constants to use 81

Chapter 7: Input and Output 83

Character I/O 83

Understanding input and output devices 83

Fetching characters with getchar() 84

Using the putchar() function 86

Working with character variables 87

Text I/O, but Mostly I 88

Storing strings 89

Introducing the scanf() function 90

Reading a string with scanf() 91

Reading values with scanf() 93

Using fgets() for text input 94

Chapter 8: Decision Making 97

What If? 97

Making a simple comparison 97

Introducing the if keyword 99

Comparing values in various ways 100

Knowing the difference between = and == 102

Forgetting where to put the semicolon 103

Multiple Decisions 104

Making more-complex decisions 104

Adding a third option 105

Multiple Comparisons with Logic 106

Building a logical comparison 106

Adding some logical operators 107

The Old Switch Case Trick 108

Making a multiple-choice selection 108

Understanding the switch-case structure 110

Taking no breaks 111

The Weird ?: Decision Thing 112

Chapter 9: Loops, Loops, Loops 115

A Little Déjà Vu 115

The Thrill of for Loops 116

Doing something x number of times 116

Introducing the for loop 117

Counting with the for statement 119

Looping letters 120

Nesting for loops 121

The Joy of the while Loop 123

Structuring a while loop 123

Using the do while loop 125

Loopy Stuff 126

Looping endlessly 126

Looping endlessly but on purpose 127

Breaking out of a loop 128

Adding multiple for loop conditions 129

Screwing up a loop 130

Chapter 10: Fun with Functions 133

Anatomy of a Function 133

Constructing a function 133

Prototyping (or not) 136

Functions and Variables 139

Using variables in functions 139

Sending a value to a function 140

Sending multiple values to a function 142

Creating functions that return values 143

Returning early 145

Constants of the Global Kind 147

Introducing defined constants 147

Putting defined constants to use 148

Part 3: Build Upon What You Know 151

Chapter 11: The Unavoidable Math Chapter 153

Math Operators from Beyond Infinity 153

Incrementing and decrementing 154

Prefixing the ++ and -- operators 156

Discovering the remainder (modulus) 158

Saving time with assignment operators 158

Math Function Mania 160

Exploring some common math functions 161

Suffering through trigonometry 163

It’s Totally Random 166

Spewing random numbers 166

Making the numbers more random 167

The Holy Order of Precedence 170

Getting the order correct 170

Forcing order with parentheses 171

Chapter 12: Give Me Arrays 173

Behold the Array 173

Avoiding arrays 173

Understanding arrays 174

Initializing an array 177

Playing with character arrays (strings) 177

Working with empty char arrays 179

Sorting arrays 181

Multidimensional Arrays 183

Making a two-dimensional array 183

Going crazy with three-dimensional arrays 186

Declaring an initialized multidimensional array 188

Arrays and Functions 189

Passing an array to a function 189

Returning an array from a function 191

Chapter 13: Fun with Text 193

Character Manipulation Functions 193

Introducing the CTYPEs 193

Testing characters 195

Changing characters 197

String Functions Galore 198

Reviewing string functions 198

Comparing text 199

Building strings 200

Fun with printf() Formatting 202

Formatting floating point 202

Setting the output width 204

Aligning output 206

Gently Down the Stream 207

Demonstrating stream input 207

Dealing with stream input 208

Chapter 14: Structures, the Multivariable 211

Hello, Structure 211

Introducing the multivariable 211

Understanding struct 213

Filling a structure 215

Making an array of structures 216

Weird Structure Concepts 218

Putting structures within structures 218

Passing a structure to a function 219

Chapter 15: Life at the Command Prompt 221

Conjure a Terminal Window 221

Starting a terminal window 222

Running code in text mode 223

Arguments for the main() Function 225

Reading the command line 225

Understanding main()’s arguments 227

Time to Bail 229

Quitting the program 229

Running another program 230

Chapter 16: Variable Nonsense 233

Variable Control 233

Typecasting into disbelief 233

Creating new things with typedef 235

Making static variables 238

Variables, Variables Everywhere 241

Using external variables 241

Creating an external structure variable 243

Enumerating 245

Chapter 17: Binary Mania 249

Binary Basics 249

Understanding binary 249

Outputting binary values 251

Bit Manipulation 253

Using the bitwise | operator 253

Using bitwise & 256

Operating exclusively with XOR 257

Understanding the ~ and ! operators 259

Shifting binary values 259

Explaining the binbin() function 263

The Joy of Hex 264

Part 4: The Advanced Part 267

Chapter 18: Introduction to Pointers 269

The Biggest Problem with Pointers 269

Sizing Up Variable Storage 270

Understanding variable storage 270

Reading a variable’s size 271

Checking a variable’s location 275

Reviewing variable storage info 278

The Hideously Complex Topic of Pointers 279

Introducing the pointer 279

Working with pointers 282

Chapter 19: Deep into Pointer Land 285

Pointers and Arrays 285

Getting the address of an array 285

Working pointer math in an array 287

Substituting pointers for array notation 293

Strings Are Pointer-Things 294

Using pointers to display a string 294

Using a pointer to declare a string 295

Building an array of pointers 296

Sorting strings 300

Pointers in Functions 302

Passing a pointer to a function 302

Returning a pointer from a function 303

Chapter 20: Memory Chunks and Linked Lists 305

Give Me Memory! 306

Introducing the malloc() function 306

Creating string storage 308

Using the calloc() function 309

Getting more memory 311

Freeing memory 313

Lists That Link 314

Allocating space for a structure 314

Creating a linked list 316

Editing a linked list 323

Saving a linked list 328

Chapter 21: It’s About Time 329

What Time is It? 329

Understanding the calendar 330

Working with time in C 330

Time to Program 331

Checking the clock 331

Viewing a timestamp 333

Slicing through the time string 334

Snoozing 336

Part 5: And the Rest of It 337

Chapter 22: Permanent Storage Functions 339

Sequential File Access 339

Understanding C file access 340

Writing text to a file 341

Reading text from a file 342

Appending text to a file 345

Writing binary data 346

Reading binary data 348

Random File Access 350

Writing a structure to a file 351

Reading and rewinding 353

Finding a specific record 355

Saving a linked list to a file 357

Chapter 23: File Management 359

Directory Madness 359

Calling up a directory 359

Gathering more file info 361

Separating files from directories 363

Exploring the directory tree 364

Fun with Files 365

Renaming a file 365

Copying a file 367

Deleting a file 368

Chapter 24: Beyond Mere Mortal Projects 369

The Multi-Module Monster 369

Linking two source code files 370

Sharing variables between modules 372

Creating a custom header file 374

Other Libraries to Link 378

Chapter 25: Out, Bugs! 381

Simple Tricks to Resolve Problems 381

Documenting the flow 382

Talking through your code 382

Writing comments for future-you 382

The Debugger 383

Debugging setup 383

Working the debugger 385

Setting a breakpoint 387

Watching variables 388

Improved Error Messages 390

Part 6: The Part of Tens 393

Chapter 26: Ten Common Boo-Boos 395

Conditional Foul-Ups 395

== v = 396

Dangerous Loop Semicolons 397

Commas in for Loops 398

Missing break in a switch Structure 398

Missing Parentheses and Curly Brackets 399

Don’t Ignore a Warning 399

Endless Loops 400

scanf() Blunders 401

Streaming Input Restrictions 402

Chapter 27: Ten Reminders and Suggestions 403

Maintain Good Posture 404

Use Creative Names 404

Write a Function 405

Work on Your Code a Little Bit at a Time 405

Break Apart Larger Projects into Several Modules 406

Know What a Pointer is 406

Add Whitespace before Condensing 407

Know When if-else Becomes switch-case 407

Remember Assignment Operators 408

When You Get Stuck, Read Your Code Out Loud 409

Part 7: Appendices 411

Appendix A: ASCII Codes 413

Appendix B: Keywords 419

Appendix C: Operators 421

Appendix D: Data Types 423

Appendix E: Escape Sequences 425

Appendix F: Conversion Characters 427

Appendix G: Order of Precedence 429

Index 431