Convertirse en Un Xcoder

8/4/2019 Convertirse en Un Xcoder

1/74

Become

an XcoderStart Programming

the Mac Using Objective-C

By Bert Altenberg, Alex Clarke

and Philippe Mougin

______________________________________________________________________________________

Become An Xcoder


2/74

License

Copyright notice

Copyright 2008 by Bert Altenburg, Alex Clarke and Philippe Mougin. Version 1.15

Released under a Creative Commons License: 3.0 Attribution Non-commercial

http://creativecommons.org/licenses/by/3.0/

Attribution:e licensors, Bert Altenburg, Alex Clarke and Philippe Mougin, permit others to copy, modify and dis-tribute the work. In return, the licensees must give the original authors credit.

Non-commercial:e licensors permit others to copy, modify and distribute the work and use the work in paid-forand free courses. In return, licensees may not sell the work itself, although it may accompany other work that is sold.

CocoaLab

CocoaLab makes this book freely available online in the form of a wiki or a pdf document in English, Chinese andArabic, from http://www.cocoalab.com.

______________________________________________________________________________________

Become An Xcoder


3/74

Become An Xcoder

Table of contents i

Contents

License. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Copyright notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

CocoaLab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

How to use this book. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

00: Before we start. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

01: A Program Is a Series of Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:1

Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:1

The semicolon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:1

Naming variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:1

Using variables in calculation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:2Integers and floats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:3

Declaring a variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:3

Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:4

Parentheses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:5

Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:5

Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:5

Modulus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 01:5

02: No comment? Unacceptable!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 02:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 02:1

Making a comment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 02:1

Outcommenting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 02:1

Why comment? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 02:1

03: Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:1

The main() function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:1

Our first function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:2

Passing in arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:3

Returning values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:4

Making it all work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:5

Shielded variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 03:6

04: Printing on screen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:1

Using NSLog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:1

Displaying variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:2

Displaying multiple values. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:3

Matching symbols to values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:3

Linking to Foundation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 04:4

05: Compiling and Running a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:1

Creating a project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:1

Exploring Xcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:3

Build and Go . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:4

______________________________________________________________________________________

Become An Xcoder


4/74

Become An Xcoder

ii Table of contents

Bugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:5

Our first Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:6

Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:7

Conclusion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 05:8

06: Conditional Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 06:1

if(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 06:1

if() else(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 06:1

Comparisons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 06:1

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 06:2

07: Repeating Statements for a While. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 07:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 07:1

for() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 07:1

while() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 07:2

08: A Program With a GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:1Objects in action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:1

Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:2

Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:2

Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:2

Objects in memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:2

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:3

Our Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:3

Our first class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:3

Creating the project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:4

Exploring Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:6

Class background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:6

Custom classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:7

One Class to rule them all . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:7

Creating our class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:7

Creating an instance in Interface Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:8

Creating connections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 08:9

Generate Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .08:12

Ready to rock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .08:14

09: Finding Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 09:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 09:1

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 09:1

10: awakeFromNib. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10:1

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10:1

11: Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11:1

Warning! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11:1

Referencing variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11:1

Using Pointers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11:1

12: Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

NSString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

______________________________________________________________________________________

Become An Xcoder


5/74

Become An Xcoder

Table of contents iii

Pointers again. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

The @ symbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

A new kind of string. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:1

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:2NSMutableString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:2

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:2

More pointers again! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12:4

13: Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13:1

A class method. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13:1

Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13:2

Conclusion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13:4

14: Memory Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1

Garbage Collection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1

Enabling Garbage collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1Reference Counting: The object lifecycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1

The retain count . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:1

Retain and Release . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:2

Autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14:2

15: Sources of Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15:1

______________________________________________________________________________________

Become An Xcoder


6/74

About

Este libro tiene como propsito introducirle a los conceptos fundamentales de la programacinde el sistema Mac utilizando Xcode y Objective-C.

No se requiere experiencia previa en programacin.

Introduccin

Apple te ofrece todas las herramientas necesarias para desarrollar aplicaciones basadas en Cocoa, de forma gratuita. Este conjunto deherramientas, conocido con el nombre de Xcode, viene incluido con Mac OS X, o puedes bajarlo de la seccin de desarrolladores enel sitio web de Apple.Existen varios buenos libros sobre programacin para Mac, pero asumen que ya tienes experiencia en programacin. Este libro no.Se ensean los conceptos bsicos de programacin, en particular con Objective-C, usando Xcode. Despus de unos 5 captulos, serscapaz de crear un programa bsico, sin una interfaz grfica de usuario (GUI). Despus de unos captulos ms, sabrs cmo crearprogramas sencillos con un GUI. Cuando hayas terminado de leer este folleto, estars listo para utilizar libros ms avanzados. Tendrque estudiar esos libros tambin, porque hay mucho ms que aprender. Por ahora, sin embargo, no te preocupes porque este librotoma las cosas con calma.

Cmo usar este libro

Como podrs observar, algunos prrafos se muestran en un recuadro como el siguiente:

Puntos tcnicos

Te sugerimos leer cada captulo dos veces (por lo menos). La primera vez pasa la caja de texto. La segunda vez que leas los captulosincluye la caja de texto. Vas a ensayar en la prctica lo que has aprendido y aprenders algunos puntos tcnicos interesantes quehubieran sido distracciones la primera vez. Al utilizar el libro de esta manera, logrars que la inevitable curva de aprendizaje sea unasuave pendiente.Este libro contiene docenas de ejemplos, que constan de una o ms lneas de cdigo de programacin. Para asegurarse de que asociesuna explicacin a su respectivo ejemplo, cada ejemplo tiene la etiqueta de un nmero colocado entre corchetes, de esta manera: [1].La mayora de los ejemplos tienen dos o ms lneas de cdigo. A veces, un segundo nmero se utiliza para referirse a unadeterminada lnea. Por ejemplo, [1.1] se refiere a la primera lnea del ejemplo [1]. En los fragmentos largos de cdigo, ponemos lareferencia despus de una lnea de cdigo, de esta manera:

//[1]

volumen = base * altura; // [1.1]

La programacin no es un trabajo simple . Se requiere un poco de perseverancia y que t mismo trates de hacer todas las cosas que seensean en este libro. No se puede aprender a tocar el piano o conducir un coche exclusivamente por la lectura de libros. Lo mismovale para aprender a programar. Este libro est en un formato electrnico, por lo que no tienes ninguna excusa para utilizar Xcodecon frecuencia. Por lo tanto, a partir del captulo 5, te sugerimos que vayas a travs de cada captulo en tres ocasiones. La segundavez, prueba los ejemplos y haz pequeas modificaciones al cdigo para explorar cmo funcionan las cosas.

______________________________________________________________________________________

Become An Xcoder


7/74

00: Antes de empezar

Escribimos este libro para usted. Como es gratis, por favor permtame decir un par de palabras sobre la promocin de la Mac acambio. Cada usuario de Macintosh puede ayudar a promover su plataforma preferida con un poco esfuerzo. Aqu es cmo.

Cuanto ms eficiente con la Mac sea usted, ms fcil es llevar a otras personas a considerar una Mac. Por lo tanto, tratar de estar alda visitando sitios web orientados a la Mac y leer revistas de Mac. Por supuesto, el aprendizaje de Objective-C o AppleScript yponerlos en uso es bueno tambien. Para las empresas, el uso de AppleScript puede ahorrar toneladas de dinero y tiempo. Echa un

vistazo al folleto gratis de Bert, AppleScript Absolutos para Principiantes, disponible en:http://www.macscripter.net/books

Muestrale al mundo que no todo el mundo est usando una PC, haciendo la Macintosh ms visible. El uso de una camiseta en pblicocon el logo de Mac es una manera, pero hay otras maneras, puede hacer que el Mac sea ms visibles dentro de su hogar. Si ejecutaActivity Monitor (en la carpeta Utilidades, que se encuentra en la carpeta de Aplicaciones de tu Mac), te dars cuenta de que tu Macutiliza todo su poder de procesamiento slo de vez en cuando. Los cientficos han puesto en marcha varios proyectos de informticadistribuida (DC) , como el Folding@home o SETI@home, que aprovechar esta potencia de procesamiento no utilizada, por logeneral en pro del bien comn.

Usted descarga un pequeo programa gratuito, llamado DC client, y empezara a procesar unidades de trabajo. Estos clientes DCcorrer con menor nivel de prioridad. Si ests usando un programa en tu Mac y las necesidades del programa requieren plena potenciade procesamiento, el DC client inmediatamente toma menor prioridad. As, usted no notar que est funcionando. Cmo ayuda estoa las Mac? Bueno, la mayora de los proyectos DC mantienen rankings en sus sitios web de las unidades procesadas hasta la fecha. Sise inscribe en un equipo Mac (reconocer sus nombre en los rankings), puede ayudar al equipo Mac de su eleccin para ascender enla clasificacin. As, los usuarios de otras plataformas de ordenador veran que tan bien las Macs estn haciendo. Hay DC clients quese concentran en varios temas, como matemticas, curar enfermedades y mucho ms. Para elegir un proyecto DC que te gusta, echaun vistazo a:

http://distributedcomputing.info/projects.html

Un problema con esta sugerencia: Se puede llegar a ser adicto!

Asegrese de que la plataforma Macintosh tiene el mejor software. No, no slo mediante la creacin de programas propios. Haga unhbito de dar (corts) retroalimentacin a los desarrolladores de programas que usted utiliza. Incluso si trat una pieza de software yno le gusto, expliquele al desarrollador por qu. Asegrese de informar sobre errores y proporcione una descripcin exacta como seaposible de las acciones que realiz cuando se experiment el error.Pagar por el software que usted utiliza. Mientras el mercado de software para Macintosh sea viable, los desarrolladores seguirnproveyendo buen software.

Pngase en contacto con al menos 3 usuarios de Macintosh que podran estar interesados en programacin, digales acerca de estelibro y dnde encontrarlo. O asesorelos sobre los 4 puntos mencionados arriba.

OK, mientras el DC client termina de descargar en el fondo, vamos a empezar!

______________________________________________________________________________________

Become An Xcoder
http://distributedcomputing.info/projects.htmlhttp://distributedcomputing.info/projects.htmlhttp://www.macscripter.net/bookshttp://www.macscripter.net/books


8/74

01: Un programa es una serie de instrucciones

Presentacin

Para conducir un automvil, tienes que aprender a controlar varias cosas a la vez. La programacin tambin requiere que mantengasun montn de cosas en mente, o tu programa romper. Mientras que al menos ya conocas el interior de un coche antes de aprender aconducir, no tendrs esa ventaja cuando trates de aprender a programar con Xcode. Para no abrumarte, dejamos el entorno deprogramacin para un captulo posterior. En primer lugar, vamos a hacer que te sientas cmodo con algunos conceptos de Objective-

C, empezando por la matemtica bsica.En la escuela primaria haba que hacer clculos, rellenando los puntos:

2 + 6 = .... = 3 * 4 (el asterisco * es la forma estndar para representar la multiplicacin en los teclados de ordenador)

En la escuela secundaria, los puntos pasaron de moda y unas variables llamadas 'x' e 'y' (y una nueva palabra: "lgebra") fueron lagran sensacin. Mirando hacia atrs, puede que te preguntes por qu nos hemos sentido tan intimidados en su momento por estepequeo cambio en la notacin.

2 + 6 = xy = 3 * 4

VariablesObjective-C tambin utiliza variables. Las variables no son nada ms que nombres para referirse a unos datos concretos, como porejemplo un nmero. Aqu tenemos una sentencia Objective-C, es decir, una lnea de cdigo, en la que asignamos un valor a unavariable.

//[1]

x = 4;

El punto y coma

Se le ha asignado el valor 4 a la variable x. Te habrs dado cuenta de que hay un punto y coma al final de la instruccin. Esto se debea que se requiere que todas las instrucciones terminen en punto y coma. Por qu? Bien, el trozo de cdigo que hay en el ejemplo [1]puede parecerte sencillo, pero un ordenador no es capaz de comprenderlo. Se necesita un programa especial, llamado compilador,para convertir ese texto en una secuencia de instrucciones que l s sea capaz de entender y ejecutar. Leer y entender nuestro idiomapuede ser muy difcil para un compilador as que debemos darle algunas pistas, por ejemplo: indicarle dnde termina cada sentencia;y eso es lo que hacemos con el punto y coma.

Si te olvidas el punto y coma en tu cdigo, ste no se podr compilar, es decir, no se va a poder convertir en un programa que tu Macpueda ejecutar. No te preocupes ahora de eso, pues el compilador se quejar si hay algn problema y, como veremos en un captuloposterior, intentar ayudarte a encontrar lo que est mal.

Dar nombres a las variables

Mientras que los nombres de las variables no tienen una importancia especial para el compilador, el utilizar nombres descriptivos sque nos puede facilitar la lectura del programa y hacerlo ms comprensible. Ten esto en cuenta para cuando tengas que buscar erroresen tu cdigo.

Por tradicin se llaman "bugs" (bichos) a los errores de los programas. A la bsqueda y reparacin de bugs se le llama debugging (enespaol solemos decir depuracin).

Por tanto, en programas reales evitaremos usar nombres de variables no descriptivos tales como x. Por ejemplo, el nombre de lavariable en la que almacenaramos el ancho de un dibujo sera anchoDibujo [2].

//[2]

anchoDibujo = 8;

Ahora que sabes que para el compilador es un gran problema que te olvides del punto y coma, comprenders que en la programacinhay que prestar atencin a los detalles. Uno de esos detalles es que el cdigo es sensible a maysculas/minsculas. Es decir, lavariable anchoDibujo no es la misma que anchoDIBUJO ni que AnchoDibujo. La convencin que vamos a seguir para losnombres de variables es unir varias palabras, la primera iniciada por minsculas y el resto por maysculas, tal como has visto en elejemplo [2]. A este estilo se le suele llamar camelCase (se llama as por las jorobas del camello, en ingls camel. Cada mayscula es

una joroba). Te ser conveniente seguir este esquema para reducir las posibilidades de cometer errores con los nombres de variables.Ten en cuenta que los nombres de variables consisten en una sola palabra, en el sentido de que no hay espacios en el nombre.

______________________________________________________________________________________

Become An Xcoder


9/74

Tienes total libertad para elegir el nombre de tus variables, pero hay una serie de reglas que debes seguir: la primera es que no puedeser el nombre de una palabra reservada de Objective-C (palabras que tienen un significado especial para Objective-C). Si tusvariables estn compuestas al menos de dos palabras unidas, como por ejemplo anchoDibujo, no vas a tener problema. Parafacilitar la lectura se recomienda poner en mayscula la inicial de cada palabra excepto la primera, tal como hemos visto. Sigue esteesquema para evitar bugs en tus programas.

Si no te importa aprender un par de reglas ms, sigue leyendo. Tambin se permite el uso de dgitos adems de letras, pero no puedesusar un dgito al comienzo del nombre. Tambin se permite el guin bajo: "_". Vamos a ver ejemplos de nombres de variables.

Nombres vlidos de variables:

puerta8k

pu3rta

puer_ta

Nombres no permitidos:

puerta 8 (porque contiene un espacio)

8puerta (porque empieza por un dgito)

Nombres vlidos pero no recomendados:

Puerta8 (porque empieza por mayscula)

Uso de variables en clculos

Ahora que sabemos como asignar un valor a una variable, podemos hacer clculos. Echemos un vistazo al cdigo para calcular lasuperficie de un dibujo [3].

//[3]

anchoDibujo=8;

altoDibujo=6;

areaDibujo=anchoDibujo*altoDibujo;

Sorprendentemente, al compilador no le importan los espacios (con la excepcin, como ya sabemos, de que estn prohibidos en losnombres de variables), as que podemos usar todos los que queramos para facilitar la lectura de nuestro cdigo.

//[4]

anchoDibujo = 8;

altoDibujo = 6;

areaDibujo = anchoDibujo * altoDibujo;

Y en un arranque de generosidad, el compilador tambin nos permite introducir saltos de lnea en medio de las instrucciones teimaginas por qu? Pues porque, si recuerdas lo que vimos un poco ms arriba, l va a interpretar todo como una sola instruccinhasta que encuentre el punto y coma (el indicador de fin de instruccin). Podemos usar esta caracterstica para facilitar la lectura enlneas excesivamente largas. As que lo siguiente tambin sera vlido para el compilador (pero tambin bastante incmodo de leer):

anchoDibujo = 8;

altoDibujo = 6;


Enteros y fraccionarios

Echemos un vistazo al ejemplo [5], especialmente a las dos primeras sentencias.

//[5]

anchoDibujo = 8;

altoDibujo = 4.5;


Se pueden distinguir en general dos tipos de nmeros: enteros y fraccionarios. Puedes ver un ejemplo de cada en [5.1] y [5.2]respectivamente. Los enteros se usan para contar, que es algo que haremos cuando queramos realizar una serie de instrucciones unnmero determinado de veces (ver captulo 7). Los nmeros fraccionarios los usamos, por ejemplo, con los precios.

Importante: Segn el pas, se usa como carcter separador de la parte decimal el punto "." o la coma ",". En Objective-C debemosemplear obligatoriamente siempre el punto.

______________________________________________________________________________________

Become An Xcoder


10/74

El cdigo del ejemplo [5] no funcionara. El problema es que el compilador necesita que le indiques previamente el nombre de lasvariables que vas a usar en tu programa y tambin qu tipo de dato va a contener cada una. Eso es lo que llamamos "declarar unavariable".

//[6]

int anchoDibujo; // [6.1]

float altoDibujo, areaDibujo; // [6.2]

anchoDibujo = 8;

altoDibujo = 4.5;


En la lnea [6.1], int indica que la variable anchoDibujo contiene un nmero entero. En la siguiente lnea [6.2] declaramos dosvariables con una sola instruccin, separando sus nombres con coma. En la sentencia tambin se indica que son de tipo float, loque quiere decir que van a ser nmeros con una parte fraccionaria. Llegados a este punto, parece que no tiene sentido que la variableanchoDibujo sea de tipo diferente a las otra dos. Pero lo que sabes es que si multiplicas un int por un float el resultado delclculo es un float, que es la razn por la que deberas declarar la variable areaDibujo como float [6.2].

Por qu quiere el compilador conocer si una variable representa a un nmero entero o a uno fraccionario? Bien, un programa usaparte de la memoria del ordenador y el compilador reserva espacio para cada variable que se declara, pero necesita saber el tipo, yaque cada tipo requiere una cantidad distinta y tambin se representa de forma distinta en la memoria del ordenador.

Y si necesitamos trabajar con nmeros muy grandes o con gran precisin de decimales? Van a poder representarse en los tipos queconocemos hasta ahora (int y float)? Bien, esta pregunta tiene dos respuestas: en primer lugar, existen otros tipos de datos paraenteros ms grandes (long) y para fraccionarios de ms precisin (double). Pero incluso estos tipos de dato podran no sersuficiente, lo que nos lleva a la segunda respuesta: como programador, parte de tu trabajo es estar atento a los posibles problemas.Pero eso no es un asunto para discutir en el primer captulo de un libro de introduccin.

Por cierto, los tipos que hemos visto pueden almacenar tambin nmeros negativos. Si sabes que el valor de tu variable nunca va aser negativo puedes restringir el rango de valores.

//[7]

unsigned int cajasDisponibles;

No tiene sentido que el nmero de cajas disponibles en el almacn sea negativo, as que en este caso podramos usar unsignedint. El tipo unsigned int representa un nmero entero mayor o igual a cero.

Declarar variables

Es posible declarar una variable y asignarle un valor de una vez [8].

//[8]

int x = 10;

float y= 3.5, z = 42;

Esto te ahorra algo de tecleo.

Tipos de datos

Como ya hemos visto, los datos almacenados en variables pueden ser de varios tipos especficos, por ejemplo int o float.En Objective-C, a los tipos de dato como esos se les llama tambin tipos escalares. A continuacin mostramos una lista con los tiposde dato escalares ms comunes de Objective-C:

Nombre Tipo Ejemplo

void Vaco Nada

int Nmero entero ...-1, 0, 1, 2...

unsigned Nmero entero positivo 0, 1, 2...

float Nmero fraccionario -0.333, 0.5, 1.223, 202.85556

double Nmero fraccionario de doble precisin 5,25253E+31

char Carcter holaBOOL Boolean 0, 1; TRUE, FALSE; YES, NO.

______________________________________________________________________________________

Become An Xcoder


11/74

Operaciones matemticas

En los ejemplos previos hemos realizado una multiplicacin. Se usan los siguientes smbolos, conocidos oficialmente como"operadores", para realizar clculos matemticos bsicos.

+ suma

- resta

/ divisin

* multiplicacin

Aparte de estos operadores, si echamos un vistazo al cdigo de un programa en Objective-C, podemos encontrarnos con un par decuriosidades, quiz porque los programadores son unos mecangrafos perezosos.

En lugar de escribir x = x + 1;, con frecuencia los programadores recurren a cosas como [9] y [10]

//[9]

x++;

//[10]

++x;

En cualquiera de los dos casos, lo que significa es: incrementa en 1 el valor de x. En algunas circunstancias es importante situar el ++antes o despus del nombre de la variable. Fjate en estos ejemplos [11] y [12].

//[11]

x = 10;

y = 2 * (x++);

// "x" tiene aqu el valor 11, pero se le asign DESPUES de realizar el clculo

// por tanto "y" tiene el valor 20

//[12]

x = 10;

y = 2 * (++x);

// "x" tambin vale ahora 11, pero su valor se asign ANTES de hacer el clculo

// as que "y" vale 22

Si usamos el ++ antes del nombre de la variable, se incrementar su valor antes de emplear la variable en el clculo en el que estenvuelta. Si usamos ++ despus del nombre de la variable, se incrementar su valor despus de utilizarse en el clculo en el que estenvuelta. El cdigo de [12] es equivalente al de [13].

//[13]

x = 10;

x++; // [13.2]

y = 2 * x;

// Como el incremento de x en la lnea [13.2] no est envuelto en ninguna

// operacin, en este caso sera lo mismo usar ++x que x++

Con esto se unen dos sentencias en una, pero quiz pueda hacer un poco ms difcil de entender tu programa. Es correcto emplearlopero ten en cuenta que puede estar acechando un bug por ah.

Parntesis

Seguro que ya lo sabes, pero los parntesis se pueden utilizar para indicar el orden en el que queremos que se realicen lasoperaciones. La multiplicacin y divisin tienen precedencia sobre la suma y la resta, as que, por ejemplo, 2 * 3 + 4 es igual a 10.Usando parntesis podemos forzar a que se realice antes la suma que la multiplicacin: 2 * (3 + 4) es igual a 14.

______________________________________________________________________________________

Become An Xcoder


12/74

Divisin

La divisin requiere un poco de atencin, ya que tiene un comportamiento distinto segn usemos enteros o fraccionarios. Echa unvistazo a los ejemplos [14] y [15].

//[14]

int x = 5, y = 12, ratio;

ratio = y / x;

//[15]

float x = 5, y = 12, ratio;

ratio = y / x;

En el primer caso [14], el resultado es 2 Por qu? Al ser enteros el dividendo y el divisor, el resultado tambin es un nmero entero.En el segundo [15], el resultado es el que probablemente te esperas: 2,4

Booleanos

Un booleano (la palabra viene de George Boole, el matemtico inventor de la lgica booleana) es un valor lgico verdadero o falso.

Se pueden considerar equivalentes el 1 como valor verdadero y el 0 como valor falso.

VERDADERO FALSO

1 0

Se emplean con frecuencia para determinar si se realiza o no una accin dependiendo del valor booleano de alguna variable ofuncin.

Resto (en ingls: modulus)

Probablemente no ests tan familiarizado con el operador %, que no tiene que ver con los porcentajes sino que calcula el resto de ladivisin entre el primer y el segundo operando (si el segundo operando es 0, el comportamiento de % es indefinido).

//[16]

int x = 13, y = 5, resto;

resto = x % y;

La variable resto contendr el valor 3.

Ms ejemplos de este operador:

21 % 7 es igual a 0

22 % 7 es igual a 1

23 % 7 es igual a 2

24 % 7 es igual a 3

27 % 7 es igual a 6

30 % 2 es igual a 0

31 % 2 es igual a 1

32 % 2 es igual a 0

33 % 2 es igual a 1

34 % 2 es igual a 0

50 % 9 es igual a 5

60 % 29 es igual a 2

Puede sernos til en ocasiones, pero ten en cuenta que slo funciona con enteros.

______________________________________________________________________________________

Become An Xcoder


13/74

Uno de los usos ms comunes del operador % es determinar si un nmero es par o impar. Si es par, su resto entre 2 es 0, si es imparentonces ser 1. Por ejemplo:

//[17]

int unNumero;

//Aqu escribiramos cdigo que asigna un valor a "unNumero"

if ((unNumero % 2) == 0) // [17.3]

{

NSLog(@"unNumero es par");

}

else

{

NSLog(@"unNumero es impar");

}

En la lnea [17.3] se ha empleado un condicional, que vers en el captulo 6. Podramos traducir la instruccin como: "si el resto de ladivisin unNumero entre 2 es igual a 0, entonces "

______________________________________________________________________________________

Become An Xcoder


14/74

02: Sin comentarios? Inaceptable!

Introduccin

Si utilizamos nombres de variables con sentido, haremos que nuestro cdigo sea ms legible y entendible [1].

//[1]

float anchoDelDibujo, altoDelDibujo, areaDelDibujo;

anchoDelDibujo = 8.0;

altoDelDibujo = 4.5;

areaDelDibujo = anchoDelDibujo * altoDelDibujo;

Hasta ahora nuestros ejemplos de cdigo han sido de slo unas pocas sentencias, pero incluso los programas ms sencillos puedencrecer rpidamente hasta cientos o miles de lneas. Cuando revises tu programa despus de algunas semanas o meses puede ser difcilrecordar la razn por la que tomaste ciertas decisiones. Ah es donde entran en accin los comentarios. Los comentarios ayudarn acomprender rpidamente lo que hace cada parte de tu programa y por qu. Algunos programadores van ms all y siempre comienzana codificar cada clase como comentarios, con lo que se organizan mejor y evitan tener que improvisar cdigo posteriormente.

Recomendamos invertir tiempo en comentar el cdigo. Podemos asegurarte que esa inversin ser revertida con creces en el futuro.Tambin, si compartes tu cdigo con alguien ms, tus comentarios ayudarn a que se adapte a tus propias necesidades msrpidamente.

Crear comentarios

Para indicar el comienzo de un comentario teclea dos barras.

// Esto es un comentario

En Xcode los comentarios se muestran en verde. Si el comentario es largo y ocupa varias lneas, encirralo entre /* */.

/* This is a comment

extending over two lines */

Comentar cdigo

Hablaremos sobre la depuracin dentro de poco, ya que Xcode tiene buenas herramientas para ello. Una de las formas de depuracina la vieja usanza es comentar el cdigo. Comentamos cdigo envolviendo las instrucciones entre /* */, de esta formadeshabilitamos el cdigo, impidiendo su ejecucin y podemos comprobar si el resto funciona como esperbamos. Esto puedeayudarnos a encontrar errores. Si, por ejemplo, la parte de cdigo comentada asigna valores a una variable, podemos aadir una lneade cdigo temporal que asigne a esa variable un valor que nos sirva para comprobar el resto de nuestro cdigo.

Por qu incluir comentarios?

No debemos desestimar la importancia de los comentarios. Frecuentemente es til incluir explicaciones en nuestro idioma sobre loque hace una serie de instrucciones. As no hay que estar deduciendo qu es lo que hace esa parte de cdigo y podemos darnos cuentainmediatamente de si el problema tiene su origen o no en esa seccin. Adems podemos usar los comentarios para explicar cosasdifciles o casi imposibles de deducir leyendo el cdigo. Por ejemplo, si programas una funcin matemtica que encontraste detalladaen un libro, podras poner la referencia bibliogrfica dentro de un comentario.

A veces es til hacer los comentarios antes de escribir el cdigo. Eso ayudar a estructurar tus pensamientos y como resultante laprogramacin ser mas fluida.

Los ejemplos de cdigo que encontrars en este libro no contienen tantos comentarios como generalmente se deberan poner, peroeso es porque ya se dan las explicaciones en el texto que los precede.

______________________________________________________________________________________

Become An Xcoder


15/74

03: Funciones

Introduccin

El trozo de cdigo ms largo que hemos visto hasta ahora tena slo cinco lneas. Los programas de varias miles de lneas parecenquedarnos an muy lejos, pero debido a la naturaleza de Objective-C, debemos discutir la forma de organizar los programas en estaetapa temprana.

Si un programa consistiese en una sucesin larga y continua de instrucciones sera difcil encontrar y reparar errores. Adems, una

serie concreta de instrucciones podra aparecer en varias partes de tu programa. Si hubiese en ellas algn error, deberas arreglar elmismo error en varios lugares. Eso sera una pesadilla porque sera fcil olvidarse de uno (o varios). Por tanto, la gente ha pensadouna solucin para organizar el cdigo, facilitando la correccin de errores.

La solucin a este problema es agrupar las instrucciones dependiendo de la tarea que realicen. Por ejemplo, tienes una serie deinstrucciones que calculan el rea de un crculo. Una vez que has comprobado que esas instrucciones funcionan correctamente, nuncatendrs que volver a ese cdigo para examinar si hay algn error en l. El conjunto de instrucciones, llamado funcin (function eningls), tiene un nombre y puedes llamarlo por ese nombre cada vez que necesites que se ejecute ese cdigo. Este concepto de usarfunciones es fundamental, de hecho siempre hay al menos una funcin en un programa: la funcin main(). Esta funcin main()es la que busca el compilador para saber por donde debe empezar la ejecucin del programa.

La funcin main()

Pasemos a estudiar la funcin main() con ms detalle. [1]//[1]

main()

{

// Cuerpo de la funcin main(). Escribe aqu tu cdigo.

}

La sentencia [1.1] muestra el nombre de la funcin, en este caso "main", seguido de la apertura y cierre de parntesis. Es obligatorioque exista esta funcin main(), que por otro lado es una palabra reservada (lo que significa entre otras cosas que no podemos usarlacomo nombre para nuestras variables). Cuando creemos nuestras funciones podremos darles el nombre que queramos. Los parntesisestn ah por una buena razn, pero la conoceremos ms adelante en este captulo. En las siguiente lneas [1.3, 1.5], hay llaves.Debemos poner nuestro cdigo entre esas llaves { }. Cualquier cosa entre las llaves es lo que llamamos el cuerpo de la funcin. He

copiado cdigo del primer captulo y lo he puesto aqu en donde corresponde [2].//[2]

main()

{

// A continuacin se declaran las variables

float anchoDelDibujo, altoDelDibujo, superficieDelDibujo;

// Asignamos un valor inicial a las variables



// Aqu se realiza el clculosuperficieDelDibujo = anchoDelDibujo * altoDelDibujo;

}

______________________________________________________________________________________

Become An Xcoder


16/74

Nuestra primera funcin

Si escribimos todo nuestro cdigo en el cuerpo de la funcin main(), eso nos llevara al problema del cdigo desestructurado ydifcil de depurar que queremos evitar. As que escribamos otro programa, ahora con un poco de estructura. Adems de la funcinmain() obligatoria crearemos una funcin calculaAreaDelCirculo() [3].

//[3]

main()

{

float anchoDelDibujo, altoDelDibujo, superficieDelDibujo;



superficieDelDibujo = anchoDelDibujo * altoDelDibujo;

}

calculaAreaDelCirculo() // [3.9]

{

}

Ha sido fcil, pero nuestra funcin definida desde la lnea [3.9] an no hace nada. Observa que la especificacin de la funcin estfuera del cuerpo de la funcin main(). En otras palabras, las funciones no estn anidadas.

Queremos que nuestra nueva funcin calculaAreaDelCirculo() sea llamada desde la funcin main(). Veamos cmopodemos hacerlo [4].

//[4]

main()

{

float anchoDelDibujo, altoDelDibujo, superficieDelDibujo,

radioDelCirculo, superficieDelCirculo; // [4.4]



radioDelCirculo = 5.0; // [4.7]

superficieDelDibujo = anchoDelDibujo * altoDelDibujo;

// Aqu es donde llamamos a nuestra funcin!

superficieDelCirculo = calculaAreaDelCirculo(radioDelCirculo); // [4.10]

}

Nota: no mostramos el resto del programa (ver [3]).

Pasar argumentos a la funcin

Hemos aadido un par de nombres de variable de tipo float [4.4], y hemos inicializado la variable radioDelCirculo dndoleun valor [4.7].Tiene ms inters la lnea [4.10], en la que llamamos a la funcin calculaAreaDelCirculo(). Como puedes ver, el nombre dela variable radioDelCirculo se ha puesto entre parntesis. Es un argumento de la funcin calculaAreaDelCirculo(). Elvalor de la variable radioDelCirculo se pasa a la funcin calculaAreaDelCirculo(). Cuando la funcincalculaAreaDelCirculo() ha hecho su tarea debe devolver un valor, en este caso el resultado del clculo de la superficie.Modifiquemos el cdigo de la funcin calculaAreaDelCirculo() [5].

______________________________________________________________________________________

Become An Xcoder


17/74

Nota: slo se muestra el cdigo de la funcin calculaAreaDelCirculo().

//[5]

calculaAreaDelCirculo(float radio) // [5.1]

{

float area;

area = 3.1416 * radio * radio; // pi veces el cuadrado del radio [5.4]return area;

}

En [5.1] definimos que se requiere un valor de tipo float como entrada para la funcin calculaAreaDelCirculo(). Cuandose recibe, ese valor es almacenado en una variable llamada radio. Usamos una segunda variable, area, para almacenar elresultado del clculo en [5.4], as que la declaramos en [5.3] de la misma forma que hemos declarado variables en la funcin main() [4.4]. Vers que la declaracin de la variable radio se ha hecho dentro de los parntesis [5.1]. La lnea [5.5] devuelve elresultado a la parte del programa desde la que fue llamada esta funcin. Como consecuencia, en la lnea [4.10], se asigna ese valor ala variable superficieDelCirculo.

La funcin en el ejemplo [5] est completa, excepto por una cosa. No hemos especificado el tipo de datos que devolver la funcin.El compilador nos va a requerir ese dato, as que no nos queda otra opcin que obedecerle e indicar que es de tipo float [6.1].

//[6]

float calculaAreaDelCirculo(float radio) //[6.1]

{

float area;

area = 3.1416 * radio * radio;

return area;

}

Como indica la primera palabra de la lnea [6.1], el dato devuelto por esta funcin (en este caso el dato devuelto por la variablearea), es de tipo float. Como programador, debes asegurarte de que la variable superficieDelCirculo en la funcin main() es tambin de ese tipo, para que el compilador no nos moleste sobre ese asunto.

No todas las funciones requieren argumentos. Si no hay ninguno, los parntesis siguen siendo obligatorios, aunque no tengancontenido.

//[7]

int tiraElDado()

{

int numeroDePuntos;

// Aqu se escribira cdigo para generar un nmero aleatorio entre 1 y 6

return numeroDePuntos;

}

Devolucin de valores

No todas las funciones devuelven un valor. Si una funcin no devuelve un valor, entonces es de tipo void (que significa "vaco"). Eneste caso, la sentencia return es opcional. Si la usas, entonces la palabra return debe ir sola, sin indicarle a continuacin unvalor o nombre de variable.

//[8]

void alarmaXVeces(int x);

{

// Cdigo para hacer que suene la alarma x veces

return;

}

Si la funcin tiene ms de un argumento, como en la funcin calculaAreaDelDibujo() que est a continuacin, losargumentos van separados por comas (,).

______________________________________________________________________________________

Become An Xcoder


18/74

//[9]

float calculaAreaDelDibujo(float ancho, float alto)

{

// Cdigo para calcular la superficie...

}

Por convenio, la funcin main() debera devolver un entero y, por tanto, debera tener tambin una sentencia return. Deberadevolver 0 (cero, [10.9]) para indicar que todo se ha ejecutado sin problemas. Ya que devuelve un entero, debemos escribir intantes de main() [10.1]. Pongamos junto todo el cdigo que tenemos.

//[10]

int main() // [10.1]

{

float anchoDelDibujo, altoDelDibujo, areaDelDibujo,

radioDelCirculo, superficieDelCirculo;

anchoDelDibujo = 8;altoDelDibujo = 4.5;

radioDelCirculo = 5.0;

areaDelDibujo = anchoDelDibujo * altoDelDibujo;

superficieDelCirculo = calculaAreaDelCirculo(radioDelCirculo); // [10.8]

return 0; // [10.9]

}

float calculaAreaDelCirculo(float radio) // [10.12]

{

float area; // [10.14]


return area;

}

Hacer que todo funcione

Como puedes ver en [10], tenemos una funcin main() y otra funcin que hemos definido nosotros mismos [10.12]. Siintentsemos compilar este cdigo, el compilador lo rechazara. En la lnea [10.8] indicara que no conoce ninguna funcin llamadacalculaAreaDelCirculo(). Por qu? Aparentemente el compilador comienza leyendo la funcin main() y de repenteencuentra algo que desconoce. No va ms all y nos muestra este aviso. Para satisfacer al compilador, simplemente debemos aadiruna declaracin de funcin antes de la lnea con el main() [11.1]. No tiene complicacin, ya que es la misma lnea que en [10.12]

excepto que termina con punto y coma (;). Ahora el compilador no se llevar una sorpresa cuando se encuentre la llamada a esafuncin.

//[11]

float calculaAreaDelCirculo(float radio); // [11.1] declaracin de la funcin

int main()

{

// Aqu va el cdigo de la funcin main...

}

Nota: no se muestra aqu el resto del programa (ver [10]).

En seguida compilaremos el programa en la realidad. Pero antes un par de comentarios.

Cuando escribas programas es importante que intentes tener en mente la posibilidad de reutilizar tu cdigo en un futuro. Nuestroprograma podra tener una funcin calculaAreaDelRectangulo() tal como la que se muestra a continuacin [12], que podrallamarse desde la funcin main(). Esto sera til incluso aunque slo se llamase a esa funcin una vez. La funcin main() sera

______________________________________________________________________________________

Become An Xcoder


19/74

ms fcil de leer. Si tuviramos que depurar el cdigo sera ms fcil encontrar el error analizando cada funcin que siguiendo unalarga secuencia de instrucciones.

//[12]

float calculaAreaDelRectangulo(float largo, float ancho) // [12.1]

{

return (largo * ancho); //[12.3]

}

Como puedes ver, en un caso simple como este, es posible agrupar en una sola instruccin el clculo y la devolucin del resultado[12.3]. En [10.14] us la variable area simplemente para mostrar cmo declarar una variable dentro de una funcin.

Aunque las funciones que definimos en este captulo son bastante sencillas, es importante darse cuenta de que se puede modificar elcontenido de una funcin sin que ello afecte al cdigo que la llama. Lo que no debe cambiarse es la declaracin de la funcin (esdecir, su primera lnea).

Por ejemplo, podemos cambiar el nombre de las variables internas de la funcin y seguir trabajando (y esto no influir en el restodel programa). Alguien podra escribir la funcin y t podras utilizarla sin conocer su interior. Todo lo que necesitas es saber cmousarla. Ello implica conocer:

el nombre de la funcin

el nmero, orden y tipo de cada argumento

Lo que devuelve la funcin y el tipo del resultado

En el ejemplo [12], esas respuestas son, respectivamente:

calculaAreaDelRectangulo

Dos argumentos, ambos de tipo float, siendo el primero el alto y el segundo el ancho.

La funcin devuelve la superficie, y el resultado es de tipo float (como podemos deducir de la primera palabra de lalnea [12.1]).

Variables protegidas

El cdigo de cada funcin est protegido del programa principal y de cualquier otra funcin.

Esto significa que el valor de una variable interna de una funcin por defecto no puede ser modificado por ninguna otra variable deninguna otra funcin, incluso aunque tuvieran el mismo nombre. Esta es una caracterstica esencial de Objective-C. En el captulo 5volveremos a discutir este comportamiento. Pero antes vamos a arrancar Xcode y ejecutar el programa anterior [10].

______________________________________________________________________________________

Become An Xcoder


20/74

04: Salida en pantalla

Introduccin

Hemos hecho grandes progresos con nuestro programa, pero an no hemos visto como mostrar los resultados de nuestros clculos. Ellenguaje Objective-C por si mismo no sabe como hacerlo, pero por suerte podemos utilizar funciones que han escrito otros ya. Hayvarias opciones para mostrar resultados por pantalla. En este libro usaremos una funcin incluida en el entorno Cocoa de Apple: lafuncin NSLog(). Esto es estupendo, porque no tenemos que preocuparnos (ni tenemos que programar nada al respecto) para

obtener nuestros resultados en la pantalla.As que dnde muestra los datos NSLog()? En Xcode existe la Consola para visualizar los mensajes de log. Para abrir la Consola,debemos seleccionar [Console] desde el men [Run] (Cmd-Shift-R). Una vez que construyamos y ejecutemos nuestra aplicacin,todos los mensajes aparecern por ah.

La funcin NSLog() se dise para mostrar mensajes de error, no para los resultados de una aplicacin. De todas formas es tan fcilde usar que la hemos adoptado en este libro para visualizar nuestros resultados. Una vez que conozcas Cocoa en profundidaddescubrirs tcnicas ms sofisticadas para hacerlo.

Uso de NSLog

Veamos como usar la funcin NSLog() con el siguiente cdigo:

//[1]

int main()

{

NSLog(@"Julia es mi actriz favorita.");

return 0;

}

Al ejecutarlo, se producir la aparicin del texto "Julia es mi actriz favorita" en la Consola. El texto entre @" y " (lo que est entre lascomillas dobles) es lo que se llama "cadena de caracteres", "cadena de texto" o simplemente "cadena" (en ingls "string").

Adems de ese texto, la funcin NSLog() muestra informacin adicional, como la fecha actual y el nombre de la aplicacin. Porejemplo, la salida completa del programa [1] en mi sistema es:

2010-03-12 22:12:38.052 prueba1[5006:a0f] Julia es mi actriz favorita.

Una cadena puede tener una longitud de cero o ms caracteres.

Nota: en los siguientes ejemplos slo se muestran las sentencias interesantes de la funcin main()

//[2]

NSLog(@""); //[2.1]

NSLog(@" "); //[2.2]

La sentencia [2.1] contiene 0 caracteres y la llamamos cadena vaca (tiene una longitud 0). La sentencia [2.2] no es una cadena vacaaunque lo parezca. Contiene un espacio entre las comillas as que su longitud es 1.

Hay algunas secuencias de caracteres que tienen un significado especial dentro de las cadenas. Se les llama "secuencias de escape".Por ejemplo para hacer que la ltima palabra de nuestra cadena empiece en una lnea nueva, debemos incluir un cdigo especial en lasentencia [3.1]. El cdigo es \n, que significa "carcter de nueva lnea".

//[3]

NSLog(@"Julia es mi actriz \nfavorita.");

Ahora la salida tiene un aspecto como este (slo se muestra el contenido relevante):

Julia es mi actriz

favorita.

La contrabarra (\) en [3.1] se llama carcter de escape, ya que indica a la funcin NSLog que el siguiente carcter no debe ser

impreso directamente en pantalla sino que tiene un significado especial: en este caso la "n" significa "salta a la siguiente lnea".

______________________________________________________________________________________

Become An Xcoder


21/74

En el caso (no muy habitual) de que quisieras mostrar un contrabarra en pantalla, podra parecer que tienes un problema. Si elcarcter tras la contrabarra tiene un significado especial, cmo ser posible imprimir una contrabarra?. Pues simplemente poniendodos contrabarras juntas. Esto indicar a la funcin NSLog que debe imprimir la segunda contrabarra. Aqu tenemos un ejemplo:

//[4]

NSLog(@"Julia es mi actriz favorita.\\n");

La sentencia [4.1] producir, tras la ejecucin, la siguiente salida:Julia es mi actriz favorita.\n

Mostrar variables

Hasta ahora slo hemos mostrado cadenas estticas. Imprimamos ahora el resultado de un clculo.

//[5]

int x, numeroAMostrar;

x = 1;

numeroAMostrar = 5 + x;

NSLog(@"El valor del entero es %d.", numeroAMostrar);Fjate que, entre los parntesis, tenemos una cadena, una coma y el nombre de una variable. La cadena contiene algo curioso: %d. Aligual que la contrabarra, el carcter de porcentaje (%) tiene un sentido especial. Si va seguido de una d (abreviatura para indicarnmero entero en sistema decimal), hace que en esa posicin se inserte el valor que va a continuacin de la coma, en este caso elcontenido de la variable numeroAMostrar. Al ejecutar el ejemplo [5] el resultado ser:

El valor del entero es 6.

Para mostrar un nmero con decimales (en ingls se llama tipo "float"), usaremos %f en lugar de %d.

//[6]

float x, numeroAMostrar;

x = 12345.09876;

numeroAMostrar = x/3.1416;NSLog(@"El valor del nmero con decimales es %f.", numeroAMostrar);

Ms tarde, cuando aprendas a hacer repeticiones de clculos, podras queres realizar una tabla de valores. Imagina una tabla deconversin de grados Fahrenheit a Celsius. Si quieres que los datos mostrados tengan buena apariencia, necesitars que los datos encada una de las dos columnas tengan un ancho fijo. Puedes especificar ese ancho introduciendo un nmero entero entre % y f (o entre% y d segn el tipo de variable). An as, si el ancho que especificas es menor que el ancho del nmero, prevalecer el ancho delnmero.

//[8]

int x = 123456;

NSLog(@"%2d", x);

NSLog(@"%4d", x);

NSLog(@"%6d", x);

NSLog(@"%8d", x);

La ejecucin del ejemplo [8] producir la siguiente salida:

123456

123456

123456

123456

En las dos primeras sentencias [8.2, 8.3] solicitamos demasiado poco espacio para que el nmero sea mostrado completamente, perose toma el espacio igualmente. Slo en la sentencia [8.5] se especifica un ancho mayor que el del valor, y es donde apreciamos losespacios adicionales que se han requerido para mostrar el nmero.

Tambin es posible combinar la especificacin del ancho y el nmero de decimales con los que queremos que se muestre el dato.

______________________________________________________________________________________

Become An Xcoder


22/74

//[9]

float x=1234.5678;

NSLog(@"Reserva espacio para 10, y muestra 2 dgitos significativos.");

NSLog(@"%10.2f", x);

Mostrar mltiples valoresPor supuesto es posible mostrar ms de un valor o cualquier combinacin de valores [10.3]. Lo que debes hacer es asegurarte deindicar correctamente el tipo de cada dato (int, float), usando %d y %f.

//[10]

int x = 8;

float pi = 3.1416;

NSLog(@"El valor de x es %d, mientras que el valor de pi es %f.", x, pi);

Asignar los smbolos a los valores

Uno de los errores ms comunes entre los principiantes es especificar incorrectamente el tipo en funciones como NSLog y otras. Si

tus resultados no son los esperados o el programa rompe sin una razn, revisa las sentencias en las que asignas los tipos de dato.Si es incorrecta la asignacin del primer dato, puede que el segundo tampoco sea mostrado correctamente. Un ejemplo:

//[10b]

int x = 8;

float pi = 3.1416;

NSLog(@"El valor int es %f, mientras que el valor float es %f.", x, pi);

// Lo correcto sera : NSLog(@"El valor int es %d, mientras que el valor float es %f.",x, pi);

produce la siguiente salida por consola:

El valor int es 3.141600, y el float es nan.

______________________________________________________________________________________

Become An Xcoder


23/74

Vincular con la librera Foundation

Estamos a solamente una pregunta y una respuesta de ejecutar nuestro primer programa.

Cmo hace nuestro programa para conocer la funcin NSLog()? Bien, realmente no la conoce, a menos que nosotros se lodigamos. Para hacerlo, tenemos que indicar al compilador que importe la librera en la que est implementada la funcin NSLog()(junto a otras muchas que iremos conociendo). La sentencia es la siguiente:

#import

sta debe ser la primera sentencia en nuestro programa. Si juntamos todo lo que hemos aprendido en este captulo obtendremos elsiguiente cdigo, que haremos funcionar en el siguiente captulo.

//[11]

#import

float calculaAreaDelCirculo(float radio);

float calculaAreaDelRectangulo(float ancho, float alto);

int main()

{

float anchoDelDibujo, altoDelDibujo, areaDelDibujo,

radioDelCirculo, areaDelCirculo;




areaDelDibujo = calculaAreaDelRectangulo(anchoDelDibujo, altoDelDibujo);

areaDelCirculo = calculaAreaDelCirculo(radioDelCirculo);

NSLog(@"Area del crculo: %10.2f.", areaDelCirculo);

NSLog(@"Area del cuadrado: %f.", areaDelDibujo);

return 0;

}

float calculaAreaDelCirculo(float radio) // primera funcin personalizada

{

float area;


return area;

}

float calculaAreaDelRectangulo(float ancho, float alto) // segunda funcin personalizada

{

return ancho* alto;

}

______________________________________________________________________________________

Become An Xcoder


24/74

05: Compilacin y ejecucin de un Programa

Introduccin

El cdigo que hemos escrito hasta ahora no es ms que texto relativamente sencillo de leer para nosotros. No es que sea prosaprecisamente, pero es an peor para nuestro Mac. No puede hacer nada con l! Se necesita un programa especial, llamadocompilador, para convertir este texto en un conjunto de instrucciones que el Mac pueda entender y ejecutar. El compilador es parte deXcode, el entorno de programacin gratuito de Apple. Deberas haber instalado Xcode desde el disco que viene con la copia de Mac

OS X. En cualquier caso, verifica que tienes la ltima versin, que puedes descargar en http://developer.apple.com (se requiereregistro gratuito).

Crear un proyecto

Arranca Xcode, que encontrars en /Developer/Applications. La primera vez te har responder algunas preguntas. Acepta lassugerencias que l haga, en principio son adecuadas y adems podrs modificarlas ms adelante en el men Preferencias. Paraempezar realmente, selecciona New Project en el men File. Aparece una ventana de dilogo con los tipos de proyecto disponibles.El aspecto puede variar ligeramente segn la versin de Xcode.

El asistente de Xcode te permite crear nuevos proyectos.

En este momento queremos crear un programa simple en Objective-C, sin GUI (Interfaz grfica de usuario), as que dentro deCommand Line Tool selecciona Type Foundation.

______________________________________________________________________________________

Become An Xcoder
http://developer.apple.com/http://developer.apple.com/


25/74

Introduce un nombre para tu aplicacin, como "justatry". Selecciona el lugar en el que quieres guardar tu proyecto y pulsa Finish.

El proyecto que estamos creando va a poder ejecutarse desde el Terminal (/Aplicaciones/Utilidades/Terminal). Si quieres evitartemolestias, asegrate de que el nombre del proyecto consta de una sola palabra (sin espacios). Tambin es costumbre que los nombres

de programas que se ejecutan en terminal comiencen por minscula. Por el contrario, los nombres de programas con interfaz grficasuelen comenzar por mayscula.

Explorando Xcode

A continuacin se muestra una ventana que t como programador vers con frecuencia. Tiene dos marcos principales a derecha eizquierda. El de la izquierda es "Groups & Files", desde el que accedemos a todos los elementos de los que consta nuestro proyecto.En este momento no hay demasiados, pero cuando creemos programas con interfaz grfica (GUI) y multiidioma, aqu veremos todoslos ficheros relacionados con la GUI y con los diferentes idiomas. Los ficheros se agrupan en carpetas, pero no busques esas carpetasen tu Mac con el Finder ya que son virtuales; aparecen aqu para organizar nuestro trabajo.

En el marco "Groups & Files" abre el grupo justatry (pulsando el tringulo gris que est a la izquierda de su nombre) y dentro de steabre el grupo Source. Dentro encontrars un fichero llamado justatry.m[1]. Recuerdas que todo programa debe contener unafuncin llamada main()? Bien, este es el fichero que contiene la funcin main(). Ms tarde en este captulo vamos a modificarla

para incluir el cdigo de nuestro programa. Si abres justatry.mte llevars una sorpresa: Apple ha creado ya por ti la funcinmain().

______________________________________________________________________________________

Become An Xcoder


26/74

Xcode mostrando la funcin main().

//[1]

#import

int main (int argc, const char * argv[]) //[1.2]{

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; //[1.4]

// insert code here...

NSLog(@"Hello, World!");

[pool drain]; //[1.7]

return 0;

}

Echa un vistazo al cdigo y busca elementos que puedas reconocer. Vers:

La sentencia import necesaria para poder utilizar funciones como NSLog().

La funcin main().

Las llaves entre las que debemos encerrar el cdigo de nuestro programa.

Un comentario, que nos invita a escribir cdigo en esa posicin.

Una instruccin con NSLog(), para mostrar una cadena de texto en pantalla.

Una sentencia return 0;.

Pero tambin hay algunas cosas que no reconocemos:

Los argumentos que se le pasan a la funcin main(). [1.2]

Una lnea que empieza por NSAutoreleasePool [1.4]

Otra lnea que contiene las palabras pool y drain [1.7].

______________________________________________________________________________________

Become An Xcoder
http://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.html


27/74

Personalmente no me gusta que los autores de libros me muestren a mi, como lector, cdigo lleno de elementos desconocidos y meprometan que ms adelante lo ver todo claro. Por eso he preferido explicar en captulos anteriores lo que son las funciones, para queno te enfrentes ahora a demasiados conceptos nuevos.

As que ahora ya sabes que las funciones son una forma de organizar el cdigo, que todos los programas tienen una funcin main()y cual es el aspecto de las funciones. An as, debo admitir que por ahora no puedo explicar completamente todo lo que ves en elejemplo [1]. Siento tener que pedirte que ignores lo que ves en [1.2, 1.4 y 1.7]. Antes debes familiarizarte con otros elementos deObjective-C. La buena noticia es que ya has pasado dos captulos complicados y los tres siguientes son bastante llevaderos, antes de

que tengamos que tratar de nuevo con cuestiones complejas.Si realmente no aguantas sin una explicacin, aqu va un resumen.

Los argumentos que se pasan a la funcin main() son necesarios para poder ejecutar el programa en el Terminal.

Los programas necesitan memoria para funcionar y deben dejarla a disposicin del resto cuando ya no es necesaria. Al comienzo delprograma, en [1.4], solicitamos la memoria y en [1.7] la liberamos justo antes de que el programa termine.

Build and run (Compilar y ejecutar)

Ejecutemos el programa que ha preparado Apple [1]. En primer lugar necesitamos abrir la ventana Console (Consola), que est en elmen Run, para ver los resultados. Despus pulsaremos el icono del martillo con el texto "Build and Run" para que se compile yejecute el programa.

El botn Build and Run.

El programa se ejecuta y se muestran sus resultados en la ventana Console, junto con informacin adicional. La ltima lnea notificaque el programa ha finalizado con un valor de estado 0. Ese es el valor que ha devuelto la funcin main(), tal como vimos en elcaptulo 3 [7.9]. Por tanto, nuestro programa ha llegado hasta la ltima lnea sin haber terminado prematuramente. No est mal paraempezar!

Control de errores

Vayamos al ejemplo [1] y veamos qu sucede cuando hay un error en el programa. Por ejemplo, he reemplazado la sentencia NSLog() con otra, pero he olvidado poner el carcter punto y coma al final.

//[2]

#import

int main (int argc, const char * argv[])

{

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

// insert code here...

NSLog(@"Julia es mi actriz favorita") //Oh, he olvidado el punto y coma!

[pool drain]; //[2.9]

return 0;

}

Para compilar la aplicacin pulsa el icono Build en la barra de herramientas (si no lo tienes, pulsa la opcin Build dentro del menBuild). Aparecer un indicador rojo antes de la lnea [2.9].

______________________________________________________________________________________

Become An Xcoder
http://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.html


28/74

Xcode seala un error de compilacin.

Segn la versin de Xcode podrs ver una descripcin del error a la derecha de la lnea o tendrs que pulsar en el marcador rojo paraque se despliegue la descripcin del error.

Lo primero que hace el compilador es analizar el cdigo, recorriendo cada lnea para comprobar si puede entender su contenido.Nosotros, para ayudarle, tenemos que dejarle algunas pistas. Por ejemplo, antes de cada sentencia import hay que poner unaalmohadilla (#). Tambin, para indicar el final de una instruccin, hay que poner un punto y coma. En el momento en que llega a lalnea [2.9] es cuando el compilador se da cuenta de que algo va mal, pero no sabe que el problema no est en esta lnea sino en laanterior, en la que falta el punto y coma. La leccin que debemos aprender es que la informacin que nos da el compilador nosiempre es una descripcin precisa del error, e incluso puede que no sea exacta la posicin del error (aunque seguro que est muycerca).

Arregla el programa aadiendo el punto y coma y ejectalo de nuevo para asegurarte de que funciona.

Nuestra primera aplicacin

Ahora vamos a coger el programa que preparamos en el captulo anterior y lo mezclamos con el cdigo que ha escrito ya Apple.Debera quedar algo as [3]:

//[3]

#import

float calculaAreaDelCirculo(float radio); //[3.3]

float calculaAreaDelRectangulo(float ancho, float alto); //[3.4]

int main(int argc, const char * argv[]) // [3.6]

{

" NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];float anchoDelDibujo, altoDelDibujo, areaDelDibujo,

radioDelCirculo, areaDelCirculo;




areaDelDibujo = calculaAreaDelRectangulo(anchoDelDibujo, altoDelDibujo);

areaDelCirculo = calculaAreaDelCirculo(radioDelCirculo);

NSLog(@"Area del crculo: %10.2f.", areaDelCirculo);

NSLog(@"Area del cuadrado: %f.", areaDelDibujo);

" [pool drain];return 0;

}

float calculaAreaDelCirculo(float radio) // [3.22]

{

______________________________________________________________________________________

Become An Xcoder
http://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/ObjC_classic/Classes/NSAutoreleasePool.html


29/74

float area;


return area;

}

float calculaAreaDelRectangulo(float ancho, float alto) // [3.29]

{return ancho * alto;

}

Toma tu tiempo para asegurarte de que entiendes la estructura del programa. Tenemos las declaraciones de nuestras propias funcionesen [3.3 y 3.4] antes de la funcin main() en la lnea [3.6]. Nuestras funciones estn implementadas fuera de las llaves de la funcinmain() y hemos puesto el cuerpo de nuestra funcin main() en el lugar que nos haba indicado Apple.

Cuando ejecutemos el programa, obtendremos la siguiente salida:

Running

2010-03-14 00:54:24.494 justatry[8613:a0f] Area del crculo: 78.54.

2010-03-14 00:54:24.496 justatry[8613:a0f] Area del cuadrado: 36.000000.Debugger stopped.

Program exited with status value:0.

Depurando

Segn se van complicando los programas, se hacen ms difciles de depurar. Xcode nos da la opcin de saber qu sucede dentro delprograma mientras

Convertirse en Un Xcoder

Documents

Transcript of Convertirse en Un Xcoder