05: Compilación y ejecución de un Programa

Introducción

El código que hemos escrito hasta ahora no es más que texto relativamente sencillo de leer para nosotros. No es que sea prosa precisamente, pero es aún peor para nuestro Mac. ¡No puede hacer nada con él! Se necesita un programa especial, llamado compilador, para convertir este texto en un conjunto de instrucciones que el Mac pueda entender y ejecutar. El compilador es parte de Xcode, el entorno de programación gratuito de Apple. Deberías haber instalado Xcode desde el disco que viene con la copia de Mac OS X. En cualquier caso, verifica que tienes la última versión, que puedes descargar en http://developer.apple.com (se requiere registro gratuito).

Crear un proyecto

Arranca Xcode, que encontrarás en /Developer/Applications. La primera vez te hará responder algunas preguntas. Acepta las sugerencias que él haga, en principio son adecuadas y además podrás modificarlas más adelante en el menú Preferencias. Para empezar realmente, selecciona New Project en el menú File. Aparece una ventana de diálogo con los tipos de proyecto disponibles. El aspecto puede variar ligeramente según la versión de Xcode.

01 New Project

El asistente de Xcode te permite crear nuevos proyectos.

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

02 New Title

Introduce un nombre para tu aplicación, 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 evitarte molestias, asegúrate de que el nombre del proyecto consta de una sola palabra (sin espacios). También es costumbre que los nombres de programas que se ejecutan en terminal comiencen por minúscula. Por el contrario, los nombres de programas con interfaz gráfica suelen comenzar por mayúscula.

Explorando Xcode

A continuación se muestra una ventana que tú como programador verás con frecuencia. Tiene dos marcos principales a derecha e izquierda. 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 gráfica (GUI) y multiidioma, aquí veremos todos los ficheros relacionados con la GUI y con los diferentes idiomas. Los ficheros se agrupan en carpetas, pero no busques esas carpetas en 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 triángulo gris que está a la izquierda de su nombre) y dentro de éste abre el grupo Source. Dentro encontrarás un fichero llamado justatry.m [1]. ¿Recuerdas que todo programa debe contener una función llamada main()? Bien, este es el fichero que contiene la función main(). Más tarde en este capítulo vamos a modificarla para incluir el código de nuestro programa. Si abres justatry.m te llevarás una sorpresa: Apple ha creado ya por ti la función main().

03 Xcode Window

Xcode mostrando la función main().

//[1]
#import <Foundation/Foundation.h>
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 código y busca elementos que puedas reconocer. Verás:

  • La sentencia import necesaria para poder utilizar funciones como NSLog().
  • La función main().
  • Las llaves entre las que debemos encerrar el código de nuestro programa.
  • Un comentario, que nos invita a escribir código en esa posición.
  • Una instrucción con NSLog(), para mostrar una cadena de texto en pantalla.
  • Una sentencia return 0;.

Pero también hay algunas cosas que no reconocemos:

  • Los argumentos que se le pasan a la función main(). [1.2]
  • Una línea que empieza por NSAutoreleasePool [1.4]
  • Otra línea que contiene las palabras pool y drain [1.7].

Personalmente no me gusta que los autores de libros me muestren a mi, como lector, código lleno de elementos desconocidos y me prometan que más adelante lo veré todo claro. Por eso he preferido explicar en capítulos anteriores lo que son las funciones, para que no te enfrentes ahora a demasiados conceptos nuevos.

Así que ahora ya sabes que las funciones son una forma de organizar el código, que todos los programas tienen una función main() y cual es el aspecto de las funciones. Aún así, debo admitir que por ahora no puedo explicar completamente todo lo que ves en el ejemplo [1]. Siento tener que pedirte que ignores lo que ves en [1.2, 1.4 y 1.7]. Antes debes familiarizarte con otros elementos de Objective-C. La buena noticia es que ya has pasado dos capítulos 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 explicación, aquí va un resumen.

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

Los programas necesitan memoria para funcionar y deben dejarla a disposición del resto cuando ya no es necesaria. Al comienzo del programa, 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 el menú Run, para ver los resultados. Después pulsaremos el icono del martillo con el texto "Build and Run" para que se compile y ejecute el programa.

04 Build

El botón Build and Run.

El programa se ejecuta y se muestran sus resultados en la ventana Console, junto con información adicional. La última línea notifica que el programa ha finalizado con un valor de estado 0. Ese es el valor que ha devuelto la función main(), tal como vimos en el capítulo 3 [7.9]. Por tanto, nuestro programa ha llegado hasta la última línea sin haber terminado prematuramente. ¡No está mal para empezar!

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 carácter punto y coma al final.

//[2]
#import <Foundation/Foundation.h>
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 aplicación pulsa el icono Build en la barra de herramientas (si no lo tienes, pulsa la opción Build dentro del menú Build). Aparecerá un indicador rojo antes de la línea [2.9].

05 Parse Error

Xcode señala un error de compilación.

Según la versión de Xcode podrás ver una descripción del error a la derecha de la línea o tendrás que pulsar en el marcador rojo para que se despliegue la descripción del error.

Lo primero que hace el compilador es analizar el código, recorriendo cada línea 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 una almohadilla (#). También, para indicar el final de una instrucción, hay que poner un punto y coma. En el momento en que llega a la línea [2.9] es cuando el compilador se da cuenta de que algo va mal, pero no sabe que el problema no está en esta línea sino en la anterior, en la que falta el punto y coma. La lección que debemos aprender es que la información que nos da el compilador no siempre es una descripción precisa del error, e incluso puede que no sea exacta la posición del error (aunque seguro que está muy cerca).

Arregla el programa añadiendo el punto y coma y ejecútalo de nuevo para asegurarte de que funciona.

Nuestra primera aplicación

Ahora vamos a coger el programa que preparamos en el capítulo anterior y lo mezclamos con el código que ha escrito ya Apple. Debería quedar algo así [3]:

//[3]
#import <Foundation/Foundation.h>
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;
    anchoDelDibujo  = 8.0;
    altoDelDibujo = 4.5;
    radioDelCirculo  = 5.0;
    areaDelDibujo = calculaAreaDelRectangulo(anchoDelDibujo, altoDelDibujo);
    areaDelCirculo = calculaAreaDelCirculo(radioDelCirculo);
    NSLog(@"Area del círculo: %10.2f.", areaDelCirculo);
    NSLog(@"Area del cuadrado: %f.", areaDelDibujo);
	[pool drain];
    return 0;
}
float calculaAreaDelCirculo(float radio)  // [3.22]
{
    float area;
    area = 3.1416 * radio * radio;
    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 funciones en [3.3 y 3.4] antes de la función main() en la línea [3.6]. Nuestras funciones están implementadas fuera de las llaves de la función main() y hemos puesto el cuerpo de nuestra función main() en el lugar que nos había indicado Apple.

Cuando ejecutemos el programa, obtendremos la siguiente salida:

Running…
2010-03-14 00:54:24.494 justatry[8613:a0f] Area del círculo:      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

Según se van complicando los programas, se hacen más difíciles de depurar. Xcode nos da la opción de saber qué sucede dentro del programa mientras está corriendo. Para ello haremos click con el ratón en el margen gris que está a la izquierda del código (en la zona en la que aparecen los números de línea), en la línea en la que queremos que el programa nos muestre los valores de las variables. En ese punto Xcode insertará un "breakpoint" (punto de ruptura), representado por una flecha azul.

06 Breakpoint

Colocando breakpoints (puntos de ruptura) en nuestro código. En este caso podemos ver uno en la línea 15

En la siguiente sección veremos cómo el Debugger nos muestra el estado de las variables al llegar al punto de ruptura. Pero ten en cuenta que serán los valores de "antes" de que se ejecute la línea en la que hemos parado, así que puede que te convenga poner el breakpoint "después" de la línea que te interesa.

En cuanto insertes el primer breakpoint verás que el icono con el martillo cambia ligeramente y en el texto se lee "Build and Debug" (Compilar y depurar). En versiones anteriores tienes que mantener pulsado el ratón en el icono del martillo hasta que aparezca un menú.

07 Build Menu

El botón de compilar y depurar.

Para seguir lo que está sucediendo necesitas abrir dos ventanas: Console y Debugger, que están en el menú Run. La Consola mostrará un texto parecido a este:

[Session started at 2009-06-03 15:48:02 +1000.]
Loading program into debugger…
GNU gdb 6.3.50-20050815 (Apple version gdb-956) (Wed Apr 30 05:08:47 UTC 2008)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-apple-darwin".tty /dev/ttys000
Program loaded.
sharedlibrary apply-load-rules all
run
[Switching to process 86746 local thread 0x2d03]
Running…
 

Esto quiere indica que nuestra aplicación ha sido compilada y lanzada, y que se ha cargado el Debugger (depurador).

La ventana del Debugger tendrá un aspecto parecido a este:

08 Debugger

El Depurador de Xcode te permite ejecutar el programa paso a paso y consultar el valor de las variables.

El programa se ejecutará hasta que alcance el primer breakpoint. Si compruebas el panel superior derecho puedes leer el valor de las variables. Se muestran en color rojo los valores que han cambiado desde el anterior breakpoint. Para continuar la ejecución pulsa el botón Continue. Los botones Step Over y Step Into sirven para ejecutar el programa instrucción a instrucción. Prueba el Debugger durante un rato para familiarizarte con él, es una herramienta poderosa.

Conclusión

Ya tenemos todo lo necesario para escribir, depurar y ejecutar programas sencillos para Mac OS X.

Si no deseas realizar programas con interfaz gráfico, todo lo que te falta es ir conociendo en profundidad Objective-C para desarrollar programas no gráficos más sofisticados. En los siguientes capítulos vamos a hacer exactamente eso. Y después, nos sumergiremos en aplicaciones con GUI (Interfaz Gráfico de Usuario). ¡Sigue leyendo!

Post new comment

The content of this field is kept private and will not be shown publicly.
Enter the code shown in the image:

CAPTCHA
This question is for testing whether you are a human visitor and to prevent automated spam submissions.
1 + 2 =
Solve this simple math problem and enter the result. E.g. for 1+3, enter 4.

Donate!





If you like what you find here and wish to support further development of this site, please donate via PayPal. No account required.

Syndicate

Syndicate content

User login

CAPTCHA
This question is for testing whether you are a human visitor and to prevent automated spam submissions.
5 + 7 =
Solve this simple math problem and enter the result. E.g. for 1+3, enter 4.
Enter the code shown in the image: