Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

You Will Learn C!

Zed Shaw has crafted the perfect course for the beginning C programmer eager to advance their skills in any language. Follow it and you will learn the many skills early and junior programmers need to succeed–just like the hundreds of thousands of programmers Zed has taught to date! You bring discipline, commitment, persistence, and experience with any programming language; the author supplies everything else.

 

In Learn C the Hard Way , you’ll learn C by working through 52 brilliantly crafted exercises. Watch Zed Shaw’s teaching video and read the exercise. Type his code precisely. (No copying and pasting!) Fix your mistakes. Watch the programs run. As you do, you’ll learn what good, modern C programs look like; how to think more effectively about code; and how to find and fix mistakes far more efficiently. Most importantly, you’ll master rigorous defensive programming techniques, so you can use any language to create software that protects itself from malicious activity and defects.

 

Through practical projects you’ll apply what you learn to build confidence in your new skills. Shaw teaches the key skills you need to start writing excellent C software, including

 

  • Setting up a C environment
  • Basic syntax and idioms
  • Compilation, make files, and linkers
  • Operators, variables, and data types
  • Program control
  • Arrays and strings
  • Functions, pointers, and structs
  • Memory allocation
  • I/O and files
  • Libraries
  • Data structures, including linked lists, sort, and search
  • Stacks and queues
  • Debugging, defensive coding, and automated testing
  • Fixing stack overflows, illegal memory access, and more
  • Breaking and hacking your own C code

 

It’ll Be Hard at First. But Soon, You’ll Just Get It–And That Will Feel Great!

This tutorial will reward you for every minute you put into it. Soon, you’ll know one of the world’s most powerful programming languages. You’ll be a C programmer.

1124173457
Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

You Will Learn C!

Zed Shaw has crafted the perfect course for the beginning C programmer eager to advance their skills in any language. Follow it and you will learn the many skills early and junior programmers need to succeed–just like the hundreds of thousands of programmers Zed has taught to date! You bring discipline, commitment, persistence, and experience with any programming language; the author supplies everything else.

 

In Learn C the Hard Way , you’ll learn C by working through 52 brilliantly crafted exercises. Watch Zed Shaw’s teaching video and read the exercise. Type his code precisely. (No copying and pasting!) Fix your mistakes. Watch the programs run. As you do, you’ll learn what good, modern C programs look like; how to think more effectively about code; and how to find and fix mistakes far more efficiently. Most importantly, you’ll master rigorous defensive programming techniques, so you can use any language to create software that protects itself from malicious activity and defects.

 

Through practical projects you’ll apply what you learn to build confidence in your new skills. Shaw teaches the key skills you need to start writing excellent C software, including

 

  • Setting up a C environment
  • Basic syntax and idioms
  • Compilation, make files, and linkers
  • Operators, variables, and data types
  • Program control
  • Arrays and strings
  • Functions, pointers, and structs
  • Memory allocation
  • I/O and files
  • Libraries
  • Data structures, including linked lists, sort, and search
  • Stacks and queues
  • Debugging, defensive coding, and automated testing
  • Fixing stack overflows, illegal memory access, and more
  • Breaking and hacking your own C code

 

It’ll Be Hard at First. But Soon, You’ll Just Get It–And That Will Feel Great!

This tutorial will reward you for every minute you put into it. Soon, you’ll know one of the world’s most powerful programming languages. You’ll be a C programmer.

28.49 In Stock
Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

by Zed Shaw
Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

Learn C the Hard Way: Practical Exercises on the Computational Subjects You Keep Avoiding (Like C)

by Zed Shaw

eBook

$28.49  $37.99 Save 25% Current price is $28.49, Original price is $37.99. You Save 25%.

Available on Compatible NOOK devices, the free NOOK App and in My Digital Library.
WANT A NOOK?  Explore Now

Related collections and offers


Overview

You Will Learn C!

Zed Shaw has crafted the perfect course for the beginning C programmer eager to advance their skills in any language. Follow it and you will learn the many skills early and junior programmers need to succeed–just like the hundreds of thousands of programmers Zed has taught to date! You bring discipline, commitment, persistence, and experience with any programming language; the author supplies everything else.

 

In Learn C the Hard Way , you’ll learn C by working through 52 brilliantly crafted exercises. Watch Zed Shaw’s teaching video and read the exercise. Type his code precisely. (No copying and pasting!) Fix your mistakes. Watch the programs run. As you do, you’ll learn what good, modern C programs look like; how to think more effectively about code; and how to find and fix mistakes far more efficiently. Most importantly, you’ll master rigorous defensive programming techniques, so you can use any language to create software that protects itself from malicious activity and defects.

 

Through practical projects you’ll apply what you learn to build confidence in your new skills. Shaw teaches the key skills you need to start writing excellent C software, including

 

  • Setting up a C environment
  • Basic syntax and idioms
  • Compilation, make files, and linkers
  • Operators, variables, and data types
  • Program control
  • Arrays and strings
  • Functions, pointers, and structs
  • Memory allocation
  • I/O and files
  • Libraries
  • Data structures, including linked lists, sort, and search
  • Stacks and queues
  • Debugging, defensive coding, and automated testing
  • Fixing stack overflows, illegal memory access, and more
  • Breaking and hacking your own C code

 

It’ll Be Hard at First. But Soon, You’ll Just Get It–And That Will Feel Great!

This tutorial will reward you for every minute you put into it. Soon, you’ll know one of the world’s most powerful programming languages. You’ll be a C programmer.


Product Details

ISBN-13: 9780133124378
Publisher: Pearson Education
Publication date: 08/10/2015
Series: Zed Shaw's Hard Way Series
Sold by: Barnes & Noble
Format: eBook
Pages: 384
File size: 26 MB
Note: This product may take a few minutes to download.
Age Range: 18 Years

About the Author

Zed Sha w is an avid guitar player, programmer, and writer whose books teach people all over the world how to write software. His books Learn Python the Hard Way and Learn Ruby the Hard Way (both now in their third editions) have been read by millions of people around the world. His software has been used by many large and small companies. His essays are often quoted and read by members of many geek communities. An entertaining and lively writer, he will keep you laughing and make you think.

 

Table of Contents

Acknowledgments          xiv


This Book Is Not Really about C          xv

The Undefined Behaviorists          xvi

C Is a Pretty and Ugly Language          xvii

What You Will Learn          xviii

How to Read This Book          xviii

The Videos          xix

 

Exercise 0: The Setup            2

Linux   2

Mac OS X    2

Windows     3

Text Editor     3

 

Exercise 1: Dust Off That Compiler           6

Breaking It Down   6

What You Should See    7

How to Break It    8

Extra Credit    8

 

Exercise 2: Using Makefiles to Build           10

Using Make   10

What You Should See    11

How to Break It    12

Extra Credit    12

 

Exercise 3: Formatted Printing           14

What You Should See    15

External Research    15

How to Break It   15

Extra Credit    16

 

Exercise 4: Using a Debugger         18

GDB Tricks    18

GDB Quick Reference    18

LLDB Quick Reference    19

 

Exercise 5: Memorizing C Operators         20

How to Memorize    20

The List of Operators    21

 

Exercise 6: Memorizing C Syntax           26

The Keywords    26

Syntax Structures    27

A Word of Encouragement   30

A Word of Warning    31

 

Exercise 7: Variables and Types              32

What You Should See    34

How to Break It    34

Extra Credit    34

 

Exercise 8: If, Else-If, Else           36

What You Should See    37

How to Break It    37

Extra Credit    38

 

Exercise 9: While-Loop and Boolean Expressions           40

What You Should See    40

How to Break It    41

Extra Credit    41

 

Exercise 10: Switch Statements           42

What You Should See    43

How to Break It    44

Extra Credit    44

 

Exercise 11: Arrays and Strings            46

What You Should See   47

How to Break It    48

Extra Credit    48

 

Exercise 12: Sizes and Arrays           50

What You Should See    51

How to Break It    52

Extra Credit    53

 

Exercise 13: For-Loops and Arrays of Strings           54

What You Should See    56

Understanding Arrays of Strings    56

How to Break It    57

Extra Credit    57

 

Exercise 14: Writing and Using Functions             58

What You Should See    59

How to Break It    60

Extra Credit    60

 

Exercise 15: Pointers, Dreaded Pointers           62

What You Should See    64

Explaining Pointers     65

Practical Pointer Usage    66

The Pointer Lexicon    66

Pointers Aren’t Arrays     67

How to Break It    67

Extra Credit    67

 

Exercise 16: Structs and Pointers to Them            68

What You Should See    71

Explaining Structures    71

How to Break It    72

Extra Credit    72

 

Exercise 17: Heap and Stack Memory Allocation          74

What You Should See    79

Heap versus Stack Allocation    80

How to Break It    81

Extra Credit    82


Exercise 18: Pointers to Functions               84

What You Should See    88

How to Break It    88

Extra Credit    89

 

Exercise 19: Zed’s Awesome Debug Macros           90

The C Error-Handling Problem   90

The Debug Macros    91

Using dbg.h    93

What You Should See    95

How the CPP Expands Macros    96

Extra Credit    98

 

Exercise 20: Advanced Debugging Techniques            100

Debug Printing versus GDB    100

A Debugging Strategy   101

Extra Credit    102

 

Exercise 21: Advanced Data Types and Flow Control           104

Available Data Types    104

Available Operators   108

Available Control Structures    110

Extra Credit    111

 

Exercise 22: The Stack, Scope, and Globals            112

ex22.h and ex22.c    112

ex22_main.c    114

What You Should See    117

Scope, Stack, and Bugs    118

How to Break It    119

Extra Credit    119

 

Exercise 23: Meet Duff’s Device           120

What You Should See   124

Solving the Puzzle    124

Extra Credit    125

 

Exercise 24: Input, Output, Files          126

What You Should See     128

How to Break It    129

The I/O Functions    129

Extra Credit    130

 

Exercise 25: Variable Argument Functions           132

What You Should See     135

How to Break It   136

Extra Credit   136

 

Exercise 26: Project logfind           138

The logfind Specification    138

 

Exercise 27: Creative and Defensive Programming           140

The Creative Programmer Mind-Set    140

The Defensive Programmer Mind-Set    141

The Eight Defensive Programmer Strategies    141

Applying the Eight Strategies    142

Order Is Not Important    149

Extra Credit    150

 

Exercise 28: Intermediate Makefiles           152

The Basic Project Structure    152

Makefile    153

What You Should See   159

Extra Credit    159

 

Exercise 29: Libraries and Linking            160

Dynamically Loading a Shared Library    161

What You Should See    163

How to Break It   164

Extra Credit    164

 

Exercise 30: Automated Testing          166

Wiring Up the Test Framework    167

Extra Credit    171

 

Exercise 31: Common Undefined Behavior           172

UB 20    173

 

Exercise 32: Double Linked Lists          174

What Are Data Structures  178

Making the Library    178

Doubly Linked Lists    179

Tests    185

What You Should See    187

How to Improve It    188

Extra Credit    188

 

Exercise 33: Linked List Algorithms           190

Bubble and Merge Sort    190

The Unit Test   191

The Implementation    193

What You Should See    195

How to Improve It    196

Extra Credit    197

 

Exercise 34: Dynamic Array          198

Advantages and Disadvantages    205

How to Improve It    206

Extra Credit    206

 

Exercise 35: Sorting and Searching           208

Radix Sort and Binary Search    211

How to Improve It    221

Extra Credit   222

 

Exercise 36: Safer Strings            224

Why C Strings Were a Horrible Idea    224

Using bstrlib    225

Learning the Library    226

 

Exercise 37: Hashmaps          228

The Unit Test    235

How to Improve It    238

Extra Credit    238

 

Exercise 38: Hashmap Algorithms    240

What You Should See    245

How to Break It    246

Extra Credit    247

 

Exercise 39: String Algorithms          248

What You Should See    255

Analyzing the Results    257

Extra Credit   258

 

Exercise 40: Binary Search Trees          260

How to Improve It    273

Extra Credit    273

 

Exercise 41: Project devpkg          274

What Is devpkg?    274

Project Layout   277

The Makefile    277

The Source Files    278

The Final Challenge    295

 

Exercise 42: Stacks and Queues            296

What You Should See   299

How to Improve It    299

Extra Credit    299

 

Exercise 43: A Simple Statistics Engine             300

Rolling Standard Deviation and Mean    300

Implemention    301

How to Use It    306

Extra Credit    307

 

Exercise 44: Ring Buffer              310

The Unit Test    313

What You Should See    313

How to Improve It    314

Extra Credit    314

 

Exercise 45: A Simple TCP/IP Client             316

Augment the Makefile    316

The netclient Code    316

What You Should See    320

How to Break It    320

Extra Credit    321

 

Exercise 46: Ternary Search Tree            322

Advantages and Disadvantages    330

How to Improve It    331

Extra Credit    331

 

Exercise 47: A Fast URL Router             332

What You Should See    335

How to Improve It    335

Extra Credit    336

 

Exercise 48: A Simple Network Server               338

The Specification    338

 

Exercise 49: A Statistics Server          340

Specification    340

 

Exercise 50: Routing the Statistics            342

 

Exercise 51: Storing the Statistics             344

The Specification    344

 

Exercise 52: Hacking and Improving Your Server             346

 

Next Steps            348

 

Index               349

 

From the B&N Reads Blog

Customer Reviews