C How To Program 9th Edition

Getting Started with C How To Program 9th Edition

The Deitel C book is one of those textbooks that gets assigned a lot in university courses, and for reasons that aren't entirely positive. It's comprehensive, sometimes to a fault, and it tries to cover everything from basic syntax to file I/O and pointers in a way that assumes you've never written a line of code before. That's not inherently bad, but it does mean the pacing can feel relentless if you're working through it on your own time. Most people grab it from academic sites or torrent directories, though the official route is through Pearson or the publisher's website. The 9th edition came out around 2017 and is still widely used, though there are some known errata that persist across multiple printings. You'll want to check the publisher's errata page before blaming the book for code that doesn't behave as described.

What C How To Program 9th Edition Actually Covers

The book is structured around progressive chapters, starting with variables and control flow, moving into functions, arrays, pointers, structs, and eventually dynamic memory allocation and file handling. Each chapter includes practice exercises at the end, some of which are genuinely useful and others that feel like filler. The real value is in the worked examples, not the exercises. One thing the book does better than most is explain pointers gradually. It introduces the concept through simple variable references before jumping into pointer arithmetic, which is something a lot of C books skip entirely and just hand you a paragraph on indirection operators. The tradeoff is that by the time it gets to pointers, it's already been 200 pages in and you might be wondering why you haven't written anything that looks like a real program yet. I remember spending an afternoon trying to get one of the dynamic array examples to compile properly. The book uses variable-length arrays in a few places without clearly stating that this is a C99 feature, which means if you're compiling with a default C89 mode or an older compiler setup, you'll get errors that make it look like the code itself is broken. The workaround was straightforward—just pass -std=c99 to gcc—but that kind of issue comes up enough that it's worth noting early.

How to Use This Book Without Losing Your Mind

Don't read it cover to cover. The book is designed to be a course companion, not a novel, and treating it like one will just slow you down. Pick a chapter, read the relevant sections, type out the examples yourself, and then move on to practice problems that match whatever you actually want to build. If you're trying to learn C because you need it for embedded work, skip the sections on GUI programming with curses and focus on the data structure chapters. If you're going the systems route, spend extra time on pointers and memory management and skim the higher-level abstractions. The code examples in this edition are generally correct, but they tend to favor clarity over efficiency. A lot of the sorting and string manipulation examples use approaches that work fine for learning but would get laughed out of a production codebase. That's expected from a textbook, but it's worth keeping in mind so you don't pick up habits that would need unlearning later. One counter-intuitive thing about this book is that the earlier chapters on basic I/O and control structures actually contain more useful material than the later advanced chapters for someone self-teaching. The first third of the book will teach you more practical C than the second half if you actually type and modify every example instead of just reading them. The later chapters assume you're in a classroom where the instructor can fill in gaps, and without that support, some of the explanations on topics like function pointers and callback patterns feel rushed.

There's also a companion website that used to host source code and additional resources, but it's been inconsistent over the years. Sometimes the links work, sometimes they don't, and the book references it frequently enough that you'll hit dead ends. Archive.org has backups of some of the older material, and a few university repositories mirror the code samples. Not ideal, but functional.

Common Problems People Run Into

The biggest issue students hit with this book is that it introduces multiple ways to do the same thing without clearly explaining when to use which. String handling in C alone gets presented through scanf, fgets, strcpy, strcat, and then later through more modern alternatives, with the text rarely saying which one you should actually pick for a given situation. The result is that readers come away knowing how to use all of them and having no idea which one is appropriate. Another problem is the treatment of undefined behavior. The book mentions it in passing but doesn't drive the point home hard enough for someone who's never programmed in a systems language. You'll see examples where array bounds aren't checked and the text doesn't flag that this is a bug waiting to happen rather than acceptable shorthand. If you're coming from a managed language background, this gap will bite you. The exercises at the end of each chapter vary wildly in quality. Some are straightforward applications of the chapter material, while others require knowledge that hasn't been fully introduced yet. I'd recommend skipping the ones that seem to demand concepts from three chapters ahead and circling back to them after you've had time to absorb the fundamentals.

Who This Book Is Actually Good For

This works well as a reference or supplementary text if you already have some programming experience and just need to learn C. It's less ideal as a standalone resource for complete beginners because it moves fast and assumes a level of technical maturity that new programmers often don't have yet. A person who's never written code before would probably benefit more from pairing this with something slower-paced or from starting with a different resource entirely and using the Deitel book as a lookup guide. For university students, it's fine. It covers the standard curriculum material and the exercises are close enough to what professors assign that it serves its purpose. Don't expect it to make you a competent systems programmer on its own, though. You'll need additional hands-on work with debugging tools, memory profilers, and actual projects outside the textbook to get anywhere near that level. If you find the pacing too slow or the explanations too verbose, there are better free resources online. The Linux Documentation Project has a C tutorial that's more direct, and various university course notes online cover the same ground with less padding. But if you already have the book or it's required for a class, it's serviceable. Just don't treat it as the final word on C programming and you'll avoid most of the frustration that comes with it.