ios 7 programming fundamentals

www.it-ebooks.info
www.it-ebooks.info
Matt Neuburg
iOS 7 Programming
Fundamentals
Objective-C, Xcode, and Cocoa Basics
www.it-ebooks.info
iOS 7 Programming Fundamentals
by Matt Neuburg
Copyright © 2014 Matt Neuburg. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (). For more information, contact our corporate/
institutional sales department: 800-998-9938 or
Editor: Rachel Roumeliotis
Production Editor: Kristen Brown
Proofreader: O’Reilly Production Services
Indexer: Matt Neuburg
Cover Designer: Karen Montgomery
Interior Designer: David Futato
Illustrator: Matt Neuburg
October 2013:
First Edition
Revision History for the First Edition:
2013-10-10: First release
See for release details.
Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly
Media, Inc. iOS 7 Programming Fundamentals, the image of a harp seal, and related trade dress are trade‐
marks of O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as

trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trade‐
mark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and authors assume
no responsibility for errors or omissions, or for damages resulting from the use of the information contained
herein.
ISBN: 978-1-491-94557-5
[LSI]
www.it-ebooks.info
Table of Contents
Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi
Part I. Language
1.
Just Enough C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Compilation, Statements, and Comments 5
Variable Declaration, Initialization, and Data Types 6
Structs 9
Pointers 11
Arrays 13
Operators 15
Flow Control and Conditions 17
Functions 21
Pointer Parameters and the Address Operator 24
Files 25
The Standard Library 29
More Preprocessor Directives 30
Data Type Qualifiers 31
2.
Object-Based Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Objects 33
Messages and Methods 34

Classes and Instances 35
Class Methods 37
Instance Variables 38
iii
www.it-ebooks.info
The Object-Based Philosophy 40
3. Objective-C Objects and Messages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
An Object Reference Is a Pointer 45
Instance References, Initialization, and nil 47
Instance References and Assignment 50
Instance References and Memory Management 51
Methods and Messages 52
Calling a Method 53
Declaring a Method 54
Nesting Method Calls 55
No Overloading 56
Parameter Lists 57
When Message Sending Goes Wrong 58
Messages to nil 59
Unrecognized Selectors 60
Typecasting and the id Type 61
Messages as Data Type 65
C Functions 67
CFTypeRefs 68
Blocks 69
4.
Objective-C Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Subclass and Superclass 75
Interface and Implementation 77
Header File and Implementation File 79

Class Methods 81
The Secret Life of Classes 82
5.
Objective-C Instances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
How Instances Are Created 85
Ready-Made Instances 85
Instantiation from Scratch 86
Nib-Based Instantiation 90
Polymorphism 91
The Keyword self 93
The Keyword super 97
Instance Variables and Accessors 98
Key–Value Coding 101
Properties 103
iv | Table of Contents
www.it-ebooks.info
How to Write an Initializer 104
Referring to Instances 108
Part II. IDE
6. Anatomy of an Xcode Project. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
New Project 114
The Project Window 116
The Navigator Pane 117
The Utilities Pane 123
The Editor 124
The Project File and Its Dependents 127
The Target 130
Build Phases 131
Build Settings 133
Configurations 134

Schemes and Destinations 135
Renaming Parts of a Project 138
From Project to Running App 139
Build Settings 141
Property List Settings 142
Nib Files 143
Additional Resources 144
Code and the App Launch Process 146
Frameworks and SDKs 150
7.
Nib Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
A Tour of the Nib Editor Interface 156
The Document Outline 158
Canvas 161
Inspectors and Libraries 163
Nib Loading 164
Outlets and the Nib Owner 167
Creating an Outlet 172
Misconfiguring an Outlet 174
Deleting an Outlet 175
More Ways to Create Outlets 176
Outlet Collections 180
Action Connections 180
Table of Contents | v
www.it-ebooks.info
Additional Initialization of Nib-Based Instances 183
8. Documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
The Documentation Window 188
Class Documentation Pages 190
Sample Code 193

Other Resources 194
Quick Help 194
Symbols 195
Header Files 196
Internet Resources 197
9. Life Cycle of a Project. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Device Architecture and Conditional Code 199
Version Control 203
Editing Your Code 206
Autocompletion 207
Snippets 209
Fix-it and Live Syntax Checking 209
Navigating Your Code 210
Running in the Simulator 213
Debugging 214
Caveman Debugging 214
The Xcode Debugger 217
Unit Testing 223
Static Analyzer 227
Clean 229
Running on a Device 230
Obtaining a Certificate 233
Obtaining a Development Provisioning Profile 235
Running the App 237
Profile and Device Management 237
Gauges and Instruments 238
Localization 244
Archiving and Distribution 249
Ad Hoc Distribution 251
Final App Preparations 252

Icons in the App 253
Other Icons 255
Launch Images 256
vi | Table of Contents
www.it-ebooks.info
Screenshots 257
Property List Settings 258
Submission to the App Store 260
Part III. Cocoa
10.
Cocoa Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Subclassing 265
Categories 268
Splitting a Class 270
Class Extensions 271
Protocols 272
Informal Protocols 276
Optional Methods 277
Some Foundation Classes 278
Useful Structs and Constants 278
NSString and Friends 279
NSDate and Friends 281
NSNumber 282
NSValue 284
NSData 284
Equality and Comparison 284
NSIndexSet 285
NSArray and NSMutableArray 286
NSSet and Friends 288
NSDictionary and NSMutableDictionary 288

NSNull 291
Immutable and Mutable 291
Property Lists 292
The Secret Life of NSObject 293
11.
Cocoa Events. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Reasons for Events 298
Subclassing 298
Notifications 300
Receiving a Notification 301
Unregistering 303
Posting a Notification 304
NSTimer 305
Table of Contents | vii
www.it-ebooks.info
Delegation 306
Cocoa Delegation 306
Implementing Delegation 308
Data Sources 311
Actions 312
The Responder Chain 315
Deferring Responsibility 316
Nil-Targeted Actions 316
Swamped by Events 317
Delayed Performance 320
12.
Accessors and Memory Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Accessors 323
Key–Value Coding 324
KVC and Outlets 326

Key Paths 327
Array Accessors 328
Memory Management 329
Principles of Cocoa Memory Management 330
The Rules of Cocoa Manual Memory Management 331
What ARC Is and What It Does 334
How Cocoa Objects Manage Memory 336
Autorelease 338
Memory Management of Instance Variables (Non-ARC) 341
Memory Management of Instance Variables (ARC) 345
Retain Cycles and Weak References 346
Unusual Memory Management Situations 349
Nib Loading and Memory Management 354
Memory Management of Global Variables 355
Memory Management of CFTypeRefs 356
Memory Management of Pointer-to-Void Context Info 359
Properties 361
Property Memory Management Policies 362
Property Declaration Syntax 363
Property Accessor Synthesis 365
Dynamic Accessors 368
13.
Communication Between Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Visibility by Instantiation 374
Visibility by Relationship 376
viii | Table of Contents
www.it-ebooks.info
Global Visibility 377
Notifications 378
Key–Value Observing 379

Model–View–Controller 385
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Table of Contents | ix
www.it-ebooks.info
www.it-ebooks.info
Preface
After three editions of my book on programming iOS — Programming iOS 4 (May
2011), Programming iOS 5 (March 2012), and Programming iOS 6 (March 2013) — it
is as if a friendly but powerful giant had ripped the book in two, just after the end of
Part III (Chapter 13). There are now two books:
• This book, iOS 7 Programming Fundamentals, comprising chapters 1–13 of the
earlier books.
• The other book, Programming iOS 7, comprising chapters 14–40 of the earlier
books.
The giant was friendly, because it was high time. Programming iOS 6 had grown to an
unwieldy and forbidding 1150 pages. In fact, I had been begging for this giant even
before Programming iOS 4 was published — indeed, before it was even conceived of.
My original proposal to O’Reilly Media, back in early 2010, had been for a book to be
called Fundamentals of Cocoa Programming, intended to cover very much the same
material as the present book, iOS 7 Programming Fundamentals. But the proposal was
accepted only on condition that it be extended to cover much more of Cocoa Touch
(iOS) programming; so I complied and set to work on this longer project, and later,
despite my impassioned pleas in the autumn of 2010, I was unable to persuade the
publisher to break up the lengthy manuscript into two: by that time, all the king’s horses
and all the king’s men could no longer crack Humpty Dumpty apart.
The new situation, therefore, is just what I always wanted in the first place — but not
quite, because what I most desired was a single book in two volumes. My idea was that
the books would have the same title, distinguished as Volume I and Volume II, with
successive numbering of pages and chapters: if Volume I ended, say, with Chapter 13
and page 400, then Volume II would start with Chapter 14 and page 401. To this de‐

lightfully Victorian extreme, I’m sorry to say, O’Reilly Media were implacably opposed.
Thus, Programming iOS 7, though it starts with its own Chapter 1 and page 1, never‐
theless still picks up exactly where iOS 7 Programming Fundamentals leaves off. They
xi
www.it-ebooks.info
complement and supplement one another. Those who desire a complete grounding in
the knowledge needed to begin writing iOS apps with a solid and rigorous understand‐
ing of what they are doing and where they are heading will, I hope, obtain both books.
At the same time, the two-book architecture should, I believe, render the size and scope
of each book individually more acceptable and attractive to more readers.
Those who feel that they know already all there is to know about C, Objective-C, Xcode,
and the linguistic and architectural basis of the Cocoa framework, or who are content
to pick up such underpinnings as they go along, need no longer (as some in the past
have done) complain that the book is occupied with 13 preliminary chapters before the
reader starts really writing any significant iOS code, because those 13 chapters have now
been abstracted into a separate volume, iOS 7 Programming Fundamentals, and the
other book, Programming iOS 7, now begins, like Homer’s Iliad, in the middle of the
story, with the reader jumping with all four feet into views and view controllers, and
with a knowledge of the language and the Xcode IDE already presupposed. And if such
a reader subsequently changes his or her mind and decides that a thorough grounding
in those underpinnings might in fact be desirable, iOS 7 Programming Fundamentals
will still be available and awaiting study.
As for this book, iOS 7 Programming Fundamentals itself, it is the prodigal child, the
book I originally wanted to write but which was then subsumed during three editions
into the larger world of Programming iOS 4, Programming iOS 5, and Programming iOS
6. Now it is home again, where it belongs, in a volume of its own. Its three parts teach
the underlying basis of all iOS programming:
• Part I introduces the Objective-C language, starting with C (which constitutes much
more of practical Objective-C than many beginners realize) and then building up
to the object-oriented concepts and mechanics of classes and instances.

•
Part II takes a break from language and turns to Xcode, the world in which all iOS
programming ultimately takes place. It explains what an Xcode project is and how
it is transformed into an app, and how to work comfortably and nimbly with Xcode
to consult the documentation and to write, navigate, and debug code, as well as how
to bring your app through the subsequent stages of running on a device and sub‐
mission to the App Store. There is also a very important chapter on nibs and the
nib editor (Interface Builder), including outlets and actions as well as the mechanics
of nib loading; however, such specialized topics as autolayout constraints in the nib
are postponed to the other book.
• Part III returns to Objective-C, this time from the point of view of the Cocoa Touch
framework. Cocoa provides important foundational classes and adds linguistic and
architectural devices such as categories, protocols, delegation, and notifications, as
well as the pervasive responsibilities of memory management. Key–value coding
and key–value observing are also discussed here.
xii | Preface
www.it-ebooks.info
The reader of this book will thus get a thorough grounding in the fundamental knowl‐
edge and techniques that any good iOS programmer needs. The book itself doesn’t show
how to write any particularly interesting iOS apps (though it is backed by dozens of
example projects that you can download from my GitHub site, />neub/Programming-iOS-Book-Examples), but it does constantly use my own real apps
and real programming situations to illustrate and motivate its explanations. And then
you’ll be ready for Programming iOS 7, of course!
Versions
This book is geared to iOS 7 and Xcode 5. In general, only very minimal attention is
given to earlier versions of iOS and Xcode. It is not my intention to embrace in this book
any detailed knowledge about earlier versions of the software, which is, after all, readily
and compendiously available in my earlier books. There are, nevertheless, a few words
of advice about backwards compatibility, and now and then I will call out a particularly
noteworthy change from earlier versions. For example, it has been hard to refrain from

pointing out the confusing accretions of interface and terminology caused by the
changes in how the status bar works and in the sizes of icons and launch images.
Xcode 5 no longer offers the user, creating a new app project from one of the project
templates, an option as to whether or not to use Automatic Reference Counting (ARC),
the compiler-based manual memory management technology that has made life so
much easier for iOS programmers in recent years. ARC is simply turned on by default.
Therefore, this book assumes from the outset that you are using ARC. I do still quite
often distinguish the ARC compiler behavior from the non-ARC compiler behavior,
but I no longer describe what the non-ARC behavior is, except in Chapter 12 where I
still explain what ARC does by describing what you would have to do if you weren’t
using it.
Xcode also no longer provides a template-based option as to whether or not to use a
storyboard. All projects (except the Empty Application template) come with a main
storyboard, and there is no option to use a main .xib file instead. Taking my cue from
this, I have adapted my teaching style to assume that storyboards are primary and that
you’ll usually be using one. I do also show how to construct a project whose nibs come
entirely from .xib files; this is more work than in the past, because you can’t do it simply
by unchecking a checkbox in the template-creation dialog.
I have also embraced, often without much fanfare, the various other iOS 7 and Xcode
5 innovations. Apple has clearly set out, with this generation of their software, to make
iOS programming easier and more pleasant than ever; and by and large they have suc‐
ceeded. Such innovations as modules and autolinking, asset catalogs, the Accounts
preference pane, and the Test navigator contrive to make your life far more comfortable,
and I simply assume as a matter of course that you will want to use them.
Preface | xiii
www.it-ebooks.info
Acknowledgments
My thanks go first and foremost to the people at O’Reilly Media who have made writing
a book so delightfully easy: Rachel Roumeliotis, Sarah Schneider, Kristen Brown, and
Adam Witwer come particularly to mind. And let’s not forget my first and long-standing

editor, Brian Jepson, who had nothing whatever to do with this edition, but whose
influence is present throughout.
I have been saved from many embarrassing errors by the sharp and dedicated eyes of
Peter Olsen, a long-time reader who faithfully posts notes to the book’s online Errata
page, apparently just because that’s the kind of amazing and dedicated person he is.
As in the past, I have been greatly aided by some fantastic software, whose excellences
I have appreciated at every moment of the process of writing this book. I should like to
mention, in particular:
• git ()
• SourceTree ()
•
TextMate ()
• AsciiDoc ( />• BBEdit ( />• Snapz Pro X ()
• GraphicConverter ()
•
OmniGraffle ()
The book was typed and edited entirely on my faithful Unicomp Model M keyboard
(), without which I could never have done so much writing over
so long a period so painlessly. For more about my physical work environment, see http://
matt.neuburg.usesthis.com.
From the Programming iOS 4 Preface
The popularity of the iPhone, with its largely free or very inexpensive apps, and the
subsequent popularity of the iPad, have brought and will continue to bring into the fold
many new programmers who see programming for these devices as worthwhile and
doable, even though they may not have felt the same way about OS X. Apple’s own annual
WWDC developer conventions have reflected this trend, with their emphasis shifted
from OS X to iOS instruction.
The widespread eagerness to program iOS, however, though delightful on the one hand,
has also fostered a certain tendency to try to run without first learning to walk. iOS gives
the programmer mighty powers that can seem as limitless as imagination itself, but it

also has fundamentals. I often see questions online from programmers who are evidently
xiv | Preface
www.it-ebooks.info
deep into the creation of some interesting app, but who are stymied in a way that reveals
quite clearly that they are unfamiliar with the basics of the very world in which they are
so happily cavorting.
It is this state of affairs that has motivated me to write this book, which is intended to
ground the reader in the fundamentals of iOS. I love Cocoa and have long wished to
write about it, but it is iOS and its popularity that has given me a proximate excuse to
do so. Here I have attempted to marshal and expound, in what I hope is a pedagogically
helpful and instructive yet ruthlessly Euclidean and logical order, the principles on
which sound iOS programming rests, including a good basic knowledge of Objective-
C (starting with C itself) and the nature of object-oriented programming, advice on the
use of the tools, the full story on how Cocoa objects are instantiated, referred to, put in
communication with one another, and managed over their lifetimes, and a survey of
the primary interface widgets and other common tasks. My hope, as with my previous
books, is that you will both read this book cover to cover (learning something new often
enough to keep you turning the pages) and keep it by you as a handy reference.
This book is not intended to disparage Apple’s own documentation and example
projects. They are wonderful resources and have become more wonderful as time goes
on. I have depended heavily on them in the preparation of this book. But I also find that
they don’t fulfill the same function as a reasoned, ordered presentation of the facts. The
online documentation must make assumptions as to how much you already know; it
can’t guarantee that you’ll approach it in a given order. And online documentation is
more suitable to reference than to instruction. A fully written example, no matter how
well commented, is difficult to follow; it demonstrates, but it does not teach.
A book, on the other hand, has numbered chapters and sequential pages; I can assume
you know C before you know Objective-C for the simple reason that Chapter 1 precedes
Chapter 2. And along with facts, I also bring to the table a degree of experience, which
I try to communicate to you. Throughout this book you’ll see me referring to “common

beginner mistakes”; in most cases, these are mistakes that I have made myself, in addition
to seeing others make them. I try to tell you what the pitfalls are because I assume that,
in the course of things, you will otherwise fall into them just as naturally as I did as I
was learning. You’ll also see me construct many examples piece by piece or extract and
explain just one tiny portion of a larger app. It is not a massive finished program that
teaches programming, but an exposition of the thought process that developed that
program. It is this thought process, more than anything else, that I hope you will gain
from reading this book.
Conventions Used in This Book
The following typographical conventions are used in this book:
Italic
Indicates new terms, URLs, email addresses, filenames, and file extensions.
Preface | xv
www.it-ebooks.info
Constant width
Used for program listings, as well as within paragraphs to refer to program elements
such as variable or function names, databases, data types, environment variables,
statements, and keywords.
Constant width bold
Shows commands or other text that should be typed literally by the user.
Constant width italic
Shows text that should be replaced with user-supplied values or by values deter‐
mined by context.
This icon signifies a tip, suggestion, or general note.
This icon indicates a warning or caution.
Using Code Examples
Supplemental material (code examples, exercises, etc.) is available for download at
/>This book is here to help you get your job done. In general, if example code is offered
with this book, you may use it in your programs and documentation. You do not need
to contact us for permission unless you’re reproducing a significant portion of the code.

For example, writing a program that uses several chunks of code from this book does
not require permission. Selling or distributing a CD-ROM of examples from O’Reilly
books does require permission. Answering a question by citing this book and quoting
example code does not require permission. Incorporating a significant amount of ex‐
ample code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title,
author, publisher, and ISBN. For example: “iOS 7 Programming Fundamentals by Matt
Neuburg (O’Reilly). Copyright 2014 Matt Neuburg, 978-1-491-94557-5.”
If you feel your use of code examples falls outside fair use or the permission given above,
feel free to contact us at
xvi | Preface
www.it-ebooks.info
Safari® Books Online
Safari Books Online is an on-demand digital library that delivers
expert content in both book and video form from the world’s lead‐
ing authors in technology and business.
Technology professionals, software developers, web designers, and business and crea‐
tive professionals use Safari Books Online as their primary resource for research, prob‐
lem solving, learning, and certification training.
Safari Books Online offers a range of product mixes and pricing programs for organi‐
zations, government agencies, and individuals. Subscribers have access to thousands of
books, training videos, and prepublication manuscripts in one fully searchable database
from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Pro‐
fessional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John
Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT
Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technol‐
ogy, and dozens more. For more information about Safari Books Online, please visit us
online.
How to Contact Us
Please address comments and questions concerning this book to the publisher:

O’Reilly Media, Inc.
1005 Gravenstein Highway North
Sebastopol, CA 95472
800-998-9938 (in the United States or Canada)
707-829-0515 (international or local)
707-829-0104 (fax)
We have a web page for this book, where we list errata, examples, and any additional
information. You can access this page at />tals.
To comment or ask technical questions about this book, send email to

For more information about our books, courses, conferences, and news, see our website
at .
Find us on Facebook: />Follow us on Twitter: />Watch us on YouTube: />Preface | xvii
www.it-ebooks.info
www.it-ebooks.info
PART I
Language
Apple has provided a vast toolbox for programming iOS to make an app come to life
and behave the way you want it to. That toolbox is the API (application programming
interface). To use the API, you must speak the API’s language. That language, for the
most part, is Objective-C, which itself is built on top of C; some pieces of the API use
C itself. This part of the book instructs you in the basics of these languages:
•
Chapter 1 explains C. In general, you will probably not need to know all the ins and
outs of C, so this chapter restricts itself to those aspects of C that you need to know
in order to use both Objective-C and the C-based areas of the API.
• Chapter 2 prepares the ground for Objective-C, by discussing object-based pro‐
gramming in general architectural terms. It also explains some extremely important
words that will be used throughout the book, along with the concepts that lie behind
them.

• Chapter 3 introduces the basic syntax of Objective-C.
•
Chapter 4 continues the explanation of Objective-C, discussing the nature of
Objective-C classes, with emphasis on how to create a class in code.
•
Chapter 5 completes the introduction to Objective-C, discussing how instances are
created and initialized, along with an explanation of such related topics as poly‐
morphism, instance variables, accessors, self and super, key–value coding, and
properties.
We’ll return in Part III to a description of further aspects of the Objective-C language
— those that are particularly bound up with the Cocoa frameworks.
www.it-ebooks.info
www.it-ebooks.info
Do you believe in C? Do you believe in anything
that has to do with me?
—Leonard Bernstein and Stephen Schwartz,
Mass
CHAPTER 1
Just Enough C
To program for iOS, you need to speak to iOS. Everything you say to iOS will be in
accordance with the iOS API. (An API, for application programming interface, is a list
or specification of things you are allowed to say when communicating.) Therefore, you
will need some knowledge of the C programming language, for two reasons:
• Most of the iOS API involves the Objective-C language, and most of your iOS
programming will be in the Objective-C language. Objective-C is a superset of C.
This means that Objective-C presupposes C; everything that is true of C trickles up
to Objective-C. A common mistake is to forget that “Objective-C is C” and to ne‐
glect a basic understanding of C.
• Some of the iOS API involves C rather than Objective-C. Even in Objective-C code,
you often need to use C data structures and C function calls. For example, a rectangle

is represented as a CGRect, which is a C struct, and to create a CGRect from four
numbers you call CGRectMake, which is a C function. The iOS API documentation
will very often show you C expressions and expect you to understand them.
The best way to learn C is to read The C Programming Language (PTR Prentice Hall,
1988) by Brian W. Kernighan and Dennis M. Ritchie, commonly called K&R (Ritchie
was the creator of C). It is one of the best computer books ever written: brief, dense, and
stunningly precise and clear. K&R is so important for effective iOS programming that
I keep a physical copy beside me at all times while coding, and I recommend that you
do the same. Another useful manual is The C Book, by Mike Banahan, Declan Brady,
and Mark Doran, available online at />3
www.it-ebooks.info
It would be impossible for me to describe all of C in a single chapter. C is not a large or
difficult language, but it has some tricky corners and can be extremely subtle, powerful,
and low-level. Moreover, since C is described fully and correctly in the manuals I’ve just
mentioned, it would be a mistake for me to repeat what they can tell you better than I.
So this chapter is not a technical manual of C.
You don’t have to know all about C, though, in order to use Objective-C effectively; so
my purpose in this chapter is to outline those aspects of C that are important for you to
understand at the outset, before you start using Objective-C for iOS programming. This
chapter is “Just Enough C” to start you off comfortably and safely.
If you know no C at all, I suggest that, as an accompaniment to this chapter, you also
read select parts of K&R (think of this as “C: The Good Parts Version”). Here’s my
proposed K&R syllabus:
•
Quickly skim K&R Chapter 1, the tutorial.
• Carefully read K&R Chapters 2 through 4.
• Read the first three sections of K&R Chapter 5 on pointers and arrays. You don’t
need to read the rest of Chapter 5 because you won’t typically be doing any pointer
arithmetic, but you do need to understand clearly what a pointer is, as Objective-
C is all about objects, and every reference to an object is a pointer; you’ll be seeing

and using that * character constantly.
•
Read also the first section of K&R Chapter 6, on structures (structs); as a beginner,
you probably won’t define any structs, but you will use them quite a lot, so you’ll
need to know the notation (for example, as I’ve already said, a CGRect is a struct).
• Glance over K&R Appendix B, which covers the standard library, because you may
find yourself making certain standard library calls, such as the mathematical func‐
tions; forgetting that the library exists is a typical beginner mistake.
The C defined in K&R is not precisely the C that forms the basis of
Objective-C. Developments subsequent to K&R have resulted in fur‐
ther C standards (ANSI C, C89, C99), and the Xcode compiler ex‐
tends the C language in its own ways. By default, Xcode projects are
treated as GNU99, which is itself an extension of C99 (though you
could specify another C standard if you really wanted to). Fortunate‐
ly, the most important differences between K&R’s C and Xcode’s C are
small, convenient improvements that are easily remembered, so K&R
remains the best and most reliable C reference.
4 | Chapter 1: Just Enough C
www.it-ebooks.info
Compilation, Statements, and Comments
C is a compiled language. You write your program as text; to run the program, things
proceed in two stages. First your text is compiled into machine instructions; then those
machine instructions are executed. Thus, as with any compiled language, you can make
two kinds of mistake:
• Any purely syntactic errors (meaning that you spoke the C language incorrectly)
will be caught by the compiler, and the program won’t even begin to run.
• If your program gets past the compiler, then it will run, but there is no guarantee
that you haven’t made some other sort of mistake, which can be detected only by
noticing that the program doesn’t behave as intended.
The C compiler is fussy, but you should accept its interference with good grace. The

compiler is your friend: learn to love it. It may emit what looks like an irrelevant or
incomprehensible error message, but when it does, the fact is that you’ve done some‐
thing wrong and the compiler has helpfully caught it for you. Also, the compiler can
warn you if something seems like a possible mistake, even though it isn’t strictly illegal;
these warnings, which differ from outright errors, are also helpful and should not be
ignored.
I have said that running a program requires a preceding stage: compilation. But in fact
there is another stage that precedes compilation: preprocessing. Preprocessing modifies
your text, so when your text is handed to the compiler, it is not identical to the text you
wrote. Preprocessing might sound tricky and intrusive, but in fact it proceeds only
according to your instructions and is helpful for making your code clearer and more
compact.
Xcode allows you to view the effects of preprocessing on your program text (choose
Product → Perform Action → Preprocess [Filename]), so if you think you’ve made a
mistake in instructing the preprocessor, you can track it down. I’ll talk more later about
some of the things you’re likely to say to the preprocessor.
C is a statement-based language; every statement ends in a semicolon. (Forgetting the
semicolon is a common beginner’s mistake.) For readability, programs are mostly writ‐
ten with one statement per line, but this is by no means a hard and fast rule: long
statements (which, unfortunately, arise very often because of Objective-C’s verbosity)
are commonly split over multiple lines, and extremely short statements are sometimes
written two or three to a line. You cannot split a line just anywhere, however; for example,
a literal string can’t contain a return character. Indentation is linguistically meaningless
and is purely a matter of convention (and C programmers argue over those conventions
with near-religious fervor); Xcode helps “intelligently” by indenting automatically, and
you can use its automatic indentation both to keep your code readable and to confirm
that you’re not making any basic syntactic mistakes.
Compilation, Statements, and Comments | 5
www.it-ebooks.info