Details

C Programming For Dummies

2. Aufl.

von: Dan Gookin
22,99 €
Verlag:	Wiley
Format:	PDF
Veröffentl.:	29.09.2020
ISBN/EAN:	9781119740254
Sprache:	englisch
Anzahl Seiten:	464

In den Warenkorb

Als Gutschein

DRM-geschütztes eBook, Sie benötigen z.B. Adobe Digital Editions und eine Adobe ID zum Lesen.

Beschreibungen

Titelbeschreibung

Get an A grade in C As with any major language, mastery of C can take you to some very interesting new places. Almost 50 years after it first appeared, it's still the world's most popular programming language and is used as the basis of global industry's core systems, including operating systems, high-performance graphics applications, and microcontrollers. This means that fluent C users are in big demand at the sharp end in cutting-edge industries—such as gaming, app development, telecommunications, engineering, and even animation—to translate innovative ideas into a smoothly functioning reality. To help you get to where you want to go with C, this 2nd edition of C Programming For Dummies covers everything you need to begin writing programs, guiding you logically through the development cycle: from initial design and testing to deployment and live iteration. By the end you'll be au fait with the do's and don'ts of good clean writing and easily able to produce the basic—and not-so-basic—building blocks of an elegant and efficient source code. <ul> <li>Write and compile source code</li> <li>Link code to create the executable program</li> <li>Debug and optimize your code</li> <li>Avoid common mistakes</li> </ul> Whatever your destination: tech industry, start-up, or just developing for pleasure at home, this easy-to-follow, informative, and entertaining guide to the C programming language is the fastest and friendliest way to get there!

Inhaltsverzeichnis

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

Autorenportrait

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!

Back cover copy

<ul> <li>Discover C language and start coding in no time</li> <li>Build your knowledge to create advanced projects and programs</li> <li>Kickstart your new career as a C programmer</li> </ul> Get an A grade in C Learning C can take you to some very interesting new places. Because it's the world's most popular programming language, fluent users are in high demand in cutting-edge industries, such as gaming, app development, telecomms, and even animation. This essential easy-to-follow, and fully updated resource covers everything you need to begin writing and applying good, clean code—from initial design and testing to deployment and live iteration. Whatever your destination with C, this is the fastest and friendliest way to get there. Inside... <ul> <li>Obtain free programming tools</li> <li>Create and debug code</li> <li>Explore text input and output</li> <li>Understand computer math</li> <li>Master data types</li> <li>Get friendly with pointers</li> <li>Explore files and structures</li> <li>Avoid silly mistakes</li> </ul>