Learn C on the Mac: For OS X and IOS

Cover
Contents at a Glance
Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1 Go Get the Tools!
Installing Xcode
How much is that IDE in the Window?
What’s a Registered Developer?
Getting the Projects
Using Xcode
Creating a New Xcode Project
The Workspace Window
Running a Project
Moving On
Chapter 2 Programming Basics
Programming
Some Alternatives to C
What About Objective-C, C#, C++, and Java?
What’s the Best Programming Language for the Mac or iOS Devices?
The Programming Process
Source Code
Compiling Your Source Code
Building Your Application
What’s Next?
Chapter 3 C Basics: Statements and Functions
C Statements
C Functions
Defining a Function
Syntax Errors and Algorithms
Calling a Function
Same Program, Two Functions
The Hello2 Project
The Hello2 Source Code
Running Hello2
Doing That Again, and Again, and Again
Generating Some Errors
Fixing the Problem
Getting Close
C is Case Sensitive
Exploring Xcode’s Built-In Manuals
Getting Help Quickly
What’s Next?
Chapter 4 C Basics: Variables and Operators
An Introduction to Variables
Working with Variables
Variable Names
The Size of a Type
Bytes and Bits
Going from 1 Byte to 2 Bytes
Operators
The +, -, ++, and -- Operators
The += and -= Operators
The *, /, %, *=, /=, and %= Operators
Using Parentheses
Operator Precedence
Sample Programs
Opening Operator.xcodeproj
Stepping Through the Operator Source Code
Opening Postfix.xcode
Stepping Through the Postfix Source Code
Sprucing Up Your Code
Source Code Spacing
Comment Your Code
The Curly Brace Controversy
What’s Next?
Chapter 5 Debugging
What’s a Debugger?
Controlling Execution
Setting Breakpoints
Stepping Over a Statement
Stepping Into a Function
Stepping Out of a Function
Full Speed Ahead
Examining Variables
How is a Debugger like an Iceberg?
What’s Next?
Chapter 6 Controlling Your Program’s Flow
Flow Control
The if Statement
Expressions
True Expressions
Comparative Operators
Logical Operators
TruthTester.xcodeproj
Compound Expressions
Statements
The Curly Braces
Where to Place the Semicolon
Two Common Pitfalls
The while Statement
The for Statement
LoopTester.xcodeproj
The do Statement
The switch Statement
A case with No Statements
The Mixed Blessing of Fall-Through
switch Wrap-Up
Breaks in Loops
The continue Statement
IsOdd.xcodeproj
Stepping Through the IsOdd Source Code
NextPrime.xcodeproj
Stepping Through the NextPrime Source Code
What’s Next?
Chapter 7 Pointers and Parameters
What Is a Pointer?
Why Use Pointers?
Checking Out of the Library
Pointer Basics
The Address of a Variable
The & Operator
Declaring a Pointer Variable
The * Operator
Function Parameters
Variable Scope
How Function Parameters Work
Parameters Are Temporary
The Difference Between Arguments and Parameters
Function Return Value
printf() Returns a Value
Multiple Return Statements
Returning Nothing at All
Putting it All Together
Using Pointers as Parameters
Factor.xcodeproj
Some Pointers on Pointers
Pass-By-Value vs. Pass-By-Reference
The NULL Pointer Value
The Dark Side of Pointers
Global and Static Variables
Global Variables
Adding Globals to Your Programs
Static Variables
What’s Next?
Chapter 8 More Data Types
Data Types Beyond Int
FloatSizer
The Integer Types
IntSizer.xcodeproj
The Long and Short of ints
The Best int for the Job
Semantic Types
Exact-Width Types
Integer vs. Floating Point
Working with Characters
The ASCII Character Set
ASCII.xcodeproj
Stepping Through the ASCII Source Code
Arrays
Why Use Arrays?
Dice.xcode
Stepping Through the Dice Source Code
Danger, Will Robinson!
The #define Directive
Using #defines in Your Code
Stepping Through the Preprocessor
The Advantages of Using #define Directives
Function-like #define Macros
Text Strings
A Text String in Memory
FullName.xcodeproj
Overflow.xcodeproj
What’s Next?
Chapter 9 The Command Line
Command Line Basics
Command Arguments
Learning More About Commands
Where Shell Commands Come From
Creating a Command-Line Tool
Command Arguments and main()
SeeArgs.xcodeproj
Deploying the Program
Using Paths
Current Directory and Relative Paths
Special Directory Names
The Home Directory Name
Installing a Command-Line Tool
Creating a Private bin Directory
Installing the Tool
Configuring the PATH Variable
Character Input
Pipes
Redirection
Namer.xcodeproj
Pointer Arithmetic
Comparing Pointers
Pointer Addition
Subtracting Pointers
WordCount.xcodeproj
Stepping Through the WordCount Source Code
Testing WordCount in the Shell
RomanNumeral.xcodeproj
main()
NumberToRomanNumeral()
One Last Word About the Command-Line Interface
What’s Next?
Chapter 10 Designing Your Own Data Structures
Bundling Data
Model A: Three Arrays
MultiArray.xcodeproj
Model B: The Structure Approach
StructSize.xcodeproj
Passing a struct As a Parameter
Passing a Copy of the struct
ParamAddress.xcodeproj
struct Arrays
Allocating Your Own Memory
Using malloc()
free()
Keeping Track of That Address!
Working with Linked Lists
Why Use Linked Lists?
Creating a Linked List
DVDTracker.xcodeproj
Stepping Through the DVDTracker Source Code
What’s Next?
Chapter 11 Working With Files
What Is a Data File?
File Basics
Understanding File Names
Opening and Closing a File
Reading a File
PrintFile.xcodeproj
Stepping Through the PrintFile Source Code
Writing Files
DVDFiler.xcodeproj
Fancier File Manipulation
The Update Modes
Random File Access
Using Random Access Functions
DinoEdit.xcodeproj
Text vs. Data Files
Working with Endians
Making RomanNumeral a Better Tool
Stepping Through RomanNumeral.xcodeproj
Putting RomanNumeral Through Its Paces
File System Objects
What’s Next?
Chapter 12 Handling Errors
Murphy’s Law
Rule #1: Never Assume
Assumptions About Variables
Check Ranges
Tolerate All Possible Values
Assert Your Assumptions
Rule #2: Stay Alert
Pay Attention to Return Values
errno
Rule #3: Have an Escape Plan
Follow the Success
Early Return
Skip Past Failure
Percolate Errors Up
Exit, Stage Left
The Long Jump
Rule #4: Anticipate Problems
Rule #5: Pick Your Battles
What’s Next?
Chapter 13 Advanced Topics
Type Conversion
Conversion Rules
Conversion Warnings
Typecasting
Typecasting Pointers
const Modifier
Creating Your Own Types
struct typedefs
Forward References
Enumerated Types
Unions
Why Use Unions?
Recursion
The Iterative Approach
A Recursive Approach
Function Pointers
The Remaining Operators
Getting More From The Libraries
Sorting with the Standard Library
Collections in Core Foundation
What’s Next?
Chapter 14 Where Do You Go from Here?
The Mac User Interface
Learning Objective-C
Learning Cocoa and Cocoa Touch
A Bit of OS X Code
A Quick iOS App
Just a Touch of Objective-C
Go Get ‘Em
Appendix: Answers to Exercises
Index
Numers and Symbols
A
B
C
D
E
F
G
H
I, J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X, Y
Z