C Programming For Dummies

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