De Wikilibros, la colección de libros de texto de contenido libre.

< Introducción a Patrones de Diseño en C++ con Qt4

Saltar a navegación, buscar

Esta es la versión para imprimir de Introducción a Patrones de Diseño en C++ con Qt4.

Si imprimes esta página, o eliges la opción de Vista preliminar de impresión de tu navegador, verás que desaparecen este cuadro y los elementos de navegación de arriba y de la izquierda, pues no son útiles en una versión impresa.
Pulsando antes en Refrescar esta página te asegurarás de obtener los últimos cambios del libro antes de imprimirlo.
Para más información, puedes ver Wikilibros:Versión para imprimir.

Desarrollo

Versión para imprimir esta pagina

Contenido

1 Introducción a Patrones de Diseño en C++ con Qt4
- 1.1 Declaración
- 1.2 Tabla de Contenido
- 1.3 Apéndice
- 1.4 Lista de Figuras
- 1.5 Lista de Tablas
- 1.6 Lista de Ejemplos
2 Prefacio
- 2.1 Como usar este libro
- 2.2 Una nota sobre los formatos
3 Agradecimientos
4 Justificación para este libro
5 1.1. Un vistazo a C++
6 Una breve historia de C++
7 Instalando C++/Qt: Plataformas Open Source
- 7.1 Descargando desde las fuentes
  - 7.1.1 Ejemplo 1.1
- 7.2 Variables de Entorno
  - 7.2.1 Ejemplo 1.2
8 Instalando C++/Qt: Win32
9 C++ Primer Ejemplo
- 9.1 Ejemplo 1.3
- 9.2 Comentarios
- 9.3 #include
- 9.4 Usando namespace
- 9.5 Declarando e Inicializando Variables
- 9.6 Selección
- 9.7 Interacción
10 Entrada y Salida
- 10.1 Ejemplo 1.4
11 Ejercicios: Entrada y Salida
- 11.1 Ejemplo 1.5
12 Diálogos Qt para entrada/salida de usuario
- 12.1 Ejemplo 1.6
13 Ejercicios: Diálogos Qt para Entrada/Salida
14 Makefile, qmake, y Archivos de Proyecto
- 14.1 Figura 1.3
15 #include: Encontrando Archivos de Cabecera
16 El comando make
- 16.1 Ejemplo 1.8
- 16.2 Limpiando Archivos
17 Obteniendo ayuda en línea
18 Cadenas
- 18.1 Ejemplo 1.9
- 18.2 Ejemplo 1.10
19 Flujos
- 19.1 Ejemplo 1.11
- 19.2 Ejemplo 1.12
- 19.3 Ejemplo 1.13
- 19.4 Ejemplo 1.14
20 Ejercicios: Flujos
21 Identificadores, Tipos y Literales
- 21.1 Tabla 1.1
- 21.2 Ejemplo 1.15
22 Ejercicios: Identificadores, Tipos y Literales
23 Tipos Simples de C++
- 23.1 Tabla 1.2
- 23.2 Ejemplo 1.16
24 main y Argumentos de Línea de Comandos
- 24.1 Ejemplo 1.17
25 Aritmética
- 25.1 Ejemplo 1.18
- 25.2 Ejemplo 1.19
- 25.3 Ejemplo 1.20
- 25.4 Ejemplo 1.21
- 25.5 Ejemplo 1.22
26 Ejercicios: Tipos Simples de C++
27 1.15 La Palabra Clave const
28 1.16. Punteros y acceso de memoria
29 1.16.1. Los operadores unarios & y *
- 29.1 Ejemplo 1.23
- 29.2 Figura 1.4
30 1.16.2. Operadores new y delete
- 30.1 Ejemplo 1.24
31 Exercicios: Punteros y acceso de Memoria
- 31.1 Ejemplo 1.25

[editar] Introducción a Patrones de Diseño en C++ con Qt4

Alan Ezust, Paul Ezust, Traducción: Paynalton

Este documento está siempre bajo desarrollo. La Distribución de este trabajo o derivado de este trabajo es permitido bajo los términos de OPL tan pronto como la propia atribución sea realizada.

Así mismo un razonable esfuerzo se ha realizado para incorporar información útil dentro de este libro, se proporciona "como es", sin ninguna garantía explícita ó expresa. Si encuentras un error, ó deseas hacer una sugerencia/contribución, por favor abre un hilo en nuestra base de datos Bugzilla.

[editar] Declaración

C++ es la enseñanza de “El Camino de Qt”, con una énfasis en patrones de diseño y el reuso de librerías y herramientas de código abierto. Al finalizar este libro, el lector debería contar con un profundo entendimiento tanto del lenguaje como de las librerías, así mismo el patrón de diseños usados al desarrollar sofware con ellos.

[editar] Tabla de Contenido

[editar] Apéndice

[editar] Lista de Figuras

[editar] Lista de Tablas

[editar] Lista de Ejemplos

1.1 ../bin/qtconfigure
1.2 src/libs/utils/qt.sh
1.3. src/early-examples/fac.cpp
1.4 src/iostream/io.cpp
1.5. src/early-examples/fac2.cpp
1.6 src/early-examples/example1/fac1.cpp
1.7 src/early-examples/example1/example1.pro
1.8 src/qapp/Makefile-abbreviated
1.9 src/generic/stlstringdemo.cpp
1.10 src/early-examples/qstring/qstringdemo.cpp
1.11 src/stdstreams/streamdemo.cpp
1.12 src/stl/streams/streams.cpp
1.13 src/stl/streams/streams.cpp
1.14 src/stl/streams/streams.cpp
1.15 src/early-examples/literals/qliterals.cpp
1.16 src/early-examples/size/qsize.cpp
1.17 src/main/clargs/clargs.cpp
1.18 src/arithmetic/arithmetic.cpp
1.19 src/arithmetic/arithmetic.cpp
1.20 src/arithmetic/arithmetic.cpp
1.21 src/arithmetic/arithmetic.cpp
1.22 src/arithmetic/arithmetic.cpp
1.23 src/pointers/pointerdemo.cpp
1.24 src/pointers/newdelete/ndsyntax.cpp
1.25 src/pointers/newdelete1.cpp
1.26 src/constptr/constptr.cpp
1.27 src/types/types.cpp
2.1 src/structdemo/demostruct.h
2.2 src/structdemo/demostruct.cpp
2.3 src/classes/fraction.h
2.4 src/classes/fraction.cpp
2.5 src/classes/fraction.h
2.6 src/classes/fraction-client.cpp
2.7 src/ctor/complex.h
2.8 src/ctor/complex.cpp
2.9 src/statics/static.h
2.10 src/statics/static.cpp
2.11. src/statics/static-test.cpp
2.12. src/lifecycle/copyassign/fraction.h
2.13. src/lifecycle/copyassign/fraction.cpp
2.14. src/lifecycle/copyassign/copyassign.cpp
2.15. src/ctor/conversion/fraction.cpp
2.16. src/const/constmembers.cpp
2.17. src/subobject/subobject.h
2.18. src/subobject/subobject.cpp
2.19. src/early-examples/thing.h
2.20. src/early-examples/thing.cpp
2.21. src/early-examples/thing-demo.cpp
2.22. src/statics/static3.h
2.23. src/statics/static3.cpp
2.24. src/destructor/demo/thing.h
2.25. src/destructor/demo/destructor-demo.cpp
3.1. src/libs/utils/qstd.h
3.2. src/libs/utils/qstd.cpp
3.3. src/qtio/qtio-demo.cpp
4.1. src/containers/lists/lists-examples.cpp
4.2. src/containers/contact/testdriver.cpp
5.1. src/functions/function-call.cpp
5.2. src/functions/function-call.cpp
5.3. src/functions/date.h
5.4. src/functions/date.cpp
5.5. src/functions/date-test.cpp
5.6. src/complex/complex.h
5.7. src/complex/complex.cpp
5.8. src/complex/complex.cpp
5.9. src/complex/complex-test.cpp
5.10. src/complex/complex-conversions.cpp
5.11. src/functions/summit.cpp
5.12. src/functions/pointerparam.cpp
5.13. src/reference/swap.cpp
5.14. src/const/reference/constref.cpp
5.15. src/reference/maxi.cpp
5.16. src/const/overload/constoverload.h
5.17. src/const/overload/constoverload-client.cpp
5.18. src/functions/inlinetst.cpp
5.19. src/ellipsis/ellipsis.cpp
5.20. src/functions/cryptoclass/crypto-client.cpp
6.1. src/derivation/qmono/student.h
6.2. src/derivation/qmono/student.cpp
6.3. src/derivation/qmono/student.cpp
6.4. src/derivation/qmono/student.cpp
6.5. src/derivation/qmono/student-test.cpp
6.6. src/derivation/qpoly/student.h
6.7. src/derivation/qpoly/student-test.cpp
6.8. src/polymorphic1.cc
6.9. src/polymorphic2.cc
6.10. src/derivation/exercise/Base.h
6.11. src/derivation/exercise/Base.cpp
6.12. src/derivation/exercise/main.cpp
6.13. src/derivation/shape1/shapes.h
6.14. src/derivation/shape1/shapes.h
6.15. src/derivation/shape1/shapes.cpp
6.16. src/derivation/shape1/shape1.cpp
6.17. src/derivation/shape1/shape.txt
6.18. src/derivation/overload/account.h
6.19. src/derivation/overload/account-client.cpp
6.20. src/derivation/assigcopy/account.h
6.21. src/derivation/assigcopy/account.h
6.22. src/derivation/assigcopy/account.cpp
6.23. src/reuse/argproc.cpp
6.24. src/libs/utils/argumentlist.h
6.25. src/libs/utils/argumentlist.cpp
6.26. src/reuse/main.cpp
6.27. src/reuse/reuse.pro
7.1. src/qapp-gui/qapp-gui.pro
7.2. src/bash/env-script.sh
8.1. src/visitorsrc/recurseadddir.cpp
8.2. src/libs/utils/filevisitor.h
8.3. src/libs/utils/filevisitor.cpp
8.4. src/visitor/codevisitor/codevisitor.h
8.5. src/visitor/codevisitor/codevisitor.cpp
8.6. src/visitor/codevisitor/codevisitor-test.cpp
9.1. src/qobject/person.h
9.2. src/qobject/person.cpp
9.3. src/qobject/bunch.cpp
9.4. src/findchildren/findchildren.cpp
9.5. src/eventloop/eventloop.cpp
9.6. src/eventloop/eventloop.cpp
9.7. src/eventloop/messager.h
9.8. src/eventloop/messager.cpp
9.9. src/widgets/sliderlcd/sliderlcd.h
9.10. src/widgets/sliderlcd/sliderlcd.cpp
9.11. src/widgets/sliderlcd/sliderlcd.cpp
9.12. src/widgets/sliderlcd/sliderlcd-demo.cpp
10.1. src/templates/template-demo.cpp
10.2. src/templates/template-demo.cpp
10.3. src/containers/stack/stack.h
10.4. src/containers/stack/stack.h
10.5. src/containers/stack/main.cpp
10.6. src/cardgame/datastructure/cardgame-client.cpp
10.7. src/containers/sortlist/sortlist4.cpp
10.8. src/containers/sortlist/sortlist-output.txt
10.9. src/containers/contact/serializer.cpp
10.10. src/containers/qmap/textbook.h
10.11. src/containers/qmap/qmap-example.cpp
10.12. src/containers/qmap/qmap-example.cpp
10.13. src/containers/qmap/qmap-example-output.txt
11.1. src/widgets/mainwindow/mymainwindow.h
11.2. src/widgets/mainwindow/mymainwindow.cpp
11.3. src/widgets/mainwindow/mainwindow-main.cpp
11.4. src/widgets/dialogs/messagebox/dialogs.h
11.5. src/widgets/dialogs/messagebox/dialogs.cpp
11.6. src/widgets/dialogs/inputdialog/inputdialog.cpp
11.7. src/libs/cards2/cards2.pro
11.8. src/libs/cards2/cardpics.h
11.9. src/libs/cards2/cardpics.cpp
11.10. src/layouts/boxes/cardtable.h
11.11. src/layouts/boxes/cardtable.cpp
11.12. src/layouts/boxes/boxes.cpp
11.13. src/layouts/stretch/cardtable.cpp
11.14. src/layouts/moving/moving.h
11.15. src/layouts/moving/moving.cpp
11.16. src/layouts/moving/moving.cpp
11.17. src/layouts/moving/moving.cpp
11.18. src/widgets/dialogs/messagebox/dialogs.cpp
11.19. src/widgets/menus/study.h
11.20. src/widgets/menus/study.cpp
11.21. src/widgets/menus/study.cpp
11.22. src/widgets/menus/study.cpp
11.23. src/widgets/menus/study.cpp
11.24. src/modelview/qstringlistmodel/simplelistapp.h
11.25. src/modelview/qstringlistmodel/simplelistapp.cpp
12.1. src/logtail/logtail.h
12.2. src/logtail/logtail.cpp
12.3. src/logtail/logtail.cpp
12.4. src/logtail/logtail.cpp
12.5. src/environment/setenv.cpp
12.6. src/qonsole/qonsole1/qonsole.cpp
12.7. src/qonsole/qonsole1/qonsole.cpp
12.8. src/qonsole/qonsole1/qonsole.cpp
12.9. src/qonsole/keyevents/qonsole.h
12.10. src/qonsole/keyevents/qonsole.cpp
12.11. src/qonsole/keyevents/qonsole.cpp
12.12. src/threads/animate/moviethreadmain.cpp
12.13. src/threads/animate/moviethread.cpp
12.14. src/threads/animate/movieview.cpp
12.15. src/threads/animate/movieview.cpp
12.16. src/threads/animate/moviethread.cpp
12.17. src/threads/animate/moviethread.cpp
12.18. src/threads/animate/movietimer.h
12.19. src/threads/animate/movietimermain.cpp
12.20. src/threads/animate/movietimer.cpp
12.21. src/threads/giant/giant.h
12.22. src/threads/giant/giant.cpp
12.23. src/threads/giant/giant.cpp
12.24. src/threads/giant/giantwindow.h
12.25. src/threads/giant/giantwindow.cpp
13.1. src/validate/inputform.h
13.2. src/validate/inputform.cpp
13.3. src/regexp/testphone.txt
13.4. src/regexp/testphoneread.cpp
13.5. src/validate/regexval/rinputform.h
13.6. src/validate/regexval/rinputform.cpp
14.1. src/xml/html/testhtml.html
14.2. src/xml/html/testxhtml.html
14.3. src/xml/sax1/samplefile.xml
14.4. src/xml/sax1/tagreader.cpp
14.5. src/xml/sax1/myhandler.h
14.6. src/xml/sax1/myhandler.cpp
14.7. src/xml/sax1/tagreader-output.txt
14.8. src/xml/domwalker/main.cpp
14.9. src/xml/domwalker/domwalker.cpp
14.10. src/xml/domwalker/slacker.cpp
14.11. src/libs/docbook/docbookdoc.h
14.12. src/xml/xmlbuilder/zenflesh.cpp
14.13. src/xml/zen.xml
14.14. src/xml/zen2html
14.15. src/libs/docbook/docbookdoc.cpp
14.16. src/libs/docbook/docbookdoc.cpp
15.1. src/qtrtti/myapp-classdef.cpp
15.2. src/qtrtti/qtrtti.cpp
15.3. src/properties/customer-props.h
15.4. src/properties/customer-props.cpp
15.5. src/properties/testcustomerprops.cpp
15.6. src/properties/testcustomerprops.cpp
15.7. src/libs/dataobjects/dataobject.cpp
16.1. src/libs/dataobjects/abstractfactory.h
16.2. src/libs/dataobjects/objectfactory.h
16.3. src/libs/dataobjects/objectfactory.cpp
16.4. src/libs/customer/customerfactory.h
16.5. src/libs/customer/customerfactory.cpp
16.6. src/libs/customer/customerfactory.cpp
16.7. src/libs/dataobjects/objectfactory.h
16.8. src/libs/dataobjects/objectfactory.cpp
16.9. src/libs/customer/customer.h
16.10. src/libs/dataobjects/address.h
16.11. src/libs/dataobjects/address.h
16.12. src/ctorpoly/ctorpoly.cpp
16.13. src/ctorpoly/ctorpoly-output.txt
16.14. src/xml/propchildren/customer.h
16.15. src/xml/propchildren/customerlist.h
16.16. src/xml/propchildren/customerlist.xml
16.17. src/xml/propchildren/xmlexport.h
16.18. src/xml/propchildren/xmlexport.cpp
16.19. src/libs/dataobjects/dataobjectreader.h
16.20. src/libs/dataobjects/dataobjectreader.cpp
16.21. src/libs/dataobjects/dataobjectreader.cpp
16.22. src/libs/dataobjects/objectfactory.cpp
16.23. src/facade/id3lib-usage.cpp
16.24. auto_ptr code fragment
16.25. src/libs/filetagger/filetagger.h
16.26. src/libs/filetagger/filetagger.cpp
16.27. src/libs/filetagger/filetagger.cpp
17.1. src/libs/dataobjects/dataobjecttablemodel.h
17.2. src/modelview/tablemodel/tablemodel.cpp
17.3. src/libs/dataobjects/dataobjecttablemodel.cpp
17.4. src/libs/dataobjects/dataobjecttablemodel.h
17.5. src/libs/dataobjects/dataobjecttablemodel.cpp
17.6. src/libs/dataobjects/dataobjecttablemodel.cpp
17.7. src/libs/dataobjects/dataobjecttablemodel.cpp
17.8. src/modelview/objectbrowser/ObjectBrowserModel.h
17.9. src/modelview/qjots/item.h
17.10. src/modelview/qjots/item.cpp
17.11. src/forms/bridgekeeper-designer/bridgekeeper.h
18.1. src/enums/enumtst.cpp
18.2. src/mixed-types.cpp
18.3. src/ansicast/m2k.cpp
18.4. src/casts/constcast1.cpp
18.5. src/casts/constcast2.cpp
18.6. src/rtti/dynamic_cast.cpp
18.7. src/pointers/autoptr/qpointer.h
18.8. src/const/cast/const.cc
18.9. src/const/cast/const2.cc
19.1. src/early-examples/decldef/point.h
19.2. src/early-examples/decldef/point.cpp
19.3. Global vs File scope
19.4. src/goto/goto.cpp
19.5. src/early-examples/scopex.cpp
19.6. src/storage/storage.cpp
19.7. src/namespace/a.h
19.8. src/namespace/b.h
19.9. src/namespace/namespace1.cc
19.10. src/namespace/namespace2.cc
19.11. src/namespace/anonymouse.h
19.12. src/libs/utils/qstd.h
19.13. src/libs/utils/qstd.cpp
20.1. src/early-examples/nestedif.cpp
20.2. src/exceptions/example/exceptions.h
20.3. src/exceptions/example/vector.h
20.4. src/exceptions/example/vector.h
20.5. src/exceptions/catch.cpp
20.6. src/exceptions/example/exceptions.cpp
20.7. src/exceptions/throw0/throw0.cpp
20.8. src/exceptions/throw2/throw2.cpp
20.9. src/exceptions/registrar/registrar.h
20.10. src/exceptions/registrar/exceptions.h
20.11. src/exceptions/registrar/registrar.cpp
20.12. src/exceptions/registrar/registrarClientCode.cpp
21.1. src/pointers/pathology/pathologydecls1.cpp
21.2. src/pointers/pathology/pathologydecls2.cpp
21.3. src/pointers/pathology/pathologydemo1.cpp
21.4. src/arrays/pointerArith.cpp
21.5. src/arrays/returningpointers.cpp
21.6. src/arrays/pointerIndex.cpp
21.7. src/newfailure/bad-alloc1.cpp
21.8. src/newfailure/setnewhandler.cpp
21.9. src/newfailure/bad-alloc2.cpp
21.10 src/newfailure/nullchecking.cpp
22.1 src/derivation/typeid/vtable.h
22.2 src/derivation/typeid/vtable.cpp
22.3 src/derivation/assigcopy/bank.h
22.4 src/derivation/assigcopy/bank.cpp
22.5 src/derivation/assigcopy/bank.cpp
22.6 src/multinheritance/window.h
22.7 src/multinheritance/window.cpp
22.8 src/multinheritance/people.h
22.9 src/privatederiv/stack.h
22.10 src/privatederiv/stack-test.cpp
C.1 src/preprocessor/constraintmap.h
C.2 src/preprocessor/constraintmap.cpp
C.3 linker-invocation.txt
C.4 src/debugging/wrongdelete.cpp
C.5 src/debugging/valgrind-test.cpp

Introducción a Patrones de Diseño en C++ con Qt4

<<- Anterior (Contenido) | (Agradecimientos) Siguiente->>

Versión para imprimir esta pagina

[editar] Prefacio

C++ ha fue usado muchos años antes de ser estandarizado en 1989, lo cual lo convierte en un lenguaje relativamente maduro comparado con otros que son populares hoy en día. Es un lenguaje muy importante para construir sistemas rápidos, eficiente, misiones críticas. C++ es también uno de los más flexibles lenguajes de los alrededores, dando a los desarrolladores muchas elecciones de estilos de programación para usar en códigos GUI de alto nivel así como en controladores de dispositivo de bajo nivel.

Por algunos años en la década de los 90, C++ fue el más popular lenguaje orientado a objetos (OO) en uso, y muchos estudiantes de ciencias de la computación(CS) fueron introducidos a la Programación Orientada a Objetos(OOP) por medio de C++. Esto es debido a que C++ proporcionó una relativamente fácil transición a OOP para los programadores de C, y muchos profesores de CS habían sido adiestrados previamente en C.

Comenzando alrededor de 1996, Java ganó favor por encima de C++ como el lenguaje OO principal para la enseñanza de los estudiantes. Hay un buen número de razones por las que Java ha ganado esa popularidad:

El Lenguaje en sí mismo es más simple que C++.
El lenguaje tiene un recolector de basura incorporado, por ello los programadores no necesitan preocuparse por sí mismos de la reasignación de memoria.
Un juego estándar de clases GUI es incluida en el kit de desarrollo.
La clase String incorporada soporta Unicode.
Multithreading está incorporada dentro del lenguaje.
Es mas sencillo construir y "conectar" archivos Java (JARs) de lo que es recompilar y reenlazar librerías.
Muchos servidores web proporcionan APIs de Java para una sencilla integración.
Los programas Java son independientes de la plataforma (Wintel, Solaris, MacOS, Linux, *nix, etc.).

Muchos de los beneficios de Java listados arriba pueden ser logrados con C++ usado en conjunción con Qt 4:

Qt proporciona un comprensible juego de clases GUI que corren más rápido, se ven mejor y son mucho más flexibles que las clases Swing de Java.
Señales y slots son mucho más fáciles de usar que las interfaces (Action|Event|Key)Listener en Java.
Qt 4 tiene una arquitectura de conexiones que haga posible cargar código dentro de una aplicación sin recompilar o reenlazar.
Qt 4 proporciona foreach, que hace la interacción a través de colecciones simple de leer y escribir.

Aunque Qt no proporciona una colección de recolectores, hay una varidedad de alternativas que se pueden utilizar para evitar la necesidad de borrar cada objeto directamente:

Contenedores (Ver Sección 10.2)
Padres e Hijos (Ver Sección 9.2)
auto_ptr (Ver Sección 16.3.2)
QPointer (Ver Sección 18.9).
Subobjetos (Ver Sección 2.13)
Objetos apilados (Ver Sección 19.3)

Usando C++ con Qt se vuelve algo muy parecido a Java en facilidad de uso, comprensibilidad y conveniencia. Esto sobrepasa significativamente a Java en las áreas de velocidad y eficiencia, haciendo posible desde aplicaciones de servidor de procesamiento intensivo hasta juegos de gráficos intensivos a alta velocidad.

Otro beneficio de aprender C++ con Qt viene del uso generalizado de QT en proyectos de código abierto. Esto es en realidad una gran riqueza de código abierto desde el cual puedes aprender, reusar y posiblemente ayudar a mejorar.

[editar] Como usar este libro

La parte I contiene una introducción a C++, UML, y el núcleo Qt. Esta parte está diseñada para evitar seguir referenciando tanto como sea posible, y se presentar los tópicos en un orden y nivel de detalle que no debieran abrumar a quien es nuevo en C/C++.

En la parte II, encontrarás ideas de programación de alto nivel, módulos Qt y patrones de diseño. Aquí es donde presentamos caminos de desplazamiento en paradigma de la escritura de código y reorganización de objetos en una moda modular.

Para complementación y referencia, la parte III cubre en mayor profundidad algunas "secas" pero importantes características de C++ que hemos introducido en la parte I. En el momento en que el lector haya alcanzado este punto, esas ideas deberían ser mucho más fáciles de entender.

Al final de cada capítulo, encontrarás ejercicios y preguntas de revisión. La mayoría de los ejercicios de programación tienen soluciones disponibles en el Website. Para las preguntas, si las respuestas no se encuentran en el capítulo precedente, entonces a menudo habrá punteros señalando a donde las encontraremos. Si este libro es usado para un curso, estas preguntas deberían se hechas por el estudiante o por el profesor, en el salón de clases o en un examen.

[editar] Una nota sobre los formatos

Lo que estas leyendo es solo un número de las posibles variaciones disponibles. Esto es porque el documento fue escrito originalmente en XML usando un estilo de "programación literal", hemos generado una variedad de versiones diferentes (viñetas laterales, libros de texto paragrafiados, con o sin soluciones, etc.) en una variedad de formatos distintos (html, pdf, ps, htmlhelp).

Cada ejemplo de programación es extraído desde el código fuente en trabajo. La versión web proporciona un enlace para cada código hacia su archivo fuente. Esto hace que sea sencillo probar los ejemplos por tí mismo. El texto y listas en la versión Web también contiene enlaces para cada librería de clase hacia su página de documentación.

<<- Anterior (Contenido) | (Agradecimientos) Siguiente->>

Versión para imprimir esta pagina

<<- Anterior (Prefacio) -|- (Contenido) -|- (Justificación del libro) Siguiente ->>

Versión para imprimir esta pagina

[editar] Agradecimientos

Gracias a los muchos autores y contribuidores en los siguientes proyectos de código abierto, por hacer herramientas libres, por responder preguntas, y por escribir buenos documentos. Usamos todos estos programas para hacer este libro:

En la traducción al castellano se utilizó:

Gracias a Norman Walsh docbook y Bob Stayton docbookxsl por desarrollar y documentar un super sistema de herramientas de publicación. Gracias al resto de la comunidad de docbook por su ayuda y guía.

Gracias a los voluntarios de @debian.org por mantener Sid al día y manterlo estable para ser una plataforma de desarrollo productiva. Gracias a irc.freenode.net por brindar a todos una gran cantidad de buenos cerebros.

Gracias a Emily Ezust por las habilidades de escritor y por darnos un inicio con Qt en primer lugar. Gracias a los correctores quienes proporcionaron entradas y valiosas revisiones en el texto: Mark Summerfield, Johan Thelin, Stephen Dewhurst, Hal Fulton, David Boddie, Andy Shaw, y Jasmin Blanchette Blanchette08, ¡Quien también nos enseñó la danza de Qt 4! Gracias a Matthias Ettrich por la visión y motivación. gracias al resto del equipo de Trolltech por escribir buenos documentos, contestar preguntas en la lista de correo, y comenzar a “abrirse” con la comunidad open-source.

Gracias al personal editorial y de producción de Prentice Hall por su lectura meticulosa de nuestro libro y por ayudarnos a encontrar los muchos errores que dejamos distribuidos a través del texto.

Finalmente, gracias a la universidad de Suffolk, una fuente de gran soporte a lo largo de este proyecto. En particular, gracias a Andrew Teixeira por su incansable ayuda en mantener los servidores que usamos asiduamente durante los últimos dos años y por su invaluable asistencia técnica. Gracias también a los estudiantes quienes tomaron CMPSC 331/608 usando la versión preliminarmente evolucionada de este libro hasta 2003 y que nos dieron un flujo invaluable de revisiones.

<<- Anterior (Prefacio) -|- (Contenido) -|- (Justificación del libro) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Agradecimientos) -|- (Contenido) -|- (Introducción a C++ y Qt 4) Siguiente ->>

Versión para imprimir esta pagina

[editar] Justificación para este libro

Como en la Universidad de Suffolk, seguimos la tendencia popular y continuamos enseñando programación orientada a objetos usando C++. Por varios años enseñamos un curso de un semestre de OOP/C++ estándar que seguía una secuencia CS1-CS2 basada en el lenguaje de programación C. Los estudiantes desarrollaron substancial maestría del lenguaje C++ del núcleo y entendimiento de algunos conceptos de OO como son la encapsulación, rehechura y desarrollo de herramientas. Sin embargo, encontramos que STL es una librería que ofrece dificultades a los estudiantes y causa que pierdan mucho tiempo construyendo programación de bajo nivel y problemas de plantillas. STL no es capaz de escribir aplicaciones con interfaces gráficas, y algún otro framework debía ser usado en consecuencia.

Durante el verano del 2003 nos hartamos y decidimos desarrollar un libro que pudiera aprovechar OOP/C++ en un alto nivel. Buscamos proporcionar una introducción sustancial a la programación de GUI usando el framework Qt multiplataforma, así como tocar algunos patrones de diseño importantes que serían usados.

Diseñamos este primeramente como un libro de texto para ser usado en clases de la universidad, pero fue diseñado de forma extensible y repleta de información que le hiciera útil para lectores con un cierto rango de respaldos: para aquellos que ya programaban en C o algún otro lenguaje progresivo y desearan aprender programación OO y GUI, para aquellos que no tuvieran ese antecedente pero estuviesen familiarizados con Basic, Java, Python, o algún otro lenguaje de programación y desearan aprender C++. La primera parte del libro está encaminada a familiarizar a todas las audiencias con los elementos de C++, conceptos de OO, UML, y las clases Qt de núcleo.

Creemos que los lectores entienden mejor las ideas cuando las aplican, y encontramos que esto es especialmente cierto con los patrones de diseño. Muchas de las clases Qt o ejemplos de código son implementaciones concretas de los patrones de diseño más populares descritos en Gamma95. Para cada patrón de diseño que discutimos, hacemos disponible el código fuente de nuestro ejemplo e incluimos ejercicios que retan al lector a reusar, refinar y extender ese código.

El reuso de librerías requiere un entendimiento no solo de las librerías, sino también del sofware modular, el enlazador y diseño de librería. Hemos incluido una cantidad substancial de advertencias destiladas por la experiencia (nuestra y de nuestros estudiantes) y desde comunidades de discución en línea. Encontramos que esto ayudaba a nuestros estudiantes s hacer frente a la mayoría de los problemas que encontraron en cursos basados en las primeras versiones de este libro.

Utilizamos versiones preliminares de este libro en el curso de OOP/C++ de la Universidad de Suffolk durante cada semestre escolar de los años 2003-2004 hasta 2005-2006, con resultados prometedoramente ascendentes y con valiosas peticiones de nuestros estudiantes. En la versión anterior de este curso los estudiantes típicamente acostumbraban escribir cientos de líneas de código para programar sus proyectos. En contraste, con el énfasis en el reuso de código y la explotación de librerías de herramientas robustas, los estudiantes programan proyectos que tienen menos líneas de código del estudiante pero son mucho más interesantes, y creemos, mucho más valiosos como experiencias de aprendizaje.

Existen muchos libros de C++ por allí que también enseñan C++ o enseñan Qt, pero encontramos que los libros de C++ usan una variedad distinta de estilos de programación, y hacen énfasis en algunos puntos que nosotros no usamos mucho con Qt. los libros sobre Qt que hemos visto asumen previos conocimientos de C++. Este libro, por el contrario, asume que no se tiene experiencia programando C++ o C, y cubre las características de lenguaje de C++ que necesitas saber con el fin de usar las clases Qt 4 tan pronto como sea posible en ejemplos y asignaciones. Esto puede ser un útil libro de texto para enseñar C++ y patrones de diseño, con énfasis en el reuso de código abierto.

Hasta donde podemos saber, no hay libros de C++ a nivel universitario que también contengan revisión de preguntas, ejercicios y lecturas alternativas para los instructores.

En Marzo del 2009 Paynalton, un aprendiz autodidacta de programación, buscaba una manera de crear una interfase gráfica en Qt 4 y buscó documentación que le enseñara a realizar esta tarea. Sin embargo la única fuente apropiada que encontró fue este libro que había sido publicado en la red. Por ello comenzó a leerlo al tiempo que realizaba una traducción al castellano con el fin de aprender y, al mismo tiempo, ayudar a otros que posteriormente buscaran este mismo conocimiento a encontrar la documentación en su idioma.

<<- Anterior (Agradecimientos) -|- (Contenido) -|- (Introducción a C++ y Qt 4) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Introducción a C++) -|- (Contenido) -|- (Una breve historia de C++) Siguiente ->>

Versión para imprimir esta pagina

[editar] 1.1. Un vistazo a C++

C++ fue escrito originalmente como una serie de macros de preprocesamiento, una extensión para C, conocida como C con clases. Después de muchos años de evolución y refinamiento, este ahora dota a C añadiendo muchísimas características de alto nivel como escritura fuerte, abstracción de datos, referencias, operadores y sobrecarga de funciones, y soporte considerable para programación orientada a objetos.

C++ retiene las características clave que hicieron de C un lenguaje popular y útil: velocidad, eficiencia y un amplio rango de expresiones que permite programar a muchos niveles, desde el más bajo - como son llamadas de sistema operativo u operaciones de bitwise - hasta el más alto nivel, manipulando una gran cantidad de objetos y gráficas de objetos.

Una decisión de diseño fundamental fue hecha en los inicios de C++: Cualquier característica agregada a C++ no debería causar una penalización de tiempo de ejecución en el código C que no lo usara^[1]. Ciertamente, esto agregó cargas al compilador, y algunas características tienen un costo de tiempo de ejecución si son utilizadas, pero un programa C que es compilado por un compilador C++ debería correr tan rápido como si hubiese sido compilado por un compilador C.

<<- Anterior (Introducción a C++) -|- (Contenido) -|- (Una breve historia de C++) Siguiente ->>

Versión para imprimir esta pagina

↑ Desafortunadamente, el manejo de excepciones rompe esta regla causando un poco de sobrecarga si es habilitada. Es el porque de que muchas librerías prefieren no usar excepciones.

<<- Anterior (Un vistazo a C++) -|- (Contenido) -|- (Instalando C++/Qt: Plataformas Open Source) Siguiente ->>

Versión para imprimir esta pagina

[editar] Una breve historia de C++

C++ fue diseñado por Bjarne Stroustrup mientras trabajaba para AT&T Bell Labs que eventualmente lo empaquetó y comercializó. Las versiones iniciales del lenguaje estuvieron disponibles internamente para AT&T a principios de 1981. C++ continuó evolucionando en respuesta a las peticiones de los usuarios.

La primera edición del libro de Stroustrup, The C++ Programming Language, fue publicado a principios de 1986. En 1989 con la liberación de la versión 2.0, C++ fue rápidamente conocido como un lenguaje serio y útil. En ese año, comienzan los trabajos para establecer un lenguaje reconocido internacionalmente para C++.

La estandarización bajo el control del comité ANSI(American National Standards Institute) X3J16 comienzan en 1989 y son completados y publicados en 1997 por la Secretaría X3 bajo el título Draft Standard - The C++ Language, X3J16/97-14882, Information Technology Council (NSITC), Washington, DC. En Junio de 1998, el borrador estándar fue aceptado unánimemente por los representantes de las 20 naciones principales en el esfuerzo ANSI/ISO (International Standards Organization) del noveno año.

La tercera edición del libro de Stroustrup, fue publicada en 1997. Y fue ampliamente difundida como la referencia C++ definitiva.

El estándar ANSI esta disponible a la venta desde el sitio web de ANSI. El Borrador Estándar ANSI/ISO está disponible gratuitamente online.

<<- Anterior (Un vistazo a C++) -|- (Contenido) -|- (Instalando C++/Qt: Plataformas Open Source) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Una breve historia de C++) -|- (Contenido) -|- (Instalando C++/Qt: Win32) Siguiente ->>

Versión para imprimir esta pagina

[editar] Instalando C++/Qt: Plataformas Open Source

Las herramientas de desarrollo Open source (ssh, bash, gcc) están disponibles nativamente en UNIX y sus plataformas relacionadas. Esto incluye a Mac OS/X, que es una distribución basada en BSD^[1].

Cuando discutimos algo que es específico para plataformas derivadas de UNIX (Linux, BSD, Solaris, etc), usaremos la contracción *nix para “la mayoría de sabores de UNIX.“

Otro acrónimo importante es POSIX, que se entiende como Portable Operating System Interface for UNIX. El desarrollo de esta familia de estándares fue auspiciado por IEEE (Institute of Electrical and Electronics Engineers), una organización de ingenieros, científicos y estudiantes, mejor conocidos por desarrollar estándares para la industria electrónica y computación^[2].

Esta sección es para lectores que tienen alguno de los sabores de *nix instalado.

Los ejemplos en este libro fueron probados con Qt 4.1. Te recomendamos utilizar la misma versión o una más reciente. El primer paso eb configurar tu computadora para este libro es estar seguros de que la instalación de Qt 4 esta disponible para ti. Esto incluye, en adicción a las fuentes y códigos de librería compilados, el systema de documentación Qt Assistant, Ejemplos de programas, Y el programa Qt Designer.

Nota:

Si tu sistema tiene instalado KDE 3.x (El Entorno de escritorio K), entonces tiene en realidad una versión de Qt 3.x instalada. Qt 4 necesita ser instalado por separado. Nuestros ejemplos no se compilan bajo Qt 3

Para ver que (si la hay) versión de Qt esta realmente instalada en tu sistema, inicia con los siguientes comandos:

which qmake
qmake -v

La salida del primer comando te dirá donde esta alojado el ejecutable de qmake. Si esta salida se ve como esto: bash: qmake: command not found, entonces es posible que:

Qt "completo” (incluyendo herramientas de desarrollo) no está instalado.
Está instalado, pero tu PATH no incluye /ruta/a/qt4/bin

Si puedes correrlo, qmake -v proporciona informes sobre la versión. Si reporta que estas usando una versión Qt 4.x.y, revisa que estas otras herramientas Qt están disponibles: moc, uic, assistant, y designer.

Si estos ejecutables se encuentran todos y coincide la versión, Qt 4 está instalado y listo para usarse.

Si las pruebas de las líneas arriba indicadas te han dado una versión anterior o que no hay ningún Qt instalado, o has perdido algunos componentes de Qt4, entonces necesitas construir o instalar la última versión liberada de Qt4 y seleccionar los ejecutables de Qt 4 dentro de tu ruta por defecto.

Instalando Qt4 desde paquetes

Usando tu administrador de paquetes *nix (p.e. apt, urmpi, aptitude, synaptic, rpmdrake, portage, etc.) puedes fácil y rápidamente instalar los paquetes que comprenden Qt 4. Esta es una lista de los paquetes Qt4 disponibles en sistemas Debian (la lista puede diferir en otras distribuciones)

# apt-cache search qt4
libqt4-core - Qt4 core non-GUI functionality runtime library
libqt4-debug - Qt4 debugging runtime libraries
libqt4-dev - Qt4 development files
libqt4-gui - Qt4 core GUI functionality runtime library
libqt4-qt3support - Qt3 compatibility library for Qt 4
libqt4-sql - Qt4 SQL database module
qt4-designer - Qt4 Designer
qt4-dev-tools - Qt4 development tools
qt4-doc - Qt4 API documentation
libqt4-designer - Qt4 Designer libraries

[editar] Descargando desde las fuentes

Puedes descargar, desempacar y compilar el último tarball de código abierto desde TrollTech. Dos lugares típico para desempacar el tarball son /usr/local/ (si eres root) ó $HOME/qt (si no lo eres).

Nota:

Un tarball es un archivo producido por el comando tar (tape archive) que puede combinar muchos archivos, tantos como se especifiquen en el comando, en un solo archivo (que generalmente lleva la extensión.tar) para facilitar su almacenamiento o transferencia. El archivo combinado generalmente es comprimido usando una utilería como gzip ó bzip2, que agrega la extensión .gz ó .bz al archivo tar.

La línea de comando para desempacar un tarball depende de como fue creado. Usualmente puedes determinar esto por su extensión.

tar -vxf whatever.tar // usando el modo "verbose"
tar -zxf whatever.tar.gz // comprimido con gzip
tar -zxf whatever.tgz // también comprimido con gzip
tar -jxf whatever.tar.bz2 // comprimido con bzip2

Un archivo tar puede preservar estructuras de directorio y muchas opciones e interruptores. Puedes leer la documentación en línea de esas utilerias escribiendo:

info tar 
info gzip
info bzip

El tarball de fuente Qt contiene el código fuente completo de la librería Qt, además de numerosos ejemplos, tutoriales y extensiones con una documentación de referencia completa. El tarball contiene instrucciones simples de instalación (en los archivos README e INSTALL)y un mensaje en configure --help. Asegúrate de leer el archivo README antes de intentar software desde cualquier tarball de fuente abierta.

La compilación de la fuente puede tomar 2 o 3 horas (dependiendo de la velocidad de tu sistema), pero es una espera que vale la pena. El Ejemplo 1.1 muestra las opciones que utilizamos para configurar Qt 4.

[editar] Ejemplo 1.1

Ejemplo: Ejemplo 1.1. ../bin/qtconfigure

#!/bin/sh
# Este es un script que utilizo para configurar y
# hacer qt4 - incluye opciones extras que utilizo para trabajar con MySQL.
#
# Antes de correr esto, asegúrate de que cuentas al menos con
# los archivos de cabecera del cliente mysql :

# apt-get install libmysqlclient-dev mysql-server mysql-client

# cambia esto al lugar en donde deseas instalar:

./configure -fast -qt-gif -system-sqlite -debug \
           -I/usr/include/mysql -qt-sql-mysql -plugin-sql-mysql

# make

Descargar ejemplo

Después de que Qt esté configurado, haz y luego instala (make, make install).

En el paso final, make install copia los ejecutables y cabeceras en otro lugar desde el árbol de directorios del tarball descomprimido. Si estas instalando en una ubicación común, necesitas ser root para hacer esto.

Consejo: Revisar la instalacón de Qt

Después de la instalación, prueba qmake -v para determinar que versión de qmake es reconocida por tu intérprete. Para sistemas que tienen más de una versión instalada, es importante hacer esto.

$ which qmake
/usr/local/qt-x11-opensource-src-4.1/bin/qmake
$ qmake -v
QMake version: 2.00a
Using Qt version 4.1 in /usr/local/qt-x11-opensource-src-4.1/lib
$

[editar] Variables de Entorno

Después de instalar, revisa tus variables de entorno y asegúrate de que PATH y LD_LIBRARY_PATH contienen referencias apropiadas para el Qt instalado.

Usamos una variable llamada QTDIR para guardar la ruta al directorio de instalación principal de QT 4 ^[3].
PATH debería ser $QTDIR/bin (la ruta a los ejecutables de Qt).
MANPATH contendría $QTDIR/doc (la ruta a la documentación de Qt).
LD_LIBRARY_PATH contendría $QTDIR/lib (la ruta a las librerías de Qt).

Consejo: Env

El comando bash env muestra los valores actuales de todas tus variables de entorno.

[editar] Ejemplo 1.2

Ejemplo: Ejemplo 1.2 src/libs/utils/qt.sh

Muestra como deben ser los valores con bash, pero el valor actual depende de donde están localizados en tu sistema

# Entorno específico del usuario típico y valores de arranque para QT
# Dependiendo de como y donde fue instalado Qt en tu sistema
export QTDIR=$QTDIR/bin:$PATH /usr/local/Trolltech/Qt-4.4.1
export PATH=$QTDIR/bin:$PATH
export MANPATH=$QTDIR/doc/man:$MANPATH
# Localización de tus propias librerías - origen y destino.
export CPPLIBS=~/cs331/projects/libs
# Ruta de la librería LD - donde se buscará por librerías de objetos compartidos
# en tiempo de ejecución.
export LD_LIBRARY_PATH=$CPPLIBS:$QTDIR/lib:$LD_LIBRARY_PATH

Descargar ejemplo

<<- Anterior (Una breve historia de C++) -|- (Contenido) -|- (Instalando C++/Qt: Win32) Siguiente ->>

Versión para imprimir esta pagina

↑ BSD es mantenido por Berkeley Software Distribution, una facilidad de Computer Systems Research Group (CSRG) de la universidad de California a Berkeley. CSRG ha sido un importante centro de desarrollo para UNIX y para varios protocolos básicos (p.e., TCP/IP) desde la década de 1980.
↑ Si queremos escribir una expresión regular de POSIX ( Sección 13.2), para *nix, esta debería verse como esto: (lin|mac-os|un|solar|ir|ultr|ai|hp)[iu]?[sx].
↑ Qt 4 no requiere del uso de esta variable de entorno, pero nosotros la utilizamos para referirnos al directorio “Qt install” en nuestros ejemplos.

<<- Anterior (Instalando C++/Qt: Plataformas Open Source) -|- (Contenido) -|- (C++ Primer Ejemplo) Siguiente ->>

Versión para imprimir esta pagina

[editar] Instalando C++/Qt: Win32

Hay dos versiones de Qt disponibles para plataformas Win32.

La edición de código abierto, que soporta MinGW (the Minimalist Gnu for Windows), que puede ser descargada y usada libremente para proyectos open-source.
La edición comercial de Qt 4.4 puede ser usada con compiladores Microsoft, como son Microsoft Visual Studio 2003, y versiones posteriores. Usar un compilador más viejo que Qt 4.4 hará que muchas de las nuevas características de Qt4.4 no estén disponibles.

Instalar la versión más reciente es un juego de niños: el instalador Win32 te guiará a través del proceso, registra extensiones y establece variables de entorno por ti. La edición open-source puede ser descargada e instala MinGW por ti.

Después de que Qt esté instalado, deberías hacer click en:

Inicio -> Programas -> Qt by Trolltech -> Build debug symbols

Nota:

Esto puede tomar un par de horas.

A continuación, abre una terminal de comandos haciendo click en:

Inicio -> Programas -> Qt by Trolltech -> Command Prompt

Ahora podras correr qmake -v desde el guión de comando para ver la versión instalada de Qt actualmente.

qmake, assistant, designer, qtdemo, qtconfig, g++, y make (o nmake si estás utilizando MS Developer's Studio) deberían ser visibles en tu ruta de búsqueda ahora.

Prueba qtdemo también disponible desde el Menú Inicio.

<<- Anterior (Instalando C++/Qt: Plataformas Open Source) -|- (Contenido) -|- (C++ Primer Ejemplo) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Instalando C++/Qt: Win32) -|- (Contenido) -|- (Entrada y Salida) Siguiente ->>

Versión para imprimir esta pagina

[editar] C++ Primer Ejemplo

A través de este libro usaremos ejemplos de código para explicar importantes problemas de programación y OOP. Nuestro objetivo es usar un ejemplo mínimo que ilustrará las ideas y técnicas amigable y eficientemente.

[editar] Ejemplo 1.3

Ejemplo: Ejemplo 1.3 src/early-examples/fac.cpp

#include <iostream> -- librería c++ estándar - En las viejas versiones de C++, deberías poder encontrar en su lugar a <iostream.h>, pero esa versión es considerada como obsoleta.
int main() { -- Inicio de la función main que retorna int.
using namespace std; -- Nos permite usar los símbolos cin, cout, y endl sin prefijar cada nombre con std::.
int factArg = 0 ; -- Sintaxis de inicialización al estilo C.
int fact(1) ; -- Sintaxis de inicialización al estilo C++.
do { -- Inicio del bucle “do..while”.
cout << "Factorial de: "; -- Escribe a la salida estándar
cin >> factArg; -- lee desde la entrada estándar y la convierte en int
} while (factArg < 0) ; -- Si es falso, sale del bucle do
while ( i <= factArg ) { -- Inicio de bucle while.
return 0; -- Cuando main devuelve 0, normalmente significa “sin errores”

/* Calcula e imprime n! desde un n dado. 
Usa diversos elementos básicos de C++. */
#include <iostream>
 int main() {
  using namespace std;
// Declaración de variables
  int factArg = 0 ;         
  int fact(1) ;
  do {                  
   cout << "Factorial de: ";
       cin >> factArg;      
       if ( factArg < 0 ) {
           cout << "Valores negativos no, ¡Por favor!" << endl;
       } 
   } while (factArg < 0) ; 
   int i = 2;
   while ( i <= factArg ) {   
       fact = fact * i; 
       i = i + 1;
   } 
   cout << "El Factorial de " << factArg << " es: " << fact << endl;
   return 0;
}

Descargar ejemplo

En la mayoría de las plataformas, compilamos y corremos este programa usando el ubicuo compilador GNU C, gcc. El comando para compilar un programa en D++ es g++, pero esto es un simple alias para gcc con algunos parámetros C++ habilitados.

Cuando invocamos al compilador, recomendamos maximizar el monto de información que está disponible desde el proceso de compilación. Para esto, incluimos algunos parámetros a la línea de comandos:

-Wall Que habilita todas las posibles alertas sobre construcciones que pueden ser consideradas cuestionables si es que van de acuerdo con el estándar.

src/early-examples> g++ -Wall fac.cpp
src/early-examples> g++ -Wall -o execFile fac.cpp

En la segunda versión mostrada arriba, el parámetro opcional -o execFile es colocado para especificar el nombre del ejecutable generado. Si omitimos este parámetro, como en la primera versión, el compilador producirá un ejecutable de nombre a.out. En cualquier caso, si en realidad ya existe un archivo en el mismo directorio con el nombre de nuestro ejecutable resultante, entonces el compilador tranquilamente lo sobreescribirá de manera automática.

Hemos mencionado aquí solo unos cuantos de los parámetros de compilación más comunes. En un sistema *nix puedes ver las páginas del manual, un sumario de opciones de comando y como son usadas escribiendo el comando:

man g++

En la mayoría de los sistemas, esos comandos te permiten navegar por la documentación en línea parra g++ una pantalla a la vez. Para documentación más completa sobre gcc, visita el Centro de Documentación en línea GNU.

Despues de que ha sido compilado completamente, nuestro programa puede correr al escribir el nombre del archivo ejecutable. Aquí hay un ejemplo en una plataforma *nix:

src/early-examples> ./a.out
Factorial de: -3
Valores negativos no, ¡Por favor!
Factorial de: 5
El Factorial de 5 es: 120
src/early-examples>

Este corto programa utiliza diversos elementos del lenguaje que se encuentran en la mayoría de los programas C++.

[editar] Comentarios

C++ tiene una línea simple de comentarios como en Java. Cualquier texto entre // y el fin de la línea es un comentario. Los delimitadores de comentario al estilo C también pueden ser usados. El texto entre /* y */ es un comentario.

[editar] #include

Para reusar funciones, tipos o identificadores desde librerías, utilizamos la directiva de preprocesamiento #include. (Sección C.1) Como en C, todas las directivas de preprocesamiento comienzan con el carácter comodín (#), y son evaluados justamente antes de que el compilador compile tu código. En este ejemplo, la cabecera incluida <iostream> contiene las definiciones Standard Library para entrada/salida.

[editar] Usando namespace

Los símbolos de Standard Library (Introducción a Patrones de Diseño en C++ con Qt4/B Cabeceras Estándar) están todos encerrados bajo el namespace std.

Un namespace (Sección 19.4) es una colección de clases, funciones y objetos que pueden ser accesados con un prefijo de nombre. El uso de la declaración le dice al compilador que agregue símbolos desde el namespace (std) especificado dentro del namespace global.

[editar] Declarando e Inicializando Variables

Las declaraciones de variable se dan en tres estilos dentro de C++ :

type-expr NombreVariable;
type-expr NombreVariable = init-expr;
type-expr NombreVariable (init-expr);

En la primera forma, la variable pudiera no ser inicializada. La tercera forma es una alternativa de sintaxis de la segunda.

[editar] Selección

C++ proporciona la suerte usual de variaciones de sintaxis para seleccionar que discutiremos en la Sección 20.2.

[editar] Interacción

Nosotros usamos dos de los árboles de las estructuras de interacción proveídas por C++ en nuestro ejemplo. Todo el árbol será discutido en la Sección 20.3

<<- Anterior (Instalando C++/Qt: Win32) -|- (Contenido) -|- (Entrada y Salida) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (C++ Primer Ejemplo) -|- (Contenido) -|- (Ejercicios: Entrada y Salida) Siguiente ->>

Versión para imprimir esta pagina

[editar] Entrada y Salida

En el ejemplo 1.3, la directiva

#include <iostream>

Nos permitió hacer uso de la entrada global predefinida y objetos de flujo de salida. Estos son:

cin, entrada estándar, el teclado por defecto.
cout, salida estándar, la pantalla de consola por defecto.
cerr, error estándar, otro flujo de salida a la pantalla de consola con parpadeos más visibles, y normalmente es usado para mensajes de error.

En el ejemplo 1.3, hacemos uso del objeto de flujo global (de la clase ostream), llamado cout. Llamamos a una de sus funciones miembro, cuyo nombre es operator<<(). Esta función recarga el operador de inserción, <<, y lo define como la función global. ^[1] La sintaxis de esa sentencia de salida es también un tanto interesante. En lugar de usar la conocida y voluminosa notación de la función:

cout.operator<<("Factorial de :");

Invocamos a la misma función utilizando la sintaxis infix más elegante y legible:

cout << "Factorial de:  " ;

Este operador puede ser encadenado (usado sobre valores múltiples), y está predefinido para usarse con muchos tipos integrados, como vemos en la siguiente sentencia de salida:

cout << "El costo es de $" << 23.45 << " por " << 6 << " artículos." << '\n';

En el ejemplo 1.4, podemos ver operator>>() usado para ingresar con istream en un camino análogo a << para ostream.

[editar] Ejemplo 1.4

Ejemplo: Ejemplo 1.4 src/iostream/io.cpp

Los símbolos flush y endl son manipuladores^[2], del namespace std.

#include <string>
#include <iostream>

int main() {
   using namespace std;
   const int ESTEANYO = 2006;
   string TuNombre;
   int AnyoNacimiento;

   cout << " ¿Cuál es tu nombre? "  << flush;
   cin >> TuNombre;

   cout << "¿En qué año naciste? " ;
   cin >> AnyoNacimiento;

   cout << "Tu nombre es " << TuNombre
           << " y tienes aproximadamente " 
           << (ESTEANYO - AnyoNacimiento)
           << " años. " << endl;
}

Descargar ejemplo

En el Ejemplo 1.4, hacemos uso del tipo cadena, también desde la librería de C++ Standard Library. Discutiremos este tipo y demostraremos algo de sus funciones más adelante en la Sección 1.11.

<<- Anterior (C++ Primer Ejemplo) -|- (Contenido) -|- (Ejercicios: Entrada y Salida) Siguiente ->>

Versión para imprimir esta pagina

↑ Cubrimos las funciones de recarga y operadores más a fondo en la Sección 5.2.
↑ Los manipuladores son referencias de función que pueden ser insertados dentro de un flujo de entrada ó salida para modificar su estado. Discutimos más a fondo esto en la Sección 1.12.

<<- Anterior (Entrada y Salida) -|- (Contenido) -|- (Diálogos Qt para entrada/salida de usuario) Siguiente ->>

Versión para imprimir esta pagina

[editar] Ejercicios: Entrada y Salida

1 Usando el Ejemplo 1.4, haz lo siguiente:

Primero, compila y ejecuta para ver su funcionamiento normal.
¿Qué pasa si ingresas un valor no numérico en el año de nacimiento?
¿Qué pasa si ingresas un nombre como Jorge el Curioso como tu nombre?
¿Qué pasa si remueves la siguiente línea?

using namespace std;

Reemplaza la sentencia:

cin >> TuNombre;

Por la sentencia:

getline(cin, TuNombre);

y prueba Jorge el Curioso de nuevo.

¿Puedes explicar las diferencias de funcionamiento entre cin >> y getline()? Discutimos esto en la Sección 1.11.
Añade algunas preguntas mas para que el programa requiera una variedad de números y cadenas y prueba los resultados.

2. Considerando el Ejemplo 1.5:

[editar] Ejemplo 1.5

Ejemplo: Ejemplo 1.5 src/early-examples/fac2.cpp

long n; Entero largo
cin >> n; lee desde stdin, trata de convertirlo a long

     #include <iostream> 
     long factorial(long n) {
         long ans = 1;
         for (long i = 2; i <= n; ++i) {
             ans = ans * i;
             if (ans < 0) {
                 return -1;
             }
         }
         return ans;
     }
     int main() {
         using namespace std;
         cout << "Por favor ingresa n: " << flush;
         long n;       
         cin >> n;      
         if (n >= 0) { 
             long nfact = factorial(n);
             if (nfact < 0) {
                 cerr << "error de carga: " 
                      << n << " es demasiado grande." << endl;
             }
             else {
                 cout << "factorial(" << n << ") = "
                      << nfact << endl;
             }
         }
         else {
             cerr << "Desconocido:  "
                  << "factorial de un número negativo: " << n << endl;
         }
         return 0;
     }

Descargar ejemplo

Prueba el Ejemplo 1.5 con una variedad de valores de entrada, incluyendo algunos valores no numéricos.
Determina el valor de entrada más largo que producirá una salida válida.
¿Puedes cambiar el programa para que este produzca resultados válidos para valores de entrada más grandes?
Modifica el programa para que este no produzca resultados inválidos.
Explora los efectos de usar la sentencia:

            if (cin >> n)   {  ...  }

para encerrar el proceso de n en este programa. En particular, trata de ingresar datos no numéricos después del prompt. Este es un ejemplo de el uso del operador de conversión, que discutiremos con más detalle en la Sección 2.11.

Modifica el programa para que acepte valores desde el usuario hasta que el valor 9999 haya sido ingresado.

<<- Anterior (Entrada y Salida) -|- (Contenido) -|- (Diálogos Qt para entrada/salida de usuario) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Ejercicios: Entrada y Salida) -|- (Contenido) -|- (Ejercicios:Diálogos Qt para entrada/salida de usuario) Siguiente ->>

Versión para imprimir esta pagina

[editar] Diálogos Qt para entrada/salida de usuario

El Ejemplo 1.6 muestra una reescritura de nuestro primer ejemplo en C++, usando diálogos en lugar de entradas/salidas estándar. Qt proporciona clases para reemplazar casi todas las clases en la librería estándar de C++. Aun podemos necesitar de ellos, en el caso de que estemos reusando código que use STL o iostreams en una aplicación Qt.

Este ejemplo hace uso de la clase de Qt QString, que es una implementación dinámica que soporta el estándar Unicode. QString contiene muchas funciones miembro útiles para convertir y dar formato a cadenas de maneras distintas.

[editar] Ejemplo 1.6

Ejemplo: Ejemplo 1.6. src/early-examples/example1/fac1.cpp

int main (int argc, char* argv[]) { Inicio de la función main que devuelve int.

QApplication app(argc, argv); Inicio de cada aplicación GUI de Qt.

QTextStream cout(stdout); Crea un QTextStream para salida estándar.

int respuesta = 0; Debe ser definida fuera del bucle do, porque este es usado dentro de la condición, fuera del bloque do.

"Factorial de:", 1); Ventana de diálogo, espera a que el usuario ingrese un interger y lo devuelve.

.arg(factArg).arg(fact) cada %n es reemplazado con un valor arg()

.arg("¿Quieres calcular otro factorial?"); Las sentencias largas pieden continuar en múltiples líneas, tanto como se topen con símbolos limitadores.

QMessageBox::Yes ¦ QMessageBox::No); bitwise or de dos valores

#include <QtGui>

int main (int argc, char* argv[]) { 
   QApplication app(argc, argv);
   QTextStream cout(stdout);     

   // Declaración de variables
   int respuesta = 0;

   do {
       // variables locales de loop:
       int factArg = 0;
       int fact(1);
       factArg = QInputDialog::getInteger(0, "Calculadora del Factorial",
           "Factorial de:", 1);
       cout << "El usuario ingresó: " << factArg << endl;
       int i=2;
       while (i <= factArg) {
           fact = fact * i;
           ++i;
       }
       QString dijo = QString("El Factorial de of %1 es %2.\n%3")
           .arg(factArg).arg(fact)
           .arg("¿Quieres calcular otro factorial?");    
       respuesta = QMessageBox::question(0, "¿Jugar de nuevo?", dijo,
           QMessageBox::Yes ¦ QMessageBox::No);
   } while (respuesta == QMessageBox::Yes);
   return EXIT_SUCCESS;
 }

Descargar ejemplo

Este programa hace uso de las siguientes clases:

QApplication - Un objeto sencillo que necesita existir en todas las aplicaciones Qt.
QInputDialog - Para hacer preguntas al usuario.
QMessageBox - Para enviar respuestas al usuario.
QString - Una clase de cadena unicode. Estamos usando un muy poderoso método llamado arg(), el cual nos permite formatear valores parametrizados (%1, %2, etc) dentro de la cadena.
QTextStream - Para flujos hacia/desde archivos de texto. En este ejemplo, definimos una variable llamada cout que cumple las mismas metas (stdout) que el cout de iostream desde la librería estándar de C++. Como desde ahora obtendremos las entradas de usuario desde diálogos y otros other widgets, no es necesario crear un cin más.

Cuando arrancamos esta aplicación, primero veremos un diálogo de entrada como el de la Figura 1.1

[editar] Figura 1.1

Diálogo de Entrada de Factorial

Ver En Tamaño Original

Después de que el usuario ingrese el número y haga click en OK, usaremos un QMessageBox con el valor calculado resultante.

[editar] Figura 1.2

QMessageBox

Ver En Tamaño Original

Para compilar esta aplicación, necesitamos un archivo de proyecto. Un archivo de proyecto describe el proyecto enlistando todos los otros archivos, así como todas las opciones y localizaciones de archivos que son necesarios para construir el proyecto. Debido a que esta es una aplicación muy simple, el archivo de proyecto también es muy simple, como se muestra en el Ejemplo 1.7

[editar] Ejemplo 1.7

Ejemplo: Ejemplo 1.7. src/early-examples/example1/example1.pro

La primera ínea, TEMPLATE = app, indica que qmake debería iniciar con un Makefile de plantilla adecuado para construcción de aplicaciones. Si este fuera un archivo de proyecto para una librería, deberías de ver TEMPLATE = lib para indicar que una plantilla de librería Makefile debería ser usada en su lugar. Una tercera posibilidad es que tuviesemos nuestro propio codigo fuente distribuido a lo largo de varios subdirectorios, cada uno teniendo su propio archivo de proyecto. En este caso deberíamos ver TEMPLATE = subdirs dentro del archivo de proyecto alojado en el directorio raiz, lo que causaría un Makefile para ser producido en el directorio raiz y en cada subdirectorio.

TEMPLATE = app
SOURCES += fac1.cpp
win {
        CONFIG += console
}

Descargar ejemplo

<<- Anterior (Ejercicios: Entrada y Salida) -|- (Contenido) -|- (Ejercicios:Diálogos Qt para entrada/salida de usuario) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Diálogos Qt para entrada/salida de usuario) -|- (Contenido) -|- (Makefile, qmake y archivos de proyecto) Siguiente ->>

Versión para imprimir esta pagina

[editar] Ejercicios: Diálogos Qt para Entrada/Salida

Los ejercicios en esta sección están basados en el Ejemplo 1.6. La mayoría de las respuestas pueden ser encontradas el la Documentación de referencia de API de QT

Para el QInputDialog, tenemos un botón Cancelar que actualmente no es usado. ¿Como podríamos arreglar este programa para que no muestre el botón Cancelar?
¿Como podríamos arreglar el programa para que no realice el cálculo y salga del bucle si el usuario hace click en Cancelar?
Por el momento, no hacemos una revisión sobre si el usuario ingresa un número negativo. ¿Cómo podríamos arreglar el programa para asegurarnos de que los números negativos jamás sean calculados?

<<- Anterior (Diálogos Qt para entrada/salida de usuario) -|- (Contenido) -|- (Makefile, qmake y archivos de proyecto) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Ejercicios:Diálogos Qt para entrada/salida de usuario) -|- (Contenido) -|- (#include: Encontrando archivos de cabecera) Siguiente ->>

Versión para imprimir esta pagina

[editar] Makefile, qmake, y Archivos de Proyecto

Las aplicaciones de C++ generalmente están compuestas por muchos archivos fuente, archivos de cabeceras y librerías externas. Durante el curso normal del desarrollo del proyecto, los archivos de origen y las librerías son agregadas, cambiadas o removidas. Durante la fase de prueba/desarrollo, el proyecto es recompilado y reenlazado muchas veces. Para producir un ejecutable, todos los archivos de origen cambiados deben ser recompilados y los archivos de objeto deben ser completamente reenlazados.

Tomando un rastro de todo, de todas las partes de cada uno un proyecto requiere un mecanismo que especifique con precisión los archivos involucrados, lar herramientas necesarias para construir, los objetivos intermedios y sus dependencias y el objetivo ejecutable final.

La utilidad más ampliamente usada para manejar el trabajo de construir un proyecto es make^[1]. Este lee los detalles de las especificaciones del proyecto y las instrucciones del compilador desde un Makefile, se asemeja a un script de consola, pero contiene (como mínimo):

Reglas para construir ciertos tipos de archivos (p.e. para obtener un archivo .o desde un archivo .cpp, debemos correr gcc -c en el archivo .cpp)
Los objetivos que se especifican como ejecutables (o librerías) que deben ser construidos.
Dependencias que listan que objetivos necesitan ser reconstruidos cuando ciertos archivos son cambiados.

El comando make carga por defecto el archivo llamado Makefile desde su directorio de trabajo actual y realiza los pasos de consstrucción especificados (compilado y enlace)

El beneficio inmediato de usar make es que este recompila solamente los archivos que necesitan ser reconstruidos, en vez de recompilar a ciegas cada archivo cada vez. La Figura 1.2 es un diagrama que intenta mostrar los pasos involucrados en la construcción de una aplicación Qt. Para aprender más sobre make, recomendamos el libro The Linux development platform Escrito por Rafeeq Ur Rehman, Christopher Paul.

[editar] Figura 1.3

Pasos de Construcción de (q)make

Ver En Tamaño Original

Con Qt, no es necesario escribir ningún Makefile. Qt proporciona una herramienta llamada qmake para generar los Makefile por tí. Es poco necesario para quienes corren make y entienden su salida. La mayoría de los IDE corren make (o algo similar) bajo la cubierta y después muestran o filtran su salida.

La transcripción de abajo muestra que archivos son creados en cada paso del proceso de construcción para el Ejemplo 1.6:

src/early-examples/example1> ls -sF
total 296
  4 fac1.cpp    
src/early-examples/example1> qmake -project
src/early-examples/example1> ls -sF
total 296
  4 fac1.cpp  4  example1.pro    
src/early-examples/example1> qmake
src/early-examples/example1> ls -sF
total 296
  4 fac1.cpp  4 example1.pro   4 Makefile    
src/early-examples/example1> make
g++ -c -pipe -g -Wall -W -D_REENTRANT -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED
 -I/usr/local/Trolltech/Qt-4.4.1/mkspecs/linux-g++ -I.
 -I/usr/local/Trolltech/Qt-4.4.1/include/QtCore
 -I/usr/local/Trolltech/Qt-4.4.1/include/QtCore
 -I/usr/local/Trolltech/Qt-4.4.1/include/QtGui
 -I/usr/local/Trolltech/Qt-4.4.1/include/QtGui
 -I/usr/local/Trolltech/Qt-4.4.1/include -I. -I. -o fac1.o fac1.cpp
g++ -Wl,-rpath,/usr/local/Trolltech/Qt-4.4.1/lib -o example1 fac1.o
 -L/usr/local/Trolltech/Qt-4.4.1/lib -lQtGui -L/usr/local/Trolltech/Qt-4.4.1/lib
 -L/usr/X11R6/lib -pthread -lpng -lSM -lICE -pthread -pthread -lXi -lXrender
 -lXrandr -lfreetype -lfontconfig -lXext -lX11 -lQtCore -lz -lm -pthread
 -lgthread-2.0 -lrt -lglib-2.0 -ldl -lpthread
src/early-examples/example1> ls -sF
total 288
124 example1*    4 example1.pro    4 fac1.cpp  148 fac1.o    8 Makefile
total 420
src/early-examples/example1>

qmake -project crea un proyecto cuyo nombre es el mismo que el directorio de los archivos de origen. make creará un ejecutable con el mismo nombre del proyecto.

Nota que nosotros podemos ver los argumentos pasados al compilador cuando corremos make. Si se encuentra algun error, lo veremos también.

<<- Anterior (Ejercicios:Diálogos Qt para entrada/salida de usuario) -|- (Contenido) -|- (#include: Encontrando archivos de cabecera) Siguiente ->>

Versión para imprimir esta pagina

↑ En MS Dev Studio, se le llama nmake

<<- Anterior (Makefile, qmake y archivos de proyecto) -|- (Contenido) -|- (El comando make) Siguiente ->>

Versión para imprimir esta pagina

[editar] #include: Encontrando Archivos de Cabecera

Hay tres formas comunmente usadas para incluir un archivo ce cabecera de librería:

 #include <headerFile>
 #include "headerFile"
 #include "path/to/headerFile"

Los corchetes de ángulo (<>) le indican al preprocesador que debe de mirar (secuencialmente) en los directorios listados dentro de la ruta include para el archivo.

Un nombre de archivo entrecomillado indica que el preprocesador deberóa buscar dentro del "directorio de archivos include" en primer lugar. Una ruta encomillada indica que el preprocesador debe revisar el directorio de la ruta primero. La información d ela ruta puede ser absoluta o relativa (al directorio del archivo donde se incluye). Si no se encuentra el archivo en la ubicación especificada, los directorios enlistados en la ruta include son rastreados en busca del archivo de cabecera.

Si existen versiones del archivo en más de un directorio dentro de la rute include, la búsqueda se detendrá tan pronto como la promera coincidencia del archivo sea encntrada. Si el archivo no se encuentra en ninguno de los directorios de la ruta de búsqueda, entonces el compilador reportará un error.

Para elementos en la Librería Estándar de C++, el compilador generalmente conoce en realidad donde encontrar los archivos de cabecera. Para otras librerías, podemos expandir la ruta de búsqueda añadiendo un parámetro -I/path/to/headerfile al compilador.

Si usas un IDE, habrá algún menú de configuración Proyecto->Configuración->Preprocesador o Proyecto->Opciones->Librerías que te permita especificar directorios include adicionales, estos seán pasados como parámetros -I hacia el compilador en el momento de la construcción.

Con qmake, como pronto veremos, puedes agregar líneas INCLUDEPATH += NombreDelDir al archivo de proyecto. Estos directorios terminarán en el Makefile generado como macros INCPATH, con esto serán pasados dentro del compilador/preprocesador en el momento de la construcción.

Consejo: Incluir cabeceras que no son de Qt

En general, es buena idea incluir (#include) archivos de cabecera que no sean Qt. Sinceramente Qt no define muchos símbolos dentro del compilador como dentro del procesador, esto te ayudará a evitar/encontrar clases más facilmente

<<- Anterior (Makefile, qmake y archivos de proyecto) -|- (Contenido) -|- (El comando make) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (#include: Encontrando archivos de cabecera) -|- (Contenido) -|- (Obteniendo ayuda en línea) Siguiente ->>

Versión para imprimir esta pagina

[editar] El comando make

En lugar de correr la línea de comando del compilador directamente, comenzaremos a usar make^[1] que simplifica enormemente el proceso de construcción cuando un proyecto involucra múltiples archivos fuente y librerías.

Hemos visto antes que qmake (sin argumentos) lee un archivo de proyecto y construye un Makefile. El Ejemplo 1.8 es una vista medianamente comentada de el Makefile generado por un simple proyecto llamado qapp.

[editar] Ejemplo 1.8

Ejemplo: Ejemplo 1.8 src/qapp/Makefile-abbreviated

# Extractos de un makefile

####### Compilador, herramientas y opciones

CC            = gcc     # ejecutable para el compilador C
CXX           = g++     # ejecutable  para el compilador C++
LINK          = g++     # ejecutable para el enlazador

# marcas para ser pasadas al compilador
CFLAGS        = -pipe -g -Wall -W -D_REENTRANT $(DEFINES)
CXXFLAGS      = -pipe -g -Wall -W -D_REENTRANT $(DEFINES)
INCPATH       = -I/usr/local/qt/mkspecs/default -I. \
                -I$(QT4)/include/QtGui -I$(QT4)/include/QtCore \
                -I$(QT4)/include

# marcas del enlazador
LIBS          = $(SUBLIBS) -L$(QT4)/lib -lQtCore_debug -lQtGui_debug -lpthread
LFLAGS        = -Wl,-rpath,$(QT4)/lib

# macros para realizar otras operaciones como parte de los pasos de construcción:
QMAKE         = /usr/local/qt/bin/qmake

####### Archivos

HEADERS       =    # Si tenemos alguno, debería estar aquí. 
SOURCES       = main.cpp
OBJECTS       = main.o
[snip]
QMAKE_TARGET  = qapp
DESTDIR       = 
TARGET        = qapp  # Objetivo por defecto para construir

first: all            # para consstruir "first" debemos construir "all"

####### Reglas Implícitas

.SUFFIXES: .c .o .cpp .cc .cxx .C

.cpp.o:
	$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

## Posibles objetivos para construir

all: Makefile $(TARGET)  # esto es como se construye "all"

$(TARGET):  $(OBJECTS) $(OBJMOC)    # esto es como se construye qapp
	$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(OBJCOMP) \
    $(LIBS)

        qmake:  FORCE               # ¡"qmake" es un objetivo también!  
	@$(QMAKE) -o Makefile qapp.pro  # ¿que hizo esto?

dist:                               # Otro objetivo 
	@mkdir -p .tmp/qapp \
    && $(COPY_FILE) --parents $(SOURCES) $(HEADERS) \ 
       $(FORMS) $(DIST) .tmp/qapp/ \ 
    &&  (cd `dirname .tmp/qapp` \ && $(TAR) qapp.tar qapp \ 
         && $(COMPRESS) qapp.tar) \ 
    && $(MOVE) `dirname .tmp/qapp`/qapp.tar.gz . \ 
    && $(DEL_FILE) -r .tmp/qapp

clean:compiler_clean                # otro objetivo más
	-$(DEL_FILE) $(OBJECTS)
	-$(DEL_FILE) *~ core *.core


####### Dependencias para reglas implícitas

main.o: main.cpp

Descargar ejemplo

El comando make revisa las dependencias y realiza cada paso de construcción del Makefile. El nombre y ubicación del resultado final puede ser establecido con las variables del proyecto TARGET y target.path. Si TARGET no es especificado, el nombre por defecto dado es el nombre del directorio en el que el archivo del proyecto se aloja. Si target.path no se especifica, la localización por defecto es el directorio en el que el proyecto se ubica.

[editar] Limpiando Archivos

make puede limpiar los archivos generados por tí por medio de dos objetivos, clean y distclean. Observa cómo ambos son distintos:

src/qapp> make clean
rm -f main.o
rm -f *~ core *.core
src/qapp> ls
 Makefile  main.cpp  qapp  qapp.pro

src/qapp> make distclean
rm -f qmake_image_collection.cpp
rm -f main.o
rm -f *~ core *.core
rm -f qapp
rm -f Makefile
src/qapp> ls
 main.cpp  qapp.pro

Después de un make distclean, los únicos archivos que restan son los de las fuentes que pueden ir dentro de una tarball para su distribución

Nota:

Si modificas un archivo de proyecto desde la última ejecución de make, la siguiente invocación de make debería reconstruir el Makefile mismo (por medio de qmake) antes de volver a correr make sobre el nuevo Makefile generado.

En otras palabras, el Makefile es sencible a qmake y puede rehacerse a si mismo.

Consejo: make dist

El comando make dist creará un tarball (nombre_del_directorio.tar.gz) que contenga todos los archivos fuente sobre los que el proyecto tenga conocimiento.

Así como nosotros agregamos más codigo fuente, cabeceras o módulos de librerías para nuestro proyecto, editamos el archivo .pro y añadimos los nuevos elementos a las listas SOURCES, HEADERS, y LIBS. La misma documentación standard que aplica también para el código fuente de C++ debería ser aplicada a los archivos de proyecto (con los comentarios comenzando con #).

Pensemos en el archivo de proyecto como un mapa de nuestro proyecto, conteniendo referencias para todos los archivos y localizaciones requeridas para construir nuestra aplicación o librería. Como otros archivos fuente, este es tanto leible por humanos como por la máquina. El archivo .pro es el primer lugar para mirar cuando encontramos mensajes not found o undefined durante el proceso de construcción (especialmente en el momento del enlace). Para más detalles recomendamos que leas la Guía para qmake de Trolltech.

<<- Anterior (#include: Encontrando archivos de cabecera) -|- (Contenido) -|- (Obteniendo ayuda en línea) Siguiente ->>

Versión para imprimir esta pagina

↑ Dependiendo de tu entorno de desarrollo, este programa puede tener algúnos otros nombres como mingw32-make, nmake, gmake, o unsermake.

<<- Anterior (El comando make) -|- (Contenido) -|- (Cadenas) Siguiente ->>

Versión para imprimir esta pagina

[editar] Obteniendo ayuda en línea

En adición a la Documentacion en Línea de Trolltech, que incluye enlaces a documentos de APIs así como a FAQs, aquí hay muchos otros recursos online dispinibles para tí:

La Lista de Correos de Interesados en Qt proporciona una comunidad de desarrollo y archivos buscables. Buscando sobre una clase que están intentando usar, o un mensaje de error que no entientes, obtendrás resultados muy útiles.
QtCentre, una comunidad en línea basada en Web
Si esto no está directamente relacionado a Qt, y el mensaje de error es corto y muy raro, Google podría brindarte pistas importantes.
También hay un canal irc #qt en irc.freenode.net.

<<- Anterior (El comando make) -|- (Contenido) -|- (Cadenas) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Obteniendo ayuda en línea) -|- (Contenido) -|- (Flujos) Siguiente ->>

Versión para imprimir esta pagina

[editar] Cadenas

Cuando trabajamos con cadenas en Qt, tenemor tres opciones:

const char*, o cadenas al estilo C, son usadas principalmente cuando estamos interpasando con librerías de C, y raramente de otra forma.
string, desde STL, que está disponible en cualquier parte
QString es preferido por encima de las cadenas STL, porque es mucho más fácil de usar. Soporta encritura en copia perezosa (lo que significa que las funciones pueden retornar Qstring por valor sin alojar y copiar la cadena entera), y estas tienen soporte unicode integrado, para una fácil internacionalización.

[editar] Ejemplo 1.9

Ejemplo: Ejemplo 1.9 Demostración básica de cadenas STL

src/generic/stlstringdemo.cpp

s1 += s2; Concatenación

#include <string>
#include <iostream>

int main() {
   using namespace std;
   string s1("Esta "), s2("es una "), s3("cadena.");
   s1 += s2;
   string s4 = s1 + s3;
   cout << s4 << endl;

   string s5("La longitud esta cadena es: ");
   cout << s5 << s4.length() << " caracteres." << endl;

   cout << "Ingresa una sentencia: " << endl;
   getline(cin, s2);
   cout << "Aquí esta tu sentencia: \n" << s2 << endl;
   cout << "El tamaño de esta fue de: " << s2.length() << endl;
   return 0;
}

Descargar ejemplo

Veamoslo compilado y corriendo:

src/generic> g++ -ansi -pedantic -Wall stlstringdemo.cpp 
src/generic> ./a.out
 Esta es una cadena.
 La longitud de la cadena es: 19 caracteres.
 Ingresa una sentencia:
 20 años de trabajo duro
 Aquí está tu sentencia:
 20 años de trabajo duro
 El tamaño de esta fue de: 23
src/generic>

Observa que usamos la función getline(istream, string) para tomar una cadena desde un flujo de entrada estándar. El mismo ejemplo, reescrito para usar Qt en lugar de STL es mostrado en el Ejemplo 1.10.

[editar] Ejemplo 1.10

Ejemplo: Ejemplo 1.10 src/early-examples/qstring/qstringdemo.cpp

.arg(s4).arg(s4.length()); Parametrización del argumento

#include <QString>
#include <QTextStream>

int main() {
   QTextStream cout(stdout);
   QTextStream cin(stdin);

   QString s1("Esto "), s2("es una "), s3("cadena.");
   s1 += s2;  
   QString s4 = s1 + s3;
   cout << s4 << endl;

   QString s5 = QString("El tamaño de '%1' es: %2 caracteres.")
       .arg(s4).arg(s4.length());
   cout << s5 << endl;

   cout << "Ingresa una sentencia: " << endl;
   s2 = cin.readLine();
   cout << "Aquí esta tu sentencia: \n" << s2 << endl;
   cout << "El tamaño de esta fue: " << s2.length() << endl;
   return 0;
}

Descargar ejemplo

<<- Anterior (Obteniendo ayuda en línea) -|- (Contenido) -|- (Flujos) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Cadenas) -|- (Contenido) -|- (Ejercicios: Flujos) Siguiente ->>

Versión para imprimir esta pagina

[editar] Flujos

Los flujos(Streams) son objetos usados para leer y escribir. La Librería Estándar define <iostream>, mientras que Qt define <QTextStream> para la funcionalidad equivalente.

iostream define los tres flujos globales:

cin - entrada estándar (teclado)
cout - salida estándar (pantalla de consola)
cerr - error estándar (pantalla de consola)

Es fácil relacionar a QTextStreams con los mismos nombres como sus contrapartes iostream equivalentes.

QTextStream cin(stdin);
QTextStream cout(stdout);
QTextStream cerr(stderr);

Los símbolos stdin, stdout, y stderr provienen de la librerñia estándar de C. QDebug() es también un flujo con una interface similar.

Los manipuladores tambien están definidos (en ambos, <iostream> y <QTextStream>), como flush y endl. Los manipuladores son llamadas explícitas a funciones que pueden cambiar el estado de un objeto de flujo en varias maneras. Un manipulador puede ser añadido para:

Un flujo de salida para cambiar la forma en que el dato de salida es formateado.
Un flujo de entrada para cambiar la manera en que el dato de entrada es interpretado.

[editar] Ejemplo 1.11

Ejemplo: Ejemplo 1.11 src/stdstreams/streamdemo.cpp Demostración del uso de manipuladores aplicados al flujo de salida estándar

Salida:

4451 929 2345 1 true 1357 +1357 +1357.00 +1234.57 +1234.567800 +1.234568e+03 1.234568e+03

#include <iostream>

int main() {
   using namespace std;
   int num1(1234), num2(2345) ;
   cout << oct << num2 << '\t'
           << hex << num2 << '\t'
            << dec << num2 
            << endl;
   cout << (num1 < num2) << endl;
   cout << boolalpha
            << (num1 < num2)
            << endl;
   double dub(1357);
   cout << dub << '\t'
           << showpos << dub << '\t'
           << showpoint << dub 
           << endl;
   dub = 1234.5678;
   cout << dub << '\t'
           << fixed << dub << '\t'
           << scientific << dub << '\n'
           << noshowpos << dub 
           << endl;
}

Descargar ejemplo

Los flujos son usados para leer desde o escribir en archivos, conexiones de red y también cadenas. Una muy útil característica de los flujos es que ellos pueden hacer que sea secillo producir cadenas desde tipos de datos mixtos. En el Ejemplo 1.12 crearemos algunas cadenas desde numéricos y los escribiremos en un archivo.

[editar] Ejemplo 1.12

Ejemplo: Ejemplo 1.12. src/stl/streams/streams.cpp

string strval = strbuf.str(); Convierte el flujo de carácteres en una cadena.

outf.open("midato"); Crea (o sobreescribe) un archivo del disco para la salida.

[ . . . . ]

#include <iostream>
#include <sstream>
#include <fstream>

int main() {
   using namespace std;
   ostringstream strbuf;

   int loco = 7;
   float pi=3.14;
   double e=2.71;
   
   /* Un flujo dentro de la memoria */
   strbuf << "número loco " << loco << endl
          << "pi " << pi << endl
          << "e " << e << endl;

   string strval = strbuf.str();
   cout << strval;

   /* Un flujo de archivo de salida. */
   ofstream outf; 
   outf.open("midato");   
   outf << strval ;   
   outf.close();

Descargar ejemplo

Despues de que las cadenas han sido escritas, tenemos una variedad de opciones sobre como queremos leerlos. Podemos usar los operadores de entrada analógica con los que escribimos en nuestra salida, y dado que hay un espacio en blanco entre cada registro, el operador de inserción debería verse como en el Ejemplo 1.13

[editar] Ejemplo 1.13

Ejemplo: Ejemplo 1.13 src/stl/streams/streams.cpp

[ . . . . ]

   /* Un flujo de entrada de archivo */
   ifstream archivoentrada;   
   archivoentrada.open("midato"); 
   string nuevacadena;  
   int loco2;
   archivoentrada >> nuevacadena >> loco2;
   if (loco != lloco2)
       cerr << "¡ERROR! número loco incorrecto" << endl;
   
   float pi2;
   archivoentrada >> nuevacadena >> pi2;
   if (pi2 != pi) cerr << "¡ERROR! pi incorrecto." << endl;
   
   double e2;
   archivoentrada >> nuevacadena >> e2;
   if (e2 != e) cerr << "e2: " << e2 << " e: " << e << endl;
   archivoentrada.close();

Descargar ejemplo

En adición, podemos leer archivos línea por línea tratando a cada nueva línea como una cadena, justo como se muestra en el Ejemplo 1.14

[editar] Ejemplo 1.14

Ejemplo: Ejemplo 1.14 src/stl/streams/streams.cpp

[ . . . . ]

   /* Leer línea por línea */
   archivoentrada.open("midato");
   while (not archivoentrada.eof()) {
       getline(archivoentrada, nuevacadena);
       cout << nuevacadena << endl;
   }
   archivoentrada.close();
   return 0;
}

Descargar ejemplo

<<- Anterior (Cadenas) -|- (Contenido) -|- (Ejercicios: Flujos) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Flujos) -|- (Contenido) -|- (Identificadores, Tipos y Literales) Siguiente ->>

Versión para imprimir esta pagina

[editar] Ejercicios: Flujos

Modiffica el programa del Ejemplo 1.12 de manera que haga lo siguiente:

Que este obtenga el nombre del archivo desde el usuario con una cadena STL NombreArchivo. Necesitaras usar la función fileName.c_str() para convertir la cadena a una forma que sea aceptable para la función open().

Que se asegure de que el archivo existe antes de intentar leerlo. (Pista: Después de la llamada para abrir puedes comprobar la variable ifstream como si esta fuera un booleano, falso significa que el archivo no existe.)

Que se asegure de que el archivo especificado por el usuario no exista en realidad (o que este está dispuesto a sobreescribir si existe) antes de abrirlo para salida.

<<- Anterior (Flujos) -|- (Contenido) -|- (Identificadores, Tipos y Literales) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Ejercicios: Flujos) -|- (Contenido) -|- (Ejercicios: Identificadores, Tipos y Literales) Siguiente ->>

Versión para imprimir esta pagina

[editar] Identificadores, Tipos y Literales

Los identificadores son nombres que son usados dentro de programas C++ para funciones, parámetros. variables, constantes, clases y tipos.

Un identificador consiste en una secuencia de letras, dígitos y guiones que no comiencen con un dígito. Un identificador no puede ser una palabra reservada. En el Apéndice A verás una lista de estos. El estándar no especifica un límite de tamaño para un identificador, pero ciertas implementaciones de C++ solo examinan los primeros 31 caracteres para diferenciar los identificadores.

Una literal es un valor constante que aparece en cualquier lugar dentro del programa. Debido a que cada valor tiene un tipo, cada literal tiene un tipo también. Esto hace posible el tener literales para cada tipo de datos nativo, y también literales de cadenas de caracteres. La Tabla 1.1 muestra algunos ejemplos de literales y sus tipos.

[editar] Tabla 1.1

Tabla 1.1 Ejemplos de Literales
Literal	Significado
5	una literal int
5u	u o U especifica int sin signo
5L	l o L especifica long int despues de un integer
05	una literal int octal
0x5	una literal int hexadecimal
true	una literal boleana
5.0F	f o F especifica una literal de punto flotante de presición simple
5.0	una literal de punto flotante de doble presición
5.0L	l o L especifica long double si este viene despues de un punto flotante
'5'	una literal char (ASCII 53)
“50”	una constante char* conteniendo los carácteres 5 0 y \0
“cualquier” “cosa”	“cualquiercosa”
'\a'	alerta
'\\'	backslash
'\b'	retroceso
'\r'	retorno de carro
'\	comilla simple
'\“'	comilla doble
'\f'	formfeed (nueva página)
'\t'	tabulación
'\n'	literal char de nueva línea
“\n”	nueva línea seguida por un terminador 'null (const char*)
'\0'	caracter null
'\v'	tabulación vertical
“una cadena con nueva línea\n”	otro const char*

Las literales de cadena son especiales en C++, debido a sus raices históricas en el lenguaje C. El Ejemplo 1.15 muestra como ciertos caracteres necesitan ser escapados dentro de los delimitadores de cadena de comilla doble:

[editar] Ejemplo 1.15

Ejemplo: Ejemplo 1.15 src/early-examples/literals/qliterals.cpp

QString str = charstr; cadenas al estilo C pueden ser convertidas a QString

#include <QTextStream>
#include <QString>

int main() {
    const char* charstr = "Esta es una cadena muy larga "
                " por eso continuaré en la siguiente línea";
    QTextStream cout(stdout);  
    QString str = charstr;
    cout << str << endl;
    cout << "\nA\tb\\c\'d\"" << endl;
    return 0;
}

Descargar ejemplo

Compilaremos y correremos de la forma en que describimos antes:

src/early-examples/literals> qmake -project
src/early-examples/literals> qmake
src/early-examples/literals> make
g++ -c -pipe -O2 -Wall -W -D_REENTRANT -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED -I/usr/share/qt4/mkspecs/linux-g++ -I. -I/usr/include /qt4/QtCore -I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. -o qliterals.o qliterals.cpp
g++  -o literals qliterals.o    -L/usr/lib -lQtGui -lQtCore -lpthread
src/early-examples/literals> ./literals

La salida debería lucir algo parecido a esto:

Esta es una cadena muy larga por eso continuaré en la siguiente línea

A       b\c'd"

Nota que este programa muestra la forma de evitar líneas demasiado largas cuando trabajamos con literales de cadena. Estas pueden ser rotas en cualquier carácter de espacio en blanco y son concatenadas automáticamente usando esta sintaxis.

<<- Anterior (Ejercicios: Flujos) -|- (Contenido) -|- (Ejercicios: Identificadores, Tipos y Literales) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Identificadores, Tipos y Literales) -|- (Contenido) -|- (Tipos Simples de C++) Siguiente ->>

Versión para imprimir esta pagina

[editar] Ejercicios: Identificadores, Tipos y Literales

Modifica el el Ejemplo 1.5 para que, con una simple sentencia de salida, la salida se convierta en:

1.-

GNU, siglas para "GNU's Not UNIX".

2.-

Título 1         "Gato Tejiendo"
Título 2         "Perro Danzando"

<<- Anterior (Identificadores, Tipos y Literales) -|- (Contenido) -|- (Tipos Simples de C++) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Ejercicios: Identificadores, Tipos y Literales) -|- (Contenido) -|- (main y Argumentos de Línea de Comandos) Siguiente ->>

Versión para imprimir esta pagina

[editar] Tipos Simples de C++

Los tipos simples soportados en C/C++ están listados en la Tabla 1.2.

C/C++ también proporciona un símbolo especial que significa la ausencia de información de tipo: void.

Los tipos simpres de C++ pueden (en su mayoría) ser modificados por las siguientes palabras clave que producen otros tipos simples:

short
long
signed
unsigned^[1]

[editar] Tabla 1.2

Tabla 1.2. Jerarquía de los Tipos Simples
Tipos byte/char	Tipos de integrales	Tipos de punto flotante
bool	short int	float
char	unsigned short	double
signed char	int	long double
unsigned char	unsigned int
wchar_t	nyType*
	long int
	unsigned long

Los compiladores de C++ te permiten omitir int desde short int, long int, y unsigned int. Puedes omitir signed desde la mayoría de los tipos, pues está por defecto.

De el rango de valores para las dependencias de tipo en particular sobre la arquitectura subrayada o la maquina en la que el compilador está corriendo, el estándar ANSI/ISO para C++ no especifica la medida (en bytes) de ninguno de estos tipos. Este solo garantiza que un tipo dado (p.e., int) no debería ser mas pequeño que uno de los que aparece sobre él (p.e., short) en la Tabla 1.2.

Existe un operador especial sizeof() que devuelve el número de caracteres^[2] que una expresión dada requiere para el almacenamiento. A diferencia d ela mayoría de las funciones, el operador sizeof() puede tomar expresiones de valor o expresiones de tipo. El Ejemplo 1.16 muestra como puede ser usado sizeof() y algunos d elos valores que este retorna en un sistema x86 de 32-bits.

[editar] Ejemplo 1.16

Ejemplo: Ejemplo 1.16 src/early-examples/size/qsize.cpp

char *charp = array1; El puntero al primer elemento del array.
cout << "sizeof qint32 = " << sizeof (qint32) << "\n"; Garantizado para ser en todas las plataformas de 32 bits.
cout << "sizeof qint64 = " << sizeof(qint64) << '\n'; Garantizado para ser en todas las plataformas de 64 bits.
cout << "sizeof qchar = " << sizeof (QChar) << endl;' Dos veces tan grande como un caracter.
cout << "qstring.length = " << qstring.length() << endl; Para # de bytes, nos aseguramos de tomar en cuenta la medida de QChar

#include <QString>
#include <QTextStream>
#include <QChar>

int main(int argc, char* argv[]) {
   QTextStream cout(stdout);
   int i=0;
   char array1[34] = "Este es un temible arrar C de caracteres";
   char array2[] = "si no está para main, podríamos vaciarlo por completo.";
   char *charp = array1;
   QString qstring = "Esta es una cadena QString unicode. La más preferida." ;
   Q_ASSERT (sizeof(i) == sizeof(int));
   cout << "  Medidas de tipos C: \n";
   cout << "Tamaño de char = " << sizeof(char) << '\n';
   cout << "Tamaño de wchar_t = " << sizeof(wchar_t) << '\n';
   cout << "Tamaño de int = " << sizeof(int) << '\n';
   cout << "Tamaño de long = " << sizeof(long) << '\n';
   cout << "Tamaño de float = " << sizeof(float) << '\n';
   cout << "Tamaño de double = " << sizeof(double) << '\n';
   cout << "Tamaño de double* = " << sizeof(double*) << '\n';
   cout << "Tamaño de array1 = " << sizeof(array1) << '\n';
   cout << "Tamaño de array2 = " << sizeof(array2) << '\n';
   cout << "Tamaño de char* = " << sizeof(charp) << endl;
   cout << "  Medidas de tipos Qt: \n";  
   cout << "Tamaño de qstring = " << sizeof(qstring) << endl;
   cout << "Tamaño de qint32 = " << sizeof (qint32) << "\n";
   cout << "Tamaño de qint64 = " << sizeof(qint64) << '\n';
   cout << "Tamaño de qchar = " << sizeof (QChar) << endl;'
   cout << "qstring.length = " << qstring.length() << endl;
   return 0;
}

Salida:

 Medidas de tipos C: 
Tamaño de char = 1 
Tamaño de wchar_t = 4 
Tamaño de int = 4 
Tamaño de long = 4 
Tamaño de float = 4 
Tamaño de double = 8 
Tamaño de double* = 4 
Tamaño de array1 = 34 
Tamaño de array2 = 45 
Tamaño de char* = 4 
 Medidas de tipos Qt: 
Tamaño de qstring = 4 
Tamaño de qint32 = 4 
Tamaño de qint64 = 8 
Tamaño de qchar = 2 
qstring.length = 42

Descargar ejemplo

Nota quye todos los punteros son de la misma medida, independientemente de su tipo.

En la salida, podemos ver que sizeof(qstring) tiene solo 4 bytes, pero es una clase compleja que utiliza memoria dinámica, entonces podemos llamar a length() para obtener el número de caracteres usado para almacenar la cadena. Bajo la cubierta, QString comparte memoria con otras cadenas que tienen el mismo valor, por ello, después de una copia, la memoria dinámica no permanece exclusivamente para un objeto QString.

Los rangos de valores para los tipos integrales (bool, char, int) son definidos en el archivo de cabecera estándar limits.h. Dentro de una instalación típica de *nix este archivo puede ser encontrado en un subdirectorio de /usr/include.

<<- Anterior (Ejercicios: Identificadores, Tipos y Literales) -|- (Contenido) -|- (main y Argumentos de Línea de Comandos) Siguiente ->>

Versión para imprimir esta pagina

↑ Para una mayor discusión sobre las diferencias entre tipos integrales con signo y sin signo, revisa la Sección 18.4.
↑ en la mayoría de los sistemas, un caracter simple es un byte

<<- Anterior (Tipos Simples de C++) -|- (Contenido) -|- (Aritmética) Siguiente ->>

Versión para imprimir esta pagina

[editar] main y Argumentos de Línea de Comandos

main() es una función (Capítulo 5) que es llamada al inicio delprograma. Si el programa acepta argumentos de línea de comandos, debemos definir main con su lista de parámetros completa.

C permite flexibilidad en la forma en como los argumentos son definidos dentro de main(), por ello podrás ver que está definido en na variedad de formas:

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

Todas las formas de arriba son válidas, y todas ellas definen dos parámetros. Esos parámetros contienen información perteneciente a la reconstrucción de los argumentos de la línea de comandos pasados dentro del programa desde el proceso padre (una consola de línea de comandos, un administrador de ventanas, etc.) El Ejemplo 1.17 es un programa main simple que imprime sus arcumentos de línea de comando.

[editar] Ejemplo 1.17

Ejemplo: Ejemplo 1.17 src/main/clargs/clargs.cpp

#include <QTextStream>

int main (int argCount, char* argValue[]) {
   QTextStream cout(stdout);
    
   for (int i=0; i<argCount; ++i) {
       cout << "argv# " << i << " es " << argValue[i] << endl;
   }
   return 0; 
}

Descargar ejemplo

argValue, o argv para resumir, es un array bidimensional (Sección 21.4) de cadena. argCount, o argc para resumir, es el número de arreglos de caracter dentro de argv. argv contiene cada cadena de línea de comando como un ítem dentro de su array.

int main() “devuelve” un entero, que debería ser 0 si todo ha ido bien, o un código de error distinto de cero si algo salió mal.

Nota:

Trata de no confundir esta interpretación de 0 con el valor boleano falso, que también es igual a 0

Si corremos este programa con argumentos de línea de comandos, veremos algo como esto en la salida:

clargs>./clargs spam huevos "guerras espaciales" 123
argv# 0 es /home/ezust/src/main/clargs/clargs
argv# 1 es spam
argv# 2 es huevos
argv# 3 es guerras espaciales
argv# 4 es 123

El primer argumento es el nombre de la ruta del ejecutable, Los otros argumentos son tomados desde la línea de comandos como cadenas separadas por espacios o tabulaciones. Para pasar una cadena que contenga espacios en un argumento simple, debes encerrar la cadena entre comillas.

<<- Anterior (Tipos Simples de C++) -|- (Contenido) -|- (Aritmética) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (main y Argumentos de Línea de Comandos) -|- (Contenido) -|- (Ejercicios: Tipos Simples de C++) Siguiente ->>

Versión para imprimir esta pagina

[editar] Aritmética

Cada lenguaje de programación debe proveer facilidades para realizar aritmética básica. Para cada uno de estos tipos numéricos, C++ proporciona estos cuatro operadores aritméticos básicos:

adición (+)
subtracción (-)
multiplicación (*)
división (/)

Estos simbolos de operadores son usados para formar expresiones en la sintaxis infis estándar que aprendimos en las clases de matemáticas.

C++ proporciona operadores de atajo que combinan cada uno de los operadores básicos con el operador de asignación mismo (=), por ejemplo, es posible escribir:

x += y;

en lugar de;

x = x + y;

C++ también proporciona operadores de incremento unario (++) y de decremento (--) que pueden ser usados con tipos integrales. Si uno de esos operadores es aplicado a la izquierda de una variable (prefijo), entonces el operador es realizado después de que el resto de expresiones es evaluado. Si se aplica a una varable a la drerecha (posfijo), entonces la operación se realiza despues de que el resto de expresiones es evaluado. Compiladores optimizados pueden además ejecutar los operadores de incremento de prefijo en un menor número de operaciones, pues están recomendados por encima de la versión postfix. El Ejemplo 1.18 así como el Ejemplo 1.22 demuestran el uso de operadores aritméticos de C++.

[editar] Ejemplo 1.18

Ejemplo: Ejemplo 1.18 src/arithmetic/arithmetic.cpp

[ . . . . ]

#include <iostream>

int main() {
   using namespace std;
   double x(1.23), y(4.56), z(7.89) ;
   int i(2), j(5), k(7);
   x += y ;
   z *= x ;
   cout << "x = " << x << "\tz = " << z
           << "\nx - z = " << x - z << endl ;

Descargar ejemplo

La división de enteros es manejada como un caso especial. El resultado de dividir un int con otro produce un int cociente y un int residuo. El operador / es usado para obtener el cociente. El operador % (llamado operador modulus) es usado para obtener el residuo. El Ejemplo 1.19 muestra el uso de esos operadores aritméticos de enteros.

[editar] Ejemplo 1.19

Ejemplo: Ejemplo 1.19 src/arithmetic/arithmetic.cpp

[ . . . . ]

   cout << "k / i = " << k / i 
           << "\tk % j = " << k % j << endl ;
   cout << "i = " << i << "\tj = " << j << "\tk = " << k << endl;
   cout << "++k / i = " << ++k / i << endl;
   cout << "i = " << i << "\tj = " << j << "\tk = " << k << endl;
   cout << "i * j-- = " << i * j-- << endl;
   cout << "i = " << i << "\tj = " << j << "\tk = " << k << endl;

Descargar ejemplo

Las expresiones mixtas, si son válidas, generalmente producen resultados de los más largos de los tipos de argumentos. El Ejemplo 1.20 muestra que el resultado de dividir un double entre un int es un double.

[editar] Ejemplo 1.20

Ejemplo: Ejemplo 1.20 src/arithmetic/arithmetic.cpp

[ . . . . ]

   cout << "z / j = " << z / j << endl ;

Descargar ejemplo

Las conversiones serán discutidas más adelante en el Capítulo 18.

C++ también proporciona un juego completo de operadores boleanos para comparar expresiones numéricas. Casa uno de esos operadores retorna un valor boleano que puede ser false o true.

Menor que (<)
Menor o igual que (<=)
Igual que (==)
Diferente que (!=)
Mayor que (>)
Mayor o Igual que (>=)

Una expresión boleana puede ser negada con el operador unario de negación (!). Dos expresiones boleanas pueden ser combinadas con los operadores:

y (&&)
o (||)

[editar] Ejemplo 1.21

Ejemplo: Ejemplo 1.21 src/arithmetic/arithmetic.cpp

[ . . . . ]

   /*   Enfoque if () ... else   */
   if (x * j <= z)
       cout << x * j << " <= " << z << endl ;
   else
       cout << x * j << " > " << z << endl;
   /* enfoque de operador condicional */
   cout << x * k
           <<( (x * k < y * j) ? " < " : " >= ")
           << y * j << endl;
   return EXIT_SUCCESS;
}

Descargar ejemplo

En adición a los operadores boleanos binarios, el Ejemplo 1.21 hace uso de la expresión condicional. Esto:

(boolExpr) ? expr1 : expr2

devuelve expr1 si boolExpr es true, y de lo contrario devuelve expr2. El Ejemplo 1.22 muestra la salida del ejemplo.

[editar] Ejemplo 1.22

Ejemplo: Ejemplo 1.22 src/arithmetic/arithmetic.cpp

[ . . . . ]
Salida:
 x = 5.79    
 z = 45.6831 
 x - z = -39.8931 
 k / i = 3 
 k % j = 2 
 i = 2 
 j = 5 
 k = 7 
 ++k / i = 4 
 i = 2 
 j = 5 
 k = 8 
 i * j-- = 10 
 i = 2 
 j = 4 
 k = 8 
 z / j = 11.4208 
 23.16 <= 45.6831 
 46.32 >= 18.24

Descargar ejemplo

<<- Anterior (main y Argumentos de Línea de Comandos) -|- (Contenido) -|- (Ejercicios: Tipos Simples de C++) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Aritmética) -|- (Contenido) -|- (La Palabra Clave const) Siguiente ->>

Versión para imprimir esta pagina

[editar] Ejercicios: Tipos Simples de C++

1. Escribe un programa corto que pida al usuario que ingrese un valor Celsius, y entonces produzca un resultado en Fahrenheit. Este deberá usar QInputDialog para obtener el valor del usuario, y QMessageBox para producir el resultado. Después de esto, debe de imprimir una tabla de valores celsius a fahrenheit desde 0 hasta 100 con incrementos de 5 por la salida estándar.

2. si agregas #include <cstdlib>, puedes hacer uso de la función rand(), esta genera una secuencia de enteros long pseudoaleatorios, en el rango de 0 a RAND_MAX, esto puede ser usado en muchas formas interesantes. Trabaja calculando el siguiente número en su secuencia desde el último número que fue generado. La función srand(unsigned int seed) establece su argumento como el valor de inicialización (seed) para la secuencia aleatoria. Escribe un programa corto que pruebe esta función permitiendo al usuario a proporcionar la semilla desde el teclado y entonces generar una lista de números pseudoaleatorios.

3. Un truco de esto es usar srand(time(0)) para sembrar la función rand(). Debido a que time(0) devuelve el número de segundos desde algún punto inicial, la semilla será diferente cada vez que corras el programa. Esto te permitirá escribir programas que hagan uso exaustivo de patrones de comportamiento impredecibles. Escribe un programa que simule un juego de dados que el usuario pueda jugar con la computadora. Aquí están las reglas para aplicar a tu juego:

El juego es sobre repetir tiradas de un par de dados.
Cada dado tiene seis caras, numeradas desde 1 hasta 6.
El resultado de la tirada debe ser un número que sea el total de las dós caras superiores.
La primera tirada establece el numero del jugador.
Si ese número es 7 u 11 el jugador automáticamente gana.
Si ese número es 2, el jugador pierde automáticamente.
De lo contrario, el jugador sigue tirando hasta que la computadora gane (comparando sus números con los de ella) o pierda (tirando un 7 o un 11).

4. Escribe un programa que acepte dos valores desde el usuario (cliente): el monto total de la compra y el monto recibido como pago.

Cada uno de esos valores puede ser almacenado en una variable del tipo double. Calcula y muestra el cambio que será devuelto al usuario. Expresa el cambio en términos de números de billetes de $100, billetes de $50, billetes de $20, monedas de $10, monedas de $5, monedas de $2, monedas de $1, monedas de 50ç, monedas de 20ç, monedas de 10ç, monedas de 5ç (Presumiblemente, esta salida debería ser enviada a la máquina que dispensa estos elementos automáticamente).

Por ejemplo, si el total del monto de compra es $73.82 y el cliente paga con un billete de $100 entonces el cambio debería de ser: un billete de $20, una moneda de $5, una moneda de $1, una moneda de 10ç y una moneda de 5ç.

Consejo:

Convierte el monto que es obtenido del cliente a fracciones de 5ç, que puede ser almacenado dentro de un int. Usa los operadores de división de enteros.

<<- Anterior (Aritmética) -|- (Contenido) -|- (La Palabra Clave const) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Ejercicios: Tipos Simples de C++) -|- (Contenido) -|- (Punteros y acceso de memoria) Siguiente ->>

Versión para imprimir esta pagina

[editar] 1.15 La Palabra Clave const

Declarar una entidad para ser const le dice al compilador que lo haga de "solo-lectura". const puede ser usado en muchos contextos, como veremos a continuación.

Debido a que no puede ser asignado también, un objeto const debe ser inicializado apropiadamente. Por ejemplo:

const int x = 33;
const int v[] = {3, 6, x, 2 * x};   // un arreglo const

Trabajando con las declaraciones anteriores:

++x ;           // error
v[2] = 44;      // error

Los compiladores pueden tomar ventaja de un objeto que comienza como solo-lectura en varias maneras. Para enteros y algunos tipos simples, no es necesario el almacenamiento para ser alojados por un const a menos que su dirección sea dada. Por lo tanto, la mayoría de los compiladores trata de alojarlo en memoria estática.

Es un buen estilo de programación el usar entidades const en lugar de embeber expresiones constantes (algunas veces llamados números mágicos) en tu código. Esto te hará ganar flexibilidad más tarde cuando necesites cambiar los valores. En general, aislar constantes mejorará el mantenimiento de tus programas. Por ejemplo, en lugar de algo como esto:

for(i = 0; i < 327; ++i) {
  ...
}

Utiliza algo como esto:

// sección de declaración de const en tu código
const int MEDIDA = 327;
...
for(i = 0; i < MEDIDA; ++i) {
   ...
}

Nota:

En algunos programas de C/C++, deberías de ver constantes definidas como macros de preprocesador como este:

#define STRSIZE 80
[...]
char str[STRSIZE];

Los magros de preprocesador son reemplazados después de que el compilador los ve. Usar macros en lugar de constantes significa que el compilador no puede mejorar el mismo nivel de tipo revisando como este puede proporcionar expresiones constantes. Generalmente las expresiones const se prefieren en lugar de las macros para definir valores constantes dentro de programas c++.

<<- Anterior (Ejercicios: Tipos Simples de C++) -|- (Contenido) -|- (Punteros y acceso de memoria) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (La Palabra Clave const) -|- (Contenido) -|- (Introducción a Patrones de Diseño en C++ con Qt4/print) Siguiente ->>

Versión para imprimir esta pagina

[editar] 1.16. Punteros y acceso de memoria

C y C++ se distinguen a sí mismos de otros lenguajes por permitir acceder directamente a la memoria a través del uso de punteros. Esta sección explica las operaciones de puntero básicas y modificadores, e introduce al uso de la memoria dinámica. Los punteros pueden parecer complicados al principio. Discutimos el buen y mal uso de punteros con más detalle en el Capítulo 21.

<<- Anterior (La Palabra Clave const) -|- (Contenido) -|- (Introducción a Patrones de Diseño en C++ con Qt4/print) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Punteros y acceso de memoria) -|- (Contenido) -|- (Operadores new y delete) Siguiente ->>

Versión para imprimir esta pagina

[editar] 1.16.1. Los operadores unarios & y *

Una variable es un objeto con un nombre reconocido por el compilador. Un nombre de variable puede ser usado si este es el objeto en sí mismo. Por ejemplo, si decimos:

   int  x  =  5;

Podemos usar x para mantener el objeto integer cuyo valor es 5, y podemos manipular el objeto integer directaente a través del nombre x. Por ejemplo:

++x ;  // el símbolo x ahora se refiere a un entero con valor 6;

Un objeto (en el sentido más general) es un pedazo de memoria, el cual puede almacenar datos. Cada objeto tiene una dirección de memoria (donde los datos comienzan). El operador unario &, también conocido como el operador dirección-de, cuando es aplicado a cualquier objeto, retorna la dirección de memoria de ese objeto. Por ejemplo: &x devuelve la dirección de memoria de x.

Un objeto que almacena la dirección d ememoria de otro objeto es llamado puntero. Decimos que el puntero apunta al objeto que almacenó la dirección d ememoria.

  int*  y  =  &x ;

En este ejemplo, y apunta al entero x. El asterísco (*) que le sigue a int indica que y es un puntero a int.

Aquí hemos inicializado el puntero int y a la dirección de la variable int x. Una de las características más poderosas de los punteros es esa, se sujetan a las reglas que exploraremos en breve, aquí es posible para un puntero de un tipo almacenar la dirección de un objeto de tipo diferente (pero relacionado).

Cero (0), también representado por la macro NULL en programas C, es un valor especial que puede ser asignado legalmente a un puntero, usualmente cuando este comienza a ser inicializado (o reinicializado). 0 no es la dirección de ningún objeto. Un puntero que almacena el valor 0 es llamado puntero nulo. often represented by the macro NULL in C programs, is a special value that can be legally assigned to a pointer, usually when it is being initialized (or re-initialized). 0 is not the address of any object. A pointer that stores the value 0 is called a null pointer. Stroustrup recomienda el uso de 0 más que el de la macro NULL en programas C++.

Un puntero a un tipo simple usa exáctamente la mísma cantidad de memoria que el puntero a un gran objeto complicado. Esta medida es usualmente la misma que sizeof(int) en esa máquina.

El operador unario *, también conocido como el operador desreferenciado, cuando se aplica a un operador no-nulo. devuelve el objeto que la dirección almacenó por el puntero.

Nota:

El símbolo * es usado en dós formas diferentes en una conexión con punteros:

Puede servir como un tipo de modificador, en un puntero de definición variable
puede ser usado como el operador de desreferencia.

Nota:

Desreferenciar un puntero nulo o no inicializado causa un error en tiempo de ejecución, usualmente un fallo de segmentación o, en windows, un fallo de protección general (GPF). Es responsabilidad del programador asegurarse de que no se intenta hacer referencia a un puntero nulo o no inicializado. Discutiremos técnicas para asegurarnos de que esos errores sean evitados

[editar] Ejemplo 1.23

Ejemplo: Ejemplo 1.23. src/pointers/pointerdemo.cpp

int* px = 0 ; Modificcador de tipo

<< " *px = " << *px Operador de desreferenciación unario

Nombre de Archivo pointerdemo.cpp

#include <iostream>
using namespace std;

int main() {
   int x = 4;
   int* px = 0 ;
   px = &x;
   cout << "x = " << x
        << " *px = " << *px 
        << " px = " << px
        << " &px = " << &px << endl;
   x = x + 1;
   cout << "x = " << x
        << " *px = " << *px
        << " px = " << px << endl;
   *px = *px + 1;
   cout << "x = " << x
        << " *px = " << *px
        << " px = " << px << endl;
   return EXIT_SUCCESS;
}

Salida:

OOP> ./a.out 
 x = 4 *px = 4 px = 0xbffff514  &px = 0xbffff510
 x = 5 *px = 5 px = 0xbffff514 
 x = 6 *px = 6 px = 0xbffff514 OOP>

Descargar ejemplo

Cuando corremos el Ejemplo 1.23 en momentos diferentes, o en diferentes máquinas, los valores particulares pueden variar.

La variable x accesa a sus datos directamente, pero la variable px accede al mismo dato indiractamente. Esto es porque la palabra indirigida es tambien usada para caracterizar el proceso de acceso a datos a través de un puntero. La relación entre las dos variables, x y px es ilustrada en la Figura 1.4.

[editar] Figura 1.4

Demostración de Puntero

Ver En Tamaño Original

<<- Anterior (Punteros y acceso de memoria) -|- (Contenido) -|- (Operadores new y delete) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Los operadores unarios & y *) -|- (Contenido) -|- (Ejercicios: Punteros y acceso de memoria.) Siguiente ->>

Versión para imprimir esta pagina

[editar] 1.16.2. Operadores new y delete

C++ cuenta con un mecanismo que permite almacenar para ser alojado dinámicamente en tiempo de ejecución. Esto significa que el programador no necesita anticipar las necesidades de memoria de un programa en avance y hacer estimaciones del máximo monto de memoria que podría ser necesitada por el programa. La alocación dinámica de almacenamiento en tiempo de ejecución es una herramienta poderosa que ayuda a construir programas que sean eficientes y flexibles.

El operador new asigna almacenamiento desde el montón (también conocido como almacenamiento dinámico) y devuelve un puntero del objeto resultante. Si por alguna razón no le es posible a la memoria el asignarlo, una excepción es producida. (Sección 21.9)

Nota:

En general, el código que llama a 'new. debería documentarse, o estar físicamente asignada cerca del código que libera la memoria. La meta de esto es la de dejar el código de administración de memoria lo más simple y leíble posible.

El operador delete libera la memoria asignada dinámicamente y la regresa al montón. delete debiera ser aplicado a punteros devueltos por new, o para punteros nulos. La memoria del montón que no se necesitará más debiera ser liberada para su reuso. Olvidar esto puede resultar en deformes pérdidas de memoria.

Nota:

Qt, la Librería Estándar, y BOOST.org, cada uno proporciona una variedad de clases y funciones para ayudar a administrar y limpiar el montón de memoria. En adición a las clases de contenedor, cada librería tiene uno o más clases de punteros inteligentes. Un puntero inteligente es un objeto que almacena y administra un puntero a un objeto de montón. Esto funciona como un puntero ordinario, excepto que es borrado automáticamente el objeto del montón en el momento adecuado. Qt tiene a QPointer, la librería estándar tiene a std::auto_ptr, y BOOST cuenta con shared_ptr. Usar una de esas clases hace que el administrador de memoria de C++ sea mucho más simple y seguro de lo que en realidad es.

La sintaxis de los operadores new y delete es demostrada en el fragmento de código del Ejemplo 1.24.

[editar] Ejemplo 1.24

Ejemplo: Ejemplo 1.24. src/pointers/newdelete/ndsyntax.cpp

int* ip = 0; puntero nulo

ip = new int; espacio asignado por un int

int* jp = new int(13); asignado e inicializado

delete ip; Sin esto, tenemos una pérdida de memoria.

{
int* ip = 0;
ip = new int;
int* jp = new int(13);
[...]      
delete ip;
delete jp;
}

Descargar ejemplo

<<- Anterior (Los operadores unarios & y *) -|- (Contenido) -|- (Ejercicios: Punteros y acceso de memoria.) Siguiente ->>

Versión para imprimir esta pagina

<<- Anterior (Operadores new y delete) -|- (Contenido) -|- (const* y *const) Siguiente ->>

Versión para imprimir esta pagina

[editar] Exercicios: Punteros y acceso de Memoria

Predice la salida del Ejemplo 1.25:

[editar] Ejemplo 1.25

Ejemplo: Ejemplo 1.25. src/pointers/newdelete1.cpp

Compila y ejecuta el código. Explica la salida, especialmente las últimas dos líneas.

{
#include <iostream>
     using namespace std;

     int main() {
         const char tab = '\t';
         int n = 13;
         int* ip = new int(n + 3);
         double d = 3.14;
         double* dp = new double(d + 2.3);
         char c = 'K';
         char* cp = new char(c + 5);
         cout << *ip << tab << *dp << tab << *cp << endl;
         int* ip2 = ip;
         cout << ip << tab << ip2 << endl;
         *ip2 += 6;
         cout << *ip << endl;
         delete ip;
         cout << *ip2 << endl;
         cout << ip << tab << ip2 << endl;
     }

}

Descargar ejemplo

2. Modifica el Ejemplo 1.23 para hacer algo de aritmética con el valor apuntando a jp. Asigna el resultado al alojamiento dentro del puntero de memoria para ip, e imprime el resultado. Imprime los valores de salida desde diferentes lugares dentro del programa. Investiga como reaccionan tu compilador y sistema en tiempo de ejecución a la colocación de las sentencias de salida.

<<- Anterior (Operadores new y delete) -|- (Contenido) -|- (const* y *const) Siguiente ->>

Versión para imprimir esta pagina

Introducción a Patrones de Diseño en C++ con Qt4/1.17 const* y *const

Pronto observamos que un objeto (en el sentido más general) es una región contigua de almacenamiento. Un lvalue (left value, valor que va a la izquierda en una asignación) es una expresión que se refiere a un objeto. Ejemplos de lvalue son variables, celdas de arrays y punteros derreferenciados. En esencia, un lvalue es cualquier cosa con una dirección de memoria a la que se le pueda dar un nombre. En contraste, expresiones temporales o constantes tales como i+1 ó 3 no son lvalues.

[0] Desafortunadamente, el manejo de excepciones rompe esta regla causando un poco de sobrecarga si es habilitada. Es el porque de que muchas librerías prefieren no usar excepciones.

[1] BSD es mantenido por Berkeley Software Distribution, una facilidad de Computer Systems Research Group (CSRG) de la universidad de California a Berkeley. CSRG ha sido un importante centro de desarrollo para UNIX y para varios protocolos básicos (p.e., TCP/IP) desde la década de 1980.

[2] Si queremos escribir una expresión regular de POSIX ( Sección 13.2), para *nix, esta debería verse como esto: (lin|mac-os|un|solar|ir|ultr|ai|hp)[iu]?[sx].

[3] Qt 4 no requiere del uso de esta variable de entorno, pero nosotros la utilizamos para referirnos al directorio “Qt install” en nuestros ejemplos.

[4] Cubrimos las funciones de recarga y operadores más a fondo en la Sección 5.2.

[5] Los manipuladores son referencias de función que pueden ser insertados dentro de un flujo de entrada ó salida para modificar su estado. Discutimos más a fondo esto en la Sección 1.12.

[6] En MS Dev Studio, se le llama nmake

[7] Dependiendo de tu entorno de desarrollo, este programa puede tener algúnos otros nombres como mingw32-make, nmake, gmake, o unsermake.

[8] Para una mayor discusión sobre las diferencias entre tipos integrales con signo y sin signo, revisa la Sección 18.4.

[9] yoría de los sistemas, un caracter simple es un byte

[1]

[1]

[2]

[3]

[1]

[2]

[1]

[1]

[1]

[2]