Cocoa_Objetive-C_Xcode

BecomeAnXcoder

Aprende a programar en Mac desde cero

Bert

Altenburg,

Alex

Clarke

y

Philippe

Mougin

Indice



About - Pagina 3 Introducción - Pagina 4 00: Antes de empezar - Pagina 5 01: Un programa es una serie de instrucciones - Pagina 7 02: Sin comentarios? Inaceptable! - Pagina 15 03: Funciones - Pagina 17 04: Salida en pantalla - Pagina 23 05: Compilación y ejecución de un Programa - Pagina 28 06: Sentencias condicionales - Pagina 38 07: Ejecución de bucles - Pagina 41 08: Programas con entorno gráfico - Pagina 44 09: Búsqueda de métodos -Pagina 65 10: awakeFromNib - Pagina 69 11: Punteros - Pagina 71 12: Cadenas de caracteres - Pagina 74 13: Arrays - Pagina 81 14: Accessors y propiedades -Pagina 85 15: Gestión de memoria - Pagina 88 16: Fuentes de información - Pagina 91 Licencia - Pagina 93

1

About

Este libro tiene como propósito introducirle a los conceptos fundamentales de la programación
 de el sistema Mac utilizando Xcode y Objective-C. No se requiere experiencia previa en programación.

2

Introducción Apple te ofrece todas las herramientas necesarias para desarrollar aplicaciones basadas en Cocoa, de forma gratuita. Este conjunto de herramientas, conocido con el nombre de Xcode, viene incluido con Mac OS X, o puedes bajarlo de la sección de desarrolladores en el sitio web de Apple.
 Existen varios buenos libros sobre programación para Mac, pero asumen que ya tienes experiencia en programación. Este libro no. Se enseñan los conceptos básicos de programación, en particular con Objective-C, usando Xcode. Después de unos 5 capítulos, serás capaz de crear un programa básico, sin una interfaz gráfica de usuario (GUI). Después de unos capítulos más, sabrás cómo crear programas sencillos con un GUI. Cuando hayas terminado de leer este folleto, estarás listo para utilizar libros más avanzados. Tendrá que estudiar esos libros también, porque hay mucho más que aprender. Por ahora, sin embargo, no te preocupes porque este libro toma las cosas con calma.

Cómo usar este libro Como podrás observar, algunos párrafos se muestran en un recuadro como el siguiente: puntos técnicos Te sugerimos leer cada capítulo dos veces (por lo menos). La primera vez pasa la caja de texto. La segunda vez que leas los capítulos incluye la caja de texto. Vas a ensayar en la práctica lo que has aprendido y aprenderás algunos puntos técnicos interesantes que hubieran sido distracciones la primera vez. Al utilizar el libro de esta manera, lograrás que la inevitable curva de aprendizaje sea una suave pendiente.
 Este libro contiene docenas de ejemplos, que constan de una o más líneas de código de programación. Para asegurarse de que asocies una explicación a su respectivo ejemplo, cada ejemplo tiene la etiqueta de un número colocado entre corchetes, de esta manera: [1]. La mayoría de los ejemplos tienen dos o más líneas de código. A veces, un segundo número se utiliza para referirse a una determinada línea. Por ejemplo, [1.1] se refiere a la primera línea del ejemplo [1]. En los fragmentos largos de código, ponemos la referencia después de una línea de código, de esta manera: //[1] volumen = base * altura;

// [1.1]

La programación no es un trabajo simple . Se requiere un poco de perseverancia y que tú mismo trates de hacer todas las cosas que se enseñan en este libro. No se puede aprender a tocar el piano o conducir un coche exclusivamente por la lectura de libros. Lo mismo vale para aprender a programar. Este libro está en un formato electrónico, por lo que no tienes ninguna excusa para utilizar Xcode con frecuencia. Por lo tanto, a partir del capítulo 5, te sugerimos que vayas a través de cada capítulo en tres ocasiones. La segunda vez, prueba los ejemplos y haz pequeñas modificaciones al código para explorar cómo funcionan las cosas.

3

0 Antes de empezar Escribimos este libro para usted. Como es gratis, por favor permítame decir un par de palabras sobre la promoción de la Mac a cambio. Cada usuario de Macintosh puede ayudar a promover su plataforma preferida con un poco esfuerzo. Aquí es cómo. Cuanto más eficiente con la Mac sea usted, más fácil es llevar a otras personas a considerar una Mac. Por lo tanto, tratar de estar al día visitando sitios web orientados a la Mac y leer revistas de Mac. Por supuesto, el aprendizaje de Objective-C o AppleScript y ponerlos 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 más visible. El uso de una camiseta en público con el logo de Mac es una manera, pero hay otras maneras, puede hacer que el Mac sea más visibles dentro de su hogar. Si ejecuta Activity Monitor (en la carpeta Utilidades, que se encuentra en la carpeta de Aplicaciones de tu Mac), te darás cuenta de que tu Mac utiliza todo su poder de procesamiento sólo de vez en cuando. Los científicos han puesto en marcha varios proyectos de informática distribuida (DC) , como el Folding@home o SETI@home, que aprovechar esta potencia de procesamiento no utilizada, por lo general en pro del bien común. Usted descarga un pequeño programa gratuito, llamado DC client, y empezara a procesar unidades de trabajo. Estos clientes DC correr con menor nivel de prioridad. Si estás usando un programa en tu Mac y las necesidades del programa requieren plena potencia de procesamiento, el DC client inmediatamente toma menor prioridad. Así, usted no notará que está funcionando. ¿Cómo ayuda esto a las Mac? Bueno, la mayoría de los proyectos DC mantienen rankings en sus sitios web de las unidades procesadas hasta la fecha. Si se inscribe en un equipo Mac (reconocerá sus nombre en los rankings), puede ayudar al equipo Mac de su elección para ascender en la clasificación. Así, los usuarios de otras plataformas de ordenador veran que tan bien las Macs están haciendo. Hay DC clients que se concentran en varios temas, como matemáticas, curar enfermedades y mucho más. Para elegir un proyecto DC que te gusta, echa un vistazo a: http://distributedcomputing.info/projects.html Un problema con esta sugerencia: Se puede llegar a ser adicto! Asegúrese de que la plataforma Macintosh tiene el mejor software. No, no sólo mediante la creación de programas propios. Haga un hábito de dar (cortés) retroalimentación a los desarrolladores de programas que usted utiliza. Incluso si trató una pieza de software y no le gusto, expliquele al desarrollador por qué. Asegúrese de informar sobre errores y proporcione una descripción exacta como sea posible de las acciones que realizó cuando se experimentó el error.


4

Pagar por el software que usted utiliza. Mientras el mercado de software para Macintosh sea viable, los desarrolladores seguirán proveyendo buen software. Póngase en contacto con al menos 3 usuarios de Macintosh que podrían estar interesados en programación, digales acerca de este libro y dónde encontrarlo. O asesorelos sobre los 4 puntos mencionados arriba. OK, mientras el DC client termina de descargar en el fondo, vamos a empezar!

5

1 Un programa es una serie de instrucciones Presentación Para conducir un automóvil, tienes que aprender a controlar varias cosas a la vez. La programación también requiere que mantengas un montón de cosas en mente, o tu programa romperá. Mientras que al menos ya conocías el interior de un coche antes de aprender a conducir, no tendrás esa ventaja cuando trates de aprender a programar con Xcode. Para no abrumarte, dejamos el entorno de programación para un capítulo posterior. En primer lugar, vamos a hacer que te sientas cómodo con algunos conceptos de Objective-C, empezando por la matemática básica. En la escuela primaria había que hacer cálculos, rellenando los puntos: 2 + 6 = ……..
 …….. = 3 * 4 (el asterisco * es la forma estándar para representar la multiplicación 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 la gran sensación. Mirando hacia atrás, puede que te preguntes por qué nos hemos sentido tan intimidados en su momento por este pequeño cambio en la notación. 2 + 6 = x
 y = 3 * 4

Variables Objective-C también utiliza variables. Las variables no son nada más que nombres para referirse a unos datos concretos, como por ejemplo un número. Aquí tenemos una sentencia Objective-C, es decir, una línea de código, en la que asignamos un valor a una variable. //[1] x = 4;

El punto y coma Se le ha asignado el valor 4 a la variable x. Te habrás dado cuenta de que hay un punto y coma al final de la instrucción. Esto se debe a que se requiere que todas las instrucciones terminen en punto y coma. ¿Por qué? Bien, el trozo de código 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 idioma puede ser muy difícil para un compilador así que debemos darle al-

6

gunas pistas, por ejemplo: indicarle dónde termina cada sentencia; y eso es lo que hacemos con el punto y coma. Si te olvidas el punto y coma en tu código, éste no se podrá compilar, es decir, no se va a poder convertir en un programa que tu Mac pueda ejecutar. No te preocupes ahora de eso, pues el compilador se quejará si hay algún problema y, como veremos en un capítulo posterior, 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 sí que nos puede facilitar la lectura del programa y hacerlo más comprensible. Ten esto en cuenta para cuando tengas que buscar errores en tu código. Por tradición se llaman "bugs" (bichos) a los errores de los programas. A la búsqueda y reparación de bugs se le llama debugging (en español solemos decir depuración). Por tanto, en programas reales evitaremos usar nombres de variables no descriptivos tales como x. Por ejemplo, el nombre de la variable en la que almacenaríamos el ancho de un dibujo sería anchoDibujo [2]. //[2] anchoDibujo = 8;

Ahora que sabes que para el compilador es un gran problema que te olvides del punto y coma, comprenderás que en la programación hay que prestar atención a los detalles. Uno de esos detalles es que el código es sensible a mayúsculas/minúsculas. Es decir, la variable anchoDibujo no es la misma que anchoDIBUJO ni que AnchoDibujo. La convención que vamos a seguir para los nombres de variables es unir varias palabras, la primera iniciada por minúsculas y el resto por mayúsculas, tal como has visto en el ejemplo [2]. A este estilo se le suele llamar camelCase (se llama así por las jorobas del camello, en inglés camel. Cada mayúscula 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. Tienes total libertad para elegir el nombre de tus variables, pero hay una serie de reglas que debes seguir: la primera es que no puede ser el nombre de una palabra reservada de Objective-C (palabras que tienen un significado especial para Objective-C). Si tus variables están compuestas al menos de dos palabras unidas, como por ejemplo anchoDibujo, no vas a tener problema. Para facilitar la lectura se recomienda poner en mayúscula la inicial de cada palabra excepto la primera, tal como hemos visto. Sigue este esquema para evitar bugs en tus programas. Si no te importa aprender un par de reglas más, sigue leyendo. También se permite el uso de dígitos además de letras, pero no puedes usar un dígito al comienzo del nombre. También se permite el guión bajo: "_". Vamos a ver ejemplos de nombres de variables. • • • • •

Nombres válidos de variables: puerta8k pu3rta puer_ta Nombres no permitidos:

7

• • • •

puerta 8 (porque contiene un espacio) 8puerta (porque empieza por un dígito) Nombres válidos pero no recomendados: Puerta8 (porque empieza por mayúscula)

Uso de variables en cálculos

Ahora que sabemos como asignar un valor a una variable, podemos hacer cálculos. Echemos un vistazo al código para calcular la superficie de un dibujo [3]. //[3] anchoDibujo=8; altoDibujo=6; areaDibujo=anchoDibujo*altoDibujo;

Sorprendentemente, al compilador no le importan los espacios (con la excepción, como ya sabemos, de que están prohibidos en los nombres de variables), así que podemos usar todos los que queramos para facilitar la lectura de nuestro código. //[4] anchoDibujo = 8; altoDibujo = 6; areaDibujo = anchoDibujo * altoDibujo;

Y en un arranque de generosidad, el compilador también nos permite introducir saltos de línea en medio de las instrucciones ¿te imaginas por qué? Pues porque, si recuerdas lo que vimos un poco más arriba, él va a interpretar todo como una sola instrucción hasta que encuentre el punto y coma (el indicador de fin de instrucción). Podemos usar esta característica para facilitar la lectura en líneas excesivamente largas. Así que lo siguiente también sería válido para el compilador (pero también bastante incómodo de leer):   anchoDibujo = 8; altoDibujo = 6; areaDibujo = anchoDibujo * altoDibujo;

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

8

anchoDibujo = 8; altoDibujo = 4.5; areaDibujo = anchoDibujo * altoDibujo;

Se pueden distinguir en general dos tipos de números: 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 un número determinado de veces (ver capítulo 7). Los números fraccionarios los usamos, por ejemplo, con los precios. Importante: Según el país, se usa como carácter separador de la parte decimal el punto "." o la coma ",". En Objective-C debemos emplear obligatoriamente siempre el punto. El código del ejemplo [5] no funcionaría. El problema es que el compilador necesita que le indiques previamente el nombre de las variables que vas a usar en tu programa y también qué tipo de dato va a contener cada una. Eso es lo que llamamos "declarar una variable". //[6] int anchoDibujo; // [6.1] float altoDibujo, areaDibujo; // [6.2] anchoDibujo = 8; altoDibujo = 4.5; areaDibujo = anchoDibujo * altoDibujo;

En la línea [6.1], int indica que la variable anchoDibujo contiene un número entero. En la siguiente línea [6.2] declaramos dos variables con una sola instrucción, separando sus nombres con coma. En la sentencia también se indica que son de tipo float, lo que quiere decir que van a ser números con una parte fraccionaria. Llegados a este punto, parece que no tiene sentido que la variable anchoDibujo sea de tipo diferente a las otra dos. Pero lo que sabes es que si multiplicas un int por un float el resultado del cálculo es un float, que es la razón por la que deberías declarar la variable areaDibujo como float [6.2]. ¿Por qué quiere el compilador conocer si una variable representa a un número entero o a uno fraccionario? Bien, un programa usa parte de la memoria del ordenador y el compilador reserva espacio para cada variable que se declara, pero necesita saber el tipo, ya que cada tipo requiere una cantidad distinta y también se representa de forma distinta en la memoria del ordenador. ¿Y si necesitamos trabajar con números muy grandes o con gran precisión de decimales? ¿Van a poder representarse en los tipos que conocemos hasta ahora (int y float)? Bien, esta pregunta tiene dos respuestas: en primer lugar, existen otros tipos de datos para enteros más grandes (long) y para fraccionarios de más precisión (double). Pero incluso estos tipos de dato podrían no ser suficiente, 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 capítulo de un libro de introducción. Por cierto, los tipos que hemos visto pueden almacenar también números negativos. Si sabes que el valor de tu variable nunca va a ser negativo puedes restringir el rango de valores. //[7] unsigned int cajasDisponibles;

9

No tiene sentido que el número de cajas disponibles en el almacén sea negativo, así que en este caso podríamos usar unsigned int. El tipo unsigned int representa un número 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 específicos, por ejemplo int o float. En Objective-C, a los tipos de dato como esos se les llama también tipos escalares. A continuación mostramos una lista con los tipos de dato escalares más comunes de Objective-C: Nombre

Tipo

Ejemplo

void

Vacío

Nada

int

Número entero

...-1, 0, 1, 2...

unsigned Número entero positivo

0, 1, 2...

float

Número fraccionario

-0.333, 0.5, 1.223, 202.85556

double

Número fraccionario de doble precisión

0.52525252333234093890324592793021

char

Carácter

hola

BOOL

Boolean

0, 1; TRUE, FALSE; YES, NO.

Operaciones matemáticas En los ejemplos previos hemos realizado una multiplicación. Se usan los siguientes símbolos, conocidos oficialmente como "operadores", para realizar cálculos matemáticos básicos. + / *

suma resta división multiplicación

10

Aparte de estos operadores, si echamos un vistazo al código de un programa en Objective-C, podemos encontrarnos con un par de curiosidades, quizá porque los programadores son unos mecanógrafos 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 después del nombre de la variable. Fíjate 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 cálculo // por tanto "y" tiene el valor 20 //[12] x = 10; y = 2 * (++x); // "x" también vale ahora 11, pero su valor se asignó ANTES de hacer el cálculo // 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 cálculo en el que esté envuelta. Si usamos ++ después del nombre de la variable, se incrementará su valor después de utilizarse en el cálculo en el que esté envuelta. El código de [12] es equivalente al de [13]. //[13] x = 10; x++; // [13.2] y = 2 * x; // Como el incremento de x en la línea [13.2] no está envuelto en ninguna // operación, en este caso sería lo mismo usar ++x que x++  

Con esto se unen dos sentencias en una, pero quizá pueda hacer un poco más difícil de entender tu programa. Es correcto emplearlo pero ten en cuenta que puede estar acechando un bug por ahí.

Paréntesis

11

Seguro que ya lo sabes, pero los paréntesis se pueden utilizar para indicar el orden en el que queremos que se realicen las operaciones. La multiplicación y división tienen precedencia sobre la suma y la resta, así que, por ejemplo, 2 * 3 + 4 es igual a 10. Usando paréntesis podemos forzar a que se realice antes la suma que la multiplicación: 2 * (3 + 4) es igual a 14.

División La división requiere un poco de atención, ya que tiene un comportamiento distinto según usemos enteros o fraccionarios. Echa un vistazo 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 también es un número 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 matemático inventor de la lógica booleana) es un valor lógico 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 acción dependiendo del valor booleano de alguna variable o función.

Resto (en inglés: modulus) Probablemente no estés tan familiarizado con el operador %, que no tiene que ver con los porcentajes sino que calcula el resto de la división 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. Más ejemplos de este operador: 21 % 7 es igual a 0 22 % 7 es igual a 1

12

23 24 27 30 31 32 33 34 50 60

% % % % % % % % % %

7 es igual a 2 7 es igual a 3 7 es igual a 6 2 es igual a 0 2 es igual a 1 2 es igual a 0 2 es igual a 1 2 es igual a 0 9 es igual a 5 29 es igual a 2

Puede sernos útil en ocasiones, pero ten en cuenta que sólo funciona con enteros. Uno de los usos más comunes del operador % es determinar si un número es par o impar. Si es par, su resto entre 2 es 0, si es impar entonces será 1. Por ejemplo: //[17] int unNumero; //Aquí escribiríamos código que asigna un valor a "unNumero" if ((unNumero % 2) == 0) // [17.3] { NSLog(@"unNumero es par"); } else { NSLog(@"unNumero es impar"); }

En la línea [17.3] se ha empleado un condicional, que verás en el capítulo 6. Podríamos traducir la instrucción como: "si el resto de la división unNumero entre 2 es igual a 0, entonces …"

13

2 Sin comentarios? Inaceptable! Introducción Si utilizamos nombres de variables con sentido, haremos que nuestro código sea más legible y entendible [1]. //[1] float anchoDelDibujo, altoDelDibujo, areaDelDibujo; anchoDelDibujo = 8.0; altoDelDibujo = 4.5; areaDelDibujo = anchoDelDibujo * altoDelDibujo;

Hasta ahora nuestros ejemplos de código han sido de sólo unas pocas sentencias, pero incluso los programas más sencillos pueden crecer rápidamente hasta cientos o miles de líneas. Cuando revises tu programa después de algunas semanas o meses puede ser difícil recordar la razón por la que tomaste ciertas decisiones. Ahí es donde entran en acción los comentarios. Los comentarios ayudarán a comprender rápidamente lo que hace cada parte de tu programa y por qué. Algunos programadores van más allá y siempre comienzan a codificar cada clase como comentarios, con lo que se organizan mejor y evitan tener que improvisar código posteriormente. Recomendamos invertir tiempo en comentar el código. Podemos asegurarte que esa inversión será revertida con creces en el futuro. También, si compartes tu código con alguien más, tus comentarios ayudarán a que se adapte a tus propias necesidades más rápidamente.

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 líneas, enciérralo entre /* */. /* This is a comment extending over two lines */

14

Comentar código Hablaremos sobre la depuración dentro de poco, ya que Xcode tiene buenas herramientas para ello. Una de las formas de depuración a la vieja usanza es comentar el código. Comentamos código envolviendo las instrucciones entre /* */, de esta forma deshabilitamos el código, impidiendo su ejecución y podemos comprobar si el resto funciona como esperábamos. Esto puede ayudarnos a encontrar errores. Si, por ejemplo, la parte de código comentada asigna valores a una variable, podemos añadir una línea de código temporal que asigne a esa variable un valor que nos sirva para comprobar el resto de nuestro código.

¿Por qué incluir comentarios? No debemos desestimar la importancia de los comentarios. Frecuentemente es útil incluir explicaciones en nuestro idioma sobre lo que hace una serie de instrucciones. Así no hay que estar deduciendo qué es lo que hace esa parte de código y podemos darnos cuenta inmediatamente de si el problema tiene su origen o no en esa sección. Además podemos usar los comentarios para explicar cosas difíciles o casi imposibles de deducir leyendo el código. Por ejemplo, si programas una función matemática que encontraste detallada en un libro, podrías poner la referencia bibliográfica dentro de un comentario. A veces es útil hacer los comentarios antes de escribir el código. Eso ayudará a estructurar tus pensamientos y como resultante la programación será mas fluida. Los ejemplos de código que encontrarás en este libro no contienen tantos comentarios como generalmente se deberían poner, pero eso es porque ya se dan las explicaciones en el texto que los precede.

15

3 Funciones Introducción El trozo de código más largo que hemos visto hasta ahora tenía sólo cinco líneas. Los programas de varias miles de líneas parecen quedarnos aún muy lejos, pero debido a la naturaleza de Objective-C, debemos discutir la forma de organizar los programas en esta etapa temprana. Si un programa consistiese en una sucesión larga y continua de instrucciones sería difícil encontrar y reparar errores. Además, una serie concreta de instrucciones podría aparecer en varias partes de tu programa. Si hubiese en ellas algún error, deberías arreglar el mismo error en varios lugares. Eso sería una pesadilla porque sería fácil olvidarse de uno (o varios). Por tanto, la gente ha pensado una solución para organizar el código, facilitando la corrección de errores. La solución a este problema es agrupar las instrucciones dependiendo de la tarea que realicen. Por ejemplo, tienes una serie de instrucciones que calculan el área de un círculo. Una vez que has comprobado que esas instrucciones funcionan correctamente, nunca tendrás que volver a ese código para examinar si hay algún error en él. El conjunto de instrucciones, llamado función (function en inglés), tiene un nombre y puedes llamarlo por ese nombre cada vez que necesites que se ejecute ese código. Este concepto de usar funciones es fundamental, de hecho siempre hay al menos una función en un programa: la función main(). Esta función main() es la que busca el compilador para saber por donde debe empezar la ejecución del programa.

La función main() Pasemos a estudiar la función main() con más detalle. [1] //[1] main() { // Cuerpo de la función main(). Escribe aquí tu código. }

La sentencia [1.1] muestra el nombre de la función, en este caso "main", seguido de la apertura y cierre de paréntesis. Es obligatorio que exista esta función main(), que por otro lado es una palabra reservada (lo que significa entre otras cosas que no podemos usarla como nombre para nuestras variables). Cuando creemos nuestras funciones podremos darles el nombre que queramos. Los paréntesis están ahí por una buena razón, pero la conoceremos más adelante en este capítulo. En las siguiente líneas [1.3, 1.5], hay llaves. Debemos poner nuestro código entre esas llaves { }. Cualquier

16

cosa entre las llaves es lo que llamamos el cuerpo de la función. He copiado código del primer capítulo y lo he puesto aquí en donde corresponde [2]. //[2] main() { // A continuación se declaran las variables float anchoDelDibujo, altoDelDibujo, superficieDelDibujo; // Asignamos un valor inicial a las variables anchoDelDibujo = 8.0; altoDelDibujo = 4.5; // Aquí se realiza el cálculo superficieDelDibujo = anchoDelDibujo * altoDelDibujo; }

Nuestra primera función Si escribimos todo nuestro código en el cuerpo de la función main(), eso nos llevaría al problema del código desestructurado y difícil de depurar que queremos evitar. Así que escribamos otro programa, ahora con un poco de estructura. Además de la función main() obligatoria crearemos una función calculaAreaDelCirculo() [3]. //[3] main() { float anchoDelDibujo, altoDelDibujo, superficieDelDibujo; anchoDelDibujo = 8.0; altoDelDibujo = 4.5; superficieDelDibujo = anchoDelDibujo * altoDelDibujo; } calculaAreaDelCirculo() // [3.9] { }

Ha sido fácil, pero nuestra función definida desde la línea [3.9] aún no hace nada. Observa que la especificación de la función está fuera del cuerpo de la función main(). En otras palabras, las funciones no están anidadas. Queremos que nuestra nueva función calculaAreaDelCirculo() sea llamada desde la función main(). Veamos cómo podemos hacerlo [4]. //[4] main() { float anchoDelDibujo, altoDelDibujo, superficieDelDibujo, radioDelCirculo, superficieDelCirculo; // [4.4]

17

anchoDelDibujo = 8.0; altoDelDibujo = 4.5; radioDelCirculo = 5.0; // [4.7] superficieDelDibujo = anchoDelDibujo * altoDelDibujo; // ¡Aquí es donde llamamos a nuestra función! superficieDelCirculo = calculaAreaDelCirculo(radioDelCirculo); // [4.10] }

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

Pasar argumentos a la función Hemos añadido un par de nombres de variable de tipo float [4.4], y hemos inicializado la variable radioDelCirculo dándole un valor [4.7].
 Tiene más interés la línea [4.10], en la que llamamos a la función calculaAreaDelCirculo(). Como puedes ver, el nombre de la variable radioDelCirculo se ha puesto entre paréntesis. Es un argumento de la función calculaAreaDelCirculo(). El valor de la variable radioDelCirculo se pasa a la función calculaAreaDelCirculo(). Cuando la función calculaAreaDelCirculo() ha hecho su tarea debe devolver un valor, en este caso el resultado del cálculo de la superficie. Modifiquemos el código de la función calculaAreaDelCirculo() [5]. Nota: sólo se muestra el código de la función 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 función calculaAreaDelCirculo(). Cuando se recibe, ese valor es almacenado en una variable llamada radio. Usamos una segunda variable, area, para almacenar el resultado del cálculo en [5.4], así que la declaramos en [5.3] de la misma forma que hemos declarado variables en la función main() [4.4]. Verás que la declaración de la variable radio se ha hecho dentro de los paréntesis [5.1]. La línea [5.5] devuelve el resultado a la parte del programa desde la que fue llamada esta función. Como consecuencia, en la línea [4.10], se asigna ese valor a la variable superficieDelCirculo. La función en el ejemplo [5] está completa, excepto por una cosa. No hemos especificado el tipo de datos que devolverá la función. El compilador nos va a requerir ese dato, así que no nos queda otra opción que obedecerle e indicar que es de tipo float [6.1]. //[6] float calculaAreaDelCirculo(float radio) { float area; area = 3.1416 * radio * radio; return area;

//[6.1]

18

… Hasta aquí la previsualización.

Puedes descargar este documento completo en

http://tutorialesenpdf.com/xcode/