Learn C on the Mac: For OS X and iOS by David Mark and James Bucanek -- Read -- Imperial Library of Trantor

Index

Coverpage Titlepage Copyright Dedication 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

← Prev
Back
Next →

← Prev
Back
Next →