El manual de usuario de KDevelop: Desarrollo con KDevelop
Description: Manual de usuario de KDevelop

Página siguiente Página anterior Índice general

### 4. Desarrollo con KDevelop

En este capítulo obtendrá una visión general sobre como utilizar KDevelop y el editor de diálogos interno para crear sus propias aplicaciones. Esto implica que todas las herramientas serán descritas en función de su uso en el proceso de desarrollo. Si es un principiante en el diseño y programación de aplicaciones C++ con interfaz de usuario, debería leer el Manual de programación de KDevelop, que describe algunas cosas básicas para el diseño de programas y muestra el uso, de forma más detallada, de KDevelop, con proyectos de ejemplo que puede seguir paso a paso para acostumbrarse a la forma en que se crean aplicaciones con KDevelop. Además, debería haber leído el capítulo Programas, para tener un conocimiento general sobre el por qué las aplicaciones Unix deben utilizar algunas de las herramientas de desarrollo incluidas; esto le ayudará a que las cosas estén más claras cuando se referencia a los ficheros Makefile, etc.

### 4.1 ¿Qué son los proyectos de KDevelop?

Los proyectos creados con KDevelop intentan facilitar el uso de las herramientas GNU a los desarrolladores. Los proyectos de KDevelop se encargan de la creación de los ficheros Makefile, evitando tener que crearlos a mano, además facilitan el transporte de los programas a plataformas diferentes gracias a la creación de ficheros configure con autoconf.

Al distribuir su aplicación, lo único que el usuario final debe tener para compilar el programa es un compilador de C++ y las bibliotecas de desarrollo necesarias, que suelen estar instaladas; por supuesto, también se puede distribuir un paquete con la aplicación ya compilada. En cualquier caso, no hace falta que el usuario final tenga instalado el KDevelop. A la hora de distribuir los ficheros fuente, le recomendamos que incluya el fichero de proyecto de KDevelop, ya que facilitará que otros usuarios de KDevelop puedan trabajar con sus fuentes. La distribución de este fichero se hace necesaria para proyectos que se realicen por varios desarrolladores, tal vez trabajando desde lugares distintos, ya que de esta forma asegurará la consistencia del fichero Makefile, evitando problemas. Permitirá además que, en aplicaciones multilíngüe, los traductores no tengan que trabajar con el código, salvo en los casos que halla que modificarlo para permitir su traducción. En cualquier caso, éstos agradecerán las opciones de KDevelop a la hora de añadir un nuevo idioma, permitiendo que el trabajo se reduzca a la traducción.

Cuando utilice KDevelop para sus propios proyecto, normalmente empezará creando una nueva aplicación con el asistente de aplicaciones. Desde ahí puede elegir el tipo de proyecto que se corresponde con el tipo de aplicación que desea crear. Tras esto, puede empezar a desarrollar la interfaz de usuario, añadiendo controles que ya estén construidos en las bibliotecas y sólo tienen que ser llamados desde la aplicación, o construyendo nuevos en el editor de diálogos. A continuación va la ampliación de la interfaz de usuario, cambiando y extendiendo las partes que KDevelop ya haya añadido, como las barras de estado, de menús, y de herramientas. Como los recursos están agrupados en ficheros de recursos, se pueden extender sencillamente añadiendo nuevos valores a los existentes; los recursos generados por KDevelop pueden utilizarse como referencia a la hora de crear nuevos. Tras implementar los métodos que el editor de diálogos creo vacios, o los que contienen código para acciones estándar, debería extender el manual de usuario editando el fichero SGML incluido, para describir las características de la aplicación. El último paso sería generar los ficheros de traducción y distribuir el proyecto entre los traductores.

KDevelop facilita la creación de nuevos proyectos incluso cuando la aplicación no tiene interfaz de usuario. El editor y el navegador de clases, junto con las facilidades para gestionar el proyecto que proporciona KDevelop, le ayudarán a reducir el tiempo de desarrollo al mínimo necesario para implementar su funcionalidad.

### 4.2 Breve descripción de las herramientas de KDevelop

Con KDevelop ha elegido un paquete que, junto con otras herramientas, le ofrecerá un entorno bajo sistemas Unix flexible y adecuado para el desarrollo de aplicaciones orientadas a objetos. KDevelop está compuesto básicamente por el entorno de programación y por el editor de diálogos; el resto de programas que pueden ser útiles al diseñar una aplicación también están incluidos, de una forma u otra.

#### El entorno de programación y el editor de diálogos

#### El entorno de programación

El entorno de programación es la interfaz de usuario que KDevelop ofrece para crear y mantener proyectos, utilizando implícitamente otras herramientas para simplificar su uso. El editor incorporado, junto con los navegadores de documentación y de clases, reduce la cantidad de trabajo que el programador ha de realizar durante el proceso de desarrollo. La facilidad de uso del programa hace que proceso de escribir aplicaciones para Unix sea agradable, y ayudará probablemente a reducir los ciclos de desarrollo y a mejoras en el desarrollo. Desde el entorno, podrá controlar todos los detalles de su proyecto, tendrá una visión general de sus clases y se le hará innecesario utilizar la consola para su trabajo. Además, la integración de todas las interfaces de usuario hace que usted sólo tenga que trabajar en una ventana, evitando tener que controlar un montón de ventanas repartidas por el escritorio.

#### El editor de diálogos

El editor de diálogos incorporado en KDevelop ofrece una manera fácil de diseñar interfaces de usuario que utilicen las bibliotecas Qt o KDE. Su funcionamiento le permite realizar casi todas las acciones con el ratón, lo que facilita una mayor rapidez a la hora de construir diálogos y ventanas para su aplicación, que serán transformados en código C++ para ser añadidos al proyecto. Como el editor de diálogos es parte de la interfaz de usuario de KDevelop, en él tiene las mismas opciones disponibles que cuando está programando. Esto permite, por ejemplo, construir un diálogo, generar su código, y probarlo desde el programa, gracias a la disponibilidad de las opciones de make. Además puede ver los mensajes del compilador sin necesidad de volver al modo de edición. Para obtener una descripción más detallada del editor vea el capítulo El editor de diálogos .

#### El asistente de aplicaciones y las herramientas de clases

El asistente de aplicaciones y las herramientas de clases incluidas para la creación del proyecto, y para la extensión automática del código, tienen la intención de hacer que la creación de aplicaciones sea lo más fácil y segura que sea posible, ofreciendo a aquellos con poca experiencia con Qt y KDE una buena manera de empezar a diseñar IGUs (interfaces gráficas de usuario), ya que se pueden conseguir resultados rápidamente.

#### El asistente de aplicaciones

La función del asistente de aplicaciones es ayudar a crear proyectos de aplicaciones que estén listas para ser ejecutadas, con la ayuda de las herramientas GNU estándar, además de ayudar a crear aplicaciones con interfaz de usuario, que hagan uso de las bibliotecas KDE y Qt. Mediante la introducción de una información mínima, el usuario puede empezar a trabajar en un nuevo proyecto en cuestión de segundos. Cuando vaya a crear una nueva aplicación con KDevelop lo primero que debe hacer es llamar al asistente de aplicaciones.

El asistente de aplicaciones creará el esqueleto de la nueva aplicación, con todos los ficheros fuente en C++ necesarios para ejecutar la aplicación. Después de que le de nombre al proyecto y configure los datos necesarios, se creará su nuevo proyecto y usted tendrá una aplicación completa, con diversas funciones (en el caso de proyectos Qt y KDE), sin que tenga que escribir ni una línea de código C++. Una vez configuradas todas las opciones posibles del asistente, su aplicación ya se creará con:

- una interfaz SDI (interfaz de un solo documento), basado en el modelo document-view-controller
- menús y diálogos para abrir y guardar ficheros, además de diálogos de impresión
- barras de herramientas y de estado, con completa funcionalidad
- un sistema de ayuda, con un manual de usuario creado en SGML y con ayuda en la barra de estado
- completa documentación de la API (interfaz de programación de la aplicación) del proyecto
- rutina de instalación a través de make

El asistente de aplicaciones está disponible desde el menú Proyecto, desde la entrada "Nuevo...".

#### Herramienta de clases

El termino "herramienta de clases" se refiere a un grupo de utilidades, disponibles para el desarrollador, que le permiten trabajar con los fuentes del proyecto de una forma orientada a objetos. Lo que se intenta es hacer que el programador se preocupe más por las clases que por los ficheros, de forma que se concentre en los objetos que contiene el proyecto. KDevelop ofrece para esta tarea un generador de clases y un navegador de clases, cada uno de los cuales ofrece una gran cantidad de opciones automatizadas.

#### Creando una nueva clase con el generador de clases

Tras crear un proyecto con el asistente de aplicaciones lo siguiente que debería hacer, como desarrollador, es añadir un conjunto de clases adecuadas para el diseño de su aplicación. La forma habitual de hacerlo, sin KDevelop, sería crear unos nuevos ficheros de cabecera y de implementación, añadirlos manualmente al fichero Makefile.am correspondiente, y empezar a escribir las declaraciones e implementaciones las clases. Para simplificar el proceso, el generador de clases le permite hacer todo esto, tan sólo diciendo el nombre de la nueva clase, la clase padre, la forma de herencia, y alguna información extra, como una pequeña descripción de lo que hace, para la documentación. Además, puede cambiar el nombre de los ficheros que se crearán, si no le gustan los que pone por defecto el generador, y también puede decidir si la clase estará preparada desde el principio para soportar el mecanismo de ranuras y señales (slot/signal) de Qt.

El resto del trabajo se realiza automáticamente. No tiene que preocuparse del fichero Makefile.am ni de ningún fichero extra. Lo único que hace falta para que la clase aparezca en el proceso de compilación es invocar al programa make. Como el navegador de clases se actualiza cada vez que se añade una clase, las declaraciones e implementaciones están disponibles inmediatamente, para que usted pueda empezar a trabajar en extender la clase. Se puede llamar al generador de clases desde el menú Proyecto, desde la entrada "Nueva clase..."

#### El navegador de clases

EL navegador de clases muestra todos los objetos y funciones de su proyecto en un árbol situado a la izquierda de la ventana de edición. Un analizador de clases busca todos los métodos y clases disponibles en los ficheros y los muestra mediante siímbolos gráficos. Desde ellos, los menús contextuales ofrecen funciones especificas, que permiten trabajar con los ficheros centrándose en las clases y funciones.

Al seleccionar una clase se mostrará el fichero que contiene su declaración; al seleccionar un método o función se mostrará su implementación. Para obtener una descripción más completa, vea el capítulo El navegador de clases.

### 4.3 El proceso de desarrollo

El desarrollo de una aplicación con KDevelop puede dividirse, como norma general, en dos partes: en la primera se genera el esqueleto del programa con el asistente de aplicaciones, la segunda consiste en el desarrollo del programa con el resto de herramientas que proporciona KDevelop y depende de la habilidad que tenga como programador. Para describir el proceso de desarrollo, hemos dado por hecho que usted desea crear una aplicación Qt o KDE, lo que significa utilizar la mayor parte de las posibilidades que KDevelop ofrece para este tipo de proyectos, para que tenga un "¿Cómo..." (o HOW-TO en inglés) general.

#### Creando el esqueleto del programa

Habitualmente, para empezar a crear su aplicación, lo primero que hará será llamar al asistente de aplicaciones, introducir el nombre del proyecto, y generar el programa. Para hacer esto, el asistente crea un fichero de proyecto para la aplicación e inserta aspectos del KDevelop en el fichero Makefile.am que se utilizará posteriormente al extender la aplicación. El fichero de proyecto es el que tiene que cargar cuando desee abrir el proyecto posteriormente.

Se accede al asistente de aplicaciones desde el menú "Proyecto", en la entrada "Nuevo...". Cuando el asistente aparezca, tiene que elegir el tipo de proyecto en la primera página. Pulsando "Siguiente >>" llegará a la siguiente página, en la que tiene que introducir el nombre del proyecto, la versión, el directorio, y sus datos personales. La página 3 ofrece algunas opciones para el uso de un sistema de control de versiones, mientras que las 4 y 5 permiten editar las cabeceras de los ficheros de cabecera y de implementación. Si ya tiene alguna cabecera en un fichero y desea utilizarla como plantilla, también puede hacerlo. La última página contiene las ventanas de salida y de errores. Cuando pulse en "Crear", su aplicación será generada, y las acciones que se realicen podrán ser observadas en la ventana de salida. Si en ella aparece la palabra READY, significa que el asistente de aplicaciones ha terminado y ya puede pulsar "Salir" para volver al entorno de programación. Para crear el binario, elija "Make" en el menú "Construir" o pulse el botón correspondiente en la barra de herramientas. Puede probar las funciones que ya están presentes en el programa eligiendo "Ejecutar" en el menú "Construir".

#### Desarrollando una aplicación

Esta sección describe la fase de desarrollo de una aplicación con KDevelop y el editor de diálogos, además de mostrar todo lo que se puede realizar con el EID.

El proceso de desarrollo se compone, habitualmente, de los siguientes pasos: se editan los ficheros fuente, se compilan y se enlazan para crear el binario final, se buscan los errores que hayan aparecido durante el proceso anterior o durante la depuración, se añade la documentación y las traducciones. El problema es que todos estos pasos pueden acabar intercalandose entre ellos y no es fácil describir una forma general con la que crear una aplicación. Normalmente, lo más habitual es crear primero todas las partes visibles del proyecto, tales como la vista principal y los diálogos de configuración. Después se genera el código fuente y se implementan todas las conexiones que deben realizarse, como cambiar las barras de menús y de herramientas, añadir mensajes de ayuda (para los menús) a la barra de estado, y llenar las nuevas funciones miembro con los objetos que muestren los diálogos. Después se suele compilar la apliación y probar sus funciones, arreglar los errores que se encuentren, y volver a probarla. Las siguientes secciones explican como se realiza todo esto. Por supuesto, cuando realice su propia aplicación, puede que elija otra forma de hacerla. KDevelop le da suficiente facilidad para que decida que es lo que quiere hacer en cada momento.

#### Interfaces de usuario

La interfaz de usuario es la parte de la aplicación que se le muestra al usuario, además de con la que interactúa. Por lo tanto, esta interfaz está compuesta habitualmente de las barras de menús, herramientas, y estado, además de una vista principal que sería, por ejemplo, aquella en la que se introduce texto, en un editor. El asistente de aplicaciones puede crear aplicaciones que ya contengan la mayor parte de la estructura de la interfaz de usuario, incluyendo menús y botones. Cuando desarrolle sus propias aplicaciones tendrá que ampliar la estructura, para darle a la aplicacion todas las posibilidades de interacción que usted desee. Parte del trabajo consiste en diseñar diálogos, por ejemplo para cambiar el tamaño de una brocha en un programa de dibujo. Esto puede realizarse fácilmente con el editor de diálogos incorporado. Ahora, ¿como crear diálogos que sean agradables a la vista? La respuesta está en la biblioteca Qt, que es en realidad una herramienta para crear interfaces de usuario (IGU). Para ello ofrece un conjunto base de controles, como etiquetas para mostrar texto, campos de texto para la entrada de texto, botones... Además de estos objetos de "bajo nivel" (respecto a la IGU), también ofrece diálogos estándar listos para usar, por ejemplo diálogos de impresión. Las bibliotecas KDE están basadas en la biblioteca Qt y contienen sustitutos para algunos de los diálogos, además de controles adicionales que pueden ser utilizados en su aplicación. Todo esto significa que, cuando empiece a diseñar el comportamiento de su aplicación de cara al usuario, debería familiarizarse con los controles que tanto Qt como KDE ofrecen. La documentación en línea de la biblioteca Qt ofrece imágenes de la mayoría de ellos, por lo que le recomendamos que le eche un vistazo en cuanto pueda. Después, le recomendamos que se informe sobre la biblioteca KDE-UI, que ofrece controles adicionales. Otras bibliotecas como la KHTML ofrecen controles muy especializados, que son usados por muchos programas. Su función es simplificar el diseño de aplicaciones, al igual que los diálogos predefinidos que vienen con la biblioteca Qt. Cuando diseñe sus propios diálogos, le recomendamos que utilice estos controles especializados. Un diálogo está formado, básicamente, por un grupo de controles combinados para crear la interfaz, siendo programado en código C++ dentro de una clase que deriva de `QWidget` o de una clase de diálogo más especializada, que a su vez es derivada de `QWidget`. Esto significa que el programa que utilice el control necesita un objeto de la clase de dicho objeto. Con esto se acaba prácticamente todo lo que necesita para entender como se utilizan los diálogos o vistas. El editor de diálogos de KDevelop permite construir diálogos e interfaces de usuario de forma visual, evitando que tenga que crear los diálogos en C++ directamente (que es la forma difícil de crear interfaces). Salte al editor de diálogos eligiendo la entrada correspondiente del menú "Ver" (o pulsando en el botón de la barra de herramientas). Verá que la apariencia del KDevelop ha variado pero que, por ejemplo, las barras de menús y herramientas son muy similares. Esto facilita el cambio entre los dos modos de trabajo, y hará que se sienta comfortable en los dos en poco tiempo. Desde el editor puede construir sus vistas y diálogos como desee, y modificar las propiedades de todos los elementos que utilice. Cuando termine, seleccione "Generar fuentes..." desde el menú "Construir"; el programa se encargará del resto. Puede comprobar si todo fue bien pulsando en "Ejecutar make" o "Ejecutar", para construir la aplicación con los nuevos ficheros fuente. Pero no espere que los diálogos estén disponibles desde el principio. Se requiere algo de programación primero, pero no se preocupe, no será muy difícil. Si desea más información sobre la creación de diálogos, vea el capítulo El editor de diálogos, también podrá encontrar ejemplos y guías de estilo en el manual de programación.

#### Incluir nuevos elementos

Tras haber creado la interfaz de usuario y haber generado sus ficheros fuente, está preparado para que su aplicación utilice estos nuevos elementos. Como se ha descrito arriba, una aplicación basada en IGU contiene barras y una vista principal; además la vista principal interacciona con las barras, que son parte de la clase principal de la aplicación, y con el objeto documento que esté abierto. Usando el lenguaje del diseño orientado a objetos, la arquitectura usada se podría definir como un modelo "Documento-Vista-Controlador". Este modelo describe las funciones básicas de los objetos de una aplicación dependiendo de su papel dentro del programa. El Controlador representa al coordinador de la aplicación principal, ofreciendo la interacción con el usuario a través de la barra de menús y, opcionalmente, de las barras de herramientas y de estado. La clase Documento se encarga de la tarea de mostrar el documento con el que el usuario está trabajando. Esto implica que la clase Documento debe ser la encargada de realizar las acciones del tipo cargar/guardar documentos. La Vista es el centro de la ventana de la aplicación, mostrando visualmente al usuario una parte del documento y ofreciéndole facilidades para manipular los datos. Como las barras de herramientas, menús y estado ya están creadas, su trabajo consistirá en crear la vista principal y los diálogos adicionales con los que el usuario pueda configurar cualquier opción, o acceder a funciones adicionales.

Para construir su vista principal, el código generado para su aplicación ya contiene una clase llamada <SuAplicación>View, que hereda de la clase `QWidget` (esta clase es la clase mínima necesaria para manejar interfaces gráficas en aplicaciones Qt, y por tanto también en aplicaciones KDE). En general, hay tres formas de ampliar la clase dada:

- eliminando la estructura de vista de documentos y utilizando uno de los controles "grandes" incluidos, que ya contienen una gran número de funciones. Tan sólo tiene que eliminar la clase View y reemplazar el objeto view por otro.
- cambiando la herencia de la clase View. Cambie la herencia, por ejemplo, a la clase QMultiLineEdit y su aplicación será un editor.
- si su vista principal consiste de distintas partes, cree los controles y sus clases con el editor de diálogos, y cree los objetos de estas clases en los constructores de la clase View, al combinarse crearán la vista principal.

Con los diálogos, el proceso es algo diferente. La forma normal de llamar a un diálogo sería a través de una entrada de menú, o de un icono de la barra de herramientas. Tras haber construido el diálogo y haber generado los fuentes, la clase está disponible para crear un objeto que será el diálogo. Lo primero que hay que hacer es buscar un lugar apropiado en el menú en que añadir la entrada que, al ser seleccionada, mostrará el diálogo. Si los menús existentes no se corresponden con la función del diálogo, cree un nuevo menú, igual que el resto, y añada la entrada y la ranura a la que llamar cuando se seleccione el elemento. Entonces implemente la ranura, creando una instancia de la clase diálogo y llamando al diálogo con las funciones miembro proporcionadas por la clase base. También debe proporcionar un identificador a la entrada de menú. La aplicación princpial tiene listados todos los identificadores ya utilizados en el fichero resource.h, por lo que lo único que tiene que hacer es añadir el identificador y darle un nuevo número. Con esto ya se ha acabado, aunque también podría añadir otro icono a la barra de herramientas, y añadir un mensaje de ayuda para la barra de estado. En cualquier caso, su aplicación ofrece ahora una nueva opción al usuario. Lo único que hay que hacer ahora es añadir la implementación de los metodos que utilizará el diálogo. Para acabar, llame a la herramienta make, o ejecute la aplicación, y los ficheros modificados serán recompilados; el resultado de los cambios podra ser entonces comprobado rápidamente.

#### El proceso completo de desarrollo

Arriba se ha hablado de la manera habitual de comenzar a trabajar en una nueva aplicación, usando KDevelop, y de como ampliar la interfaz de usuario. Estos son los pasos más habituales en los que el EID le ayuda, pero KDevelop no sólo ofrece herramientas para crear aplicaciones e interfaces. A continuación, se dará una pequeña descripción de las principales facilidades que KDevelop ofrece para mejorar el desarrollo de aplicaciones.

#### Administración del código

KDevelop ofrece una gran cantidad de opciones para que el programador alcance su meta en el menor tiempo posible. Como se ha descrito arriba, el asistente de aplicaciones y el editor de diálogos reducen la cantidad de tiempo que se necesitaría para conseguir el mismo resultado manualmente. Pero no se ha hablado de la principal tarea del programador: implementar el correcto funcionamiento de la aplicación. La pregunta es, ¿por qué utilizar KDevelop como entorno de desarrollo, incluso para crear aplicaciones sin IGU?

Implicitamente, el EID se encarga de controlar su proyecto; esto es: no tiene que preocuparse de guardar los cambios, de generar el fichero Makefile, etc. Se está proporcionando una completa administración del proyecto, siendo aquídonde KDevelop ofrece todas sus posibilidades, en cualquier tipo de desarrollo en C++. Es fácil entender que, al hacer que el programador se olvide de la administración del proyecto, se consigue una mayor concentración en la programación del código. Por otro lado, el código suele estar distribuido en diversos ficheros a lo largo del proyecto, para separar ciertas partes. Normalmente, esto significaría que el desarrollador tendría que encargarse de crear cada uno de estos ficheros, y de insertar las líneas que todos ellos suelen llevar como norma general, como las cabeceras con la fecha y el nombre del autor, la licencia con que se distribuye el código, etc. Además, esto implicaría que el desarrollador se acordara, en todo momento, de en que ficheros se encuentra cada función, declaración e implementación de cada clase. Para evitar todo esto, KDevelop contiene la herramienta de clases, que proporciona una serie de acciones que facilitan el trabajo del desarrollador y permiten que se centre en los objetos, clases, estructuras y métodos que contiene la aplicación, en lugar de en sus ficheros. El generador de clases le permite crear una nueva clase, pudiendo especificar su documentación, sus atributos y si posee algún tipo de herencia. En lo que al trabajo orientado a objetos se refiere, el navegador de clases le posibilita localizar sus objetos; no importa en que parte del código estén. El navegador recorre todos los fuentes y se actualiza para mostrar información actualizada sobre los objetos, permitiéndole acceder a cualquier nuevo código directamente. Mediante los menús contextuales, el navegador le ofrece aún más posibilidades, como mostrar la implementación de la clase o la declaración de sus funciones miembro. Con esto, la adición de miembros se hace mediante diálogos, no hace falta buscar el fichero y la línea en la que se ha de introducir el código. Por último, puede obtener una visión más directa de las clases de su proyecto con la ayuda del diálogo de clases, que le muestra un árbol en el que se puede ver el uso, los contenidos y la herencia de las clases y sus objetos. Para obtener una información más detallada, vea el apartado sobre el navegador de clases.

#### Construyendo y ejecutando su aplicación

KDevelop está diseñado para eliminar todos esos pasos que se deben realizar periódicamente, tales como la construcción y ejecución de su programa, además de la localización de errores en el código fuente.

Puede comenzar el proceso de construcción:

- pulsando en los botones "Construir" o "Reconstruir todo" de la barra de herramientas
- o seleccionando "Construir"/"Reconstruir todo" desde el menú Construir.

Para ejecutar su aplicación, elija:

- los botones "Ejecutar" o "Depurar" (que abrirá el depurador junto a su programa) de la barra de herramientas
- las entradas de menú correspondientes del menú Construir
- o seleccione "Ejecutar con argumentos" para lanzar su aplicación pasándole argumentos adicionales.

Para obtener más información sobre el proceso de construcción, vea el apartado Proyectos.

#### Buscando errores en el programa

Como la aparición de errores es habitual, tanto durante el proceso de construcción (en el que son detectados por el compilador y en el que son llamados errores sintácticos, porque son resultado de errores de sintaxis en los fuentes) como durante la ejecución de la aplicación, estos errores tienen que ser detectados y eliminados por el programador. Para encontrar estos errores, el desarrollador necesita saber la razón exacta de su existencia. Como se ha mencionado, el compilador es capaz de detectar errores de sintaxis el solo, dando como resultado que el ejecutable no se cree (esto también puede pasar en enlazado, cuando el enlazador detecta "símbolos sin resolver"-vea Opciones de enlazado). Como se da una descripción del error lo más detallada posible, el error puede ser encontrado y eliminado. Durante el proceso de construcción, verá que aparece la ventana de salida mostrando los mensajes de la herramienta make y del compilador. En caso de que aparezcan errores o avisos, tan sólo pulse con el ratón sobre el mensaje de error y el editor mostrará el fichero afectado y moverá el cursor a la línea que contiene el error. Esto también puede ser realizarse desde las entradas del menú "Ver" "Siguiente error" y "Anterior error" o mediante sus atajos de teclado. Encontrará que estas funciones son muy útilas y ahorran mucho tiempo en ir a los errores, lo cual le dará más tiempo para solucionarlos.

Los errores en tiempo de ejecución, que ocurren durante la ejecución de la aplicación y suelen resultar en un dallo de segmentación, suelen ser más difíciles de encontrar. Para encontrarlos más fácilmente, puede decirle al compilador que añada información dentro del binario que permita observar su ejecución con el código fuente. Runtime Errors, which occur during execution and will mostly result in a segmentation fault, are sometimes hard to find. Un depurador es otro programa que le permite hacer esto, lanzando la aplicación y permitiéndole poner puntos de interrupción en el código para que la ejecución del mismo se detenga en ellos, de forma que pueda controlar las zonas críticas de la implementación y encontrar al menos de esta forma la línea que provocó el error. Encontrar la causa del error es una tarea que ya depende del programador. El depurador gdb viene con el compilador GNU y los programas del tipo ddd o KDbg son interfaces de usuario para facilitar su uso. KDevelop utiliza el KDbg y le permite comenzar el proceso de depurado desde la entrada "Inicio" del menú "Depurar" o desde el botón "Depurar" de la barra de herramientas. Para obtener más información sobre aplicaciones de depurado, vea el capítulo Proyectos y el manual de programación de KDevelop.

### 4.4 Información adicional

Los temas de los que se ha hablado en este capítulo son tratados con más detalle dentro de la documentación incluida con KDevelop, además de en otras documentaciones:

- El manual de programación de KDevelop, que incluye una completa introducción al diseño de la interfaz de usuario de aplicaciones, y a la programación con las bibliotecas Qt y KDE,
- este manual, en las secciones desde Descripción general hasta Proyectos, donde se descubren todas las funciones disponibles con KDevelop,
- este manual, en la sección El editor de diálogos, donde se trata el uso del editor de diálogos para la creación de sus propios controles,
- la guía de referencia en línea de la biblioteca Qt, que contiene ejemplos de uso de la biblioteca Qt para crear interfaces de usuario, además de una guía de referencia de las clases, y de capturas de pantalla mostrando los controles más importantes incluidos en la biblioteca,
- la guía de referencia de las clases de KDE, generada automáticamente por KDevelop desde los fuentes de la biblioteca KDE, que contiene descripciones de todas las clases y controles, además de código de ejemplo mostrando su uso,
- en Internet, vea:
  - http://www.troll.no para encontrar información sobre los controles Qt y sobre controles adicionales de otros desarrolladores,
  - http://www.kde.org para obtener información sobre el proyecto KDE y sobre las guías de estilo para el desarrollo,
  - http://developer.kde.org para ver referencias adicionales sobre el desarrollo de aplicaciones KDE,
  - y la página web de KDevelop http://www.kdevelop.org

Página siguiente Página anterior Índice general