Investigación

Programación III

Richardson Alejandro Laínez Cárcamo 4-11-2018

11711075
Tabla de contenido
Smart Pointers (C++) .............................................................................................................. 2
¿Qué son? ............................................................................................................................ 2
Usos de los punteros inteligentes ........................................................................................ 2
Clases de punteros inteligentes ........................................................................................... 5
Punteros inteligentes de la biblioteca estándar de C++ ................................................... 5
Punteros inteligentes para objetos COM (programación clásica de Windows) .............. 6
Punteros inteligentes ATL para objetos POCO............................................................... 6
QT en C++ .............................................................................................................................. 8
¿Qué es? .............................................................................................................................. 8
Ventajas .............................................................................................................................. 8
Ejemplos ........................................................................................................................... 10
Emulador de sonido a bajo nivel para C++. ......................................................................... 12
FMOD ............................................................................................................................... 12
Ejemplo ......................................................................................................................... 13
MMSystem.h..................................................................................................................... 14
PlaySound...................................................................................................................... 14
Ejemplos ........................................................................................................................ 15
Referencias ........................................................................................................................... 16
 Smart Pointers (C++)

¿Qué son?

Un smart pointer (puntero inteligente) es un tipo abstracto de datos que simula el

comportamiento de un puntero corriente, pero añadiendo nuevas características adicionales, como
ser: recolector de basura automático y comprobador de límites. Estas características adicionales tienen
como objetivo reducir errores causados por el mal uso de punteros, manteniendo la eficiencia.

Existen varios tipos de punteros inteligentes. Algunos trabajan llevando la cuenta de

referencias, otros mediante asignación de un objeto a un único puntero.

En C++, los punteros inteligentes pueden ser implementados como una "template class" que
imita, mediante sobrecarga de operadores, el comportamiento de los punteros tradicionales, pero
proporcionando algoritmos de administración de memoria.

Usos de los punteros inteligentes

Los punteros inteligentes se definen en el espacio de nombres std del archivo de encabezado
<memory>. Son cruciales en la expresión de programación RAII o Resource Acquisition Is
Initialialization. El objetivo principal de esta expresión es asegurarse de que la adquisición de recursos
ocurre al mismo tiempo que se inicializa el objeto, de manera que todos los recursos del objeto se
creen y se dispongan en una sola línea de código. En la práctica, el principio básico RAII consiste en
proporcionar la propiedad de cualquier recurso asignado por montón (por ejemplo, memoria asignada
dinámicamente o identificadores de objetos del sistema) a un objeto asignado a la pila cuyo destructor
contiene código para eliminar o liberar el recurso, además de cualquier código asociado de limpieza.

En la mayoría de los casos, cuando se inicializa un puntero o un identificador de recursos sin

formato para apuntar a un recurso real, el puntero se pasa inmediatamente a un puntero inteligente.
En el lenguaje C++ actual, los punteros sin formato se utilizan únicamente en pequeños bloques de
código de ámbito limitado, bucles o funciones auxiliares donde el rendimiento es crucial y no hay
ninguna posibilidad de confusión sobre la propiedad.

En el siguiente código se compara una declaración de puntero sin formato con una
declaración de puntero inteligente:
 Como se muestra en el ejemplo, un puntero inteligente es una plantilla de clase que se declara
en la pila y se inicializa con un puntero sin formato que apunta a un objeto asignado por montón. Una
vez que se inicializa el puntero inteligente, se convierte en propietario del puntero sin formato. Esto
significa que el puntero inteligente es responsable de eliminar la memoria que el puntero sin formato
especifica. El destructor del puntero inteligente contiene la llamada de eliminación y, dado que el
puntero inteligente se declara en la pila, su destructor se invoca cuando el puntero inteligente sale del
ámbito, incluso si se produce una excepción en alguna parte que se encuentre más arriba en la pila.

Para acceder al puntero encapsulado, utilice los conocidos operadores de puntero -> y *, que
la clase del puntero inteligente sobrecarga para devolver el puntero sin formato encapsulado.

La expresión del puntero inteligente de C++ se asemeja a la creación de objetos en lenguajes

como C#: se crea el objeto y después se permite al sistema que se ocupe de eliminarlo en el momento
correcto. La diferencia es que ningún recolector de elementos no utilizados independiente se ejecuta
en segundo plano; la memoria se administra con las reglas estándar de ámbito de C++, de modo que
el entorno en tiempo de ejecución es más rápido y eficaz.

En el ejemplo siguiente se muestra cómo se puede utilizar un tipo de puntero inteligente

unique_ptr de la biblioteca de plantillas estándar para encapsular un puntero a un objeto grande.
En el ejemplo se muestran los pasos básicos siguientes para utilizar punteros inteligentes.
1. Declare el puntero inteligente como variable automática (local). (No utilice la expresión new
o malloc en el propio puntero inteligente).
2. En el parámetro de tipo, especifique el tipo al que apunta el puntero encapsulado.
3. Pase un puntero sin formato al objeto new-ed en el constructor de puntero inteligente.
(Algunas funciones de utilidad o constructores de puntero inteligente hacen esto por usted.)
4. Utilice los operadores sobrecargados -> y * para tener acceso al objeto.
5. Deje que el puntero inteligente elimine el objeto.

Los punteros inteligentes están diseñados para ser lo más eficaces posible tanto en términos de
memoria como de rendimiento. Por ejemplo, el único miembro de datos de unique_ptr es el puntero
encapsulado. Esto significa que unique_ptr tiene exactamente el mismo tamaño que ese puntero,
cuatro u ocho bytes. El acceso al puntero encapsulado a través del puntero inteligente sobrecargado
* y los operadores -> no es mucho más lento que el acceso directo a los punteros sin formato.

Los punteros inteligentes tienen sus propias funciones miembro, a las que se accede mediante la
notación “punto”. Por ejemplo, algunos punteros inteligentes de STL tienen una función miembro de
restablecimiento que libera la propiedad del puntero. Esto es útil cuando se quiere liberar la memoria
que es propiedad del puntero inteligente antes de que el puntero inteligente salga del ámbito, tal y
como se muestra en el ejemplo siguiente.
 Los punteros inteligentes suelen proporcionar un mecanismo para acceder directamente al
puntero sin formato. Los punteros inteligentes STL tienen una función miembro de get con este
propósito y CComPtr tiene un miembro de clase p público. Si proporciona acceso directo al puntero
subyacente, puede utilizar el puntero inteligente para administrar la memoria en el propio código y
continuar pasando el puntero sin formato en un código que no admita punteros inteligentes.

Clases de punteros inteligentes

En la sección siguiente se resumen los distintos tipos de punteros inteligentes disponibles en
el entorno de programación de Windows y se describe cuándo utilizarlos.

Punteros inteligentes de la biblioteca estándar de C++

Utilice estos punteros inteligentes como primera opción para encapsular punteros a los objetos
estándar de C++ (POCO).

 unique_ptr
Permite exactamente un único propietario del puntero subyacente. Utilice esta opción como
predeterminada para los objetos POCO, a menos que sepa con certeza que necesita un objeto
shared_ptr. Puede moverse a un nuevo propietario, pero no se puede copiar ni compartir.
Sustituye a auto_ptr, que está desusado. Comparado con boost::scoped_ptr, unique_ptr es
pequeño y eficaz; el tamaño es un puntero y admite referencias rvalue de inserción y
extracción rápidas en colecciones STL. Archivo de encabezado: <memory>.

 shared_ptr
Puntero inteligente con recuento de referencias. Utilícelo cuando desee asignar un puntero
sin formato a varios propietarios, por ejemplo, cuando devuelve una copia de un puntero
desde un contenedor pero desea conservar el original. El puntero sin formato no se elimina
hasta que todos los propietarios de shared_ptr han salido del ámbito o, de lo contrario, han
renunciado a la propiedad. El tamaño es dos punteros: uno para el objeto y otro para el bloque
de control compartido que contiene el recuento de referencias. Archivo de encabezado:
<memory>.
  weak_ptr
Puntero inteligente de caso especial para usarlo junto con shared_ptr. weak_ptr proporciona
acceso a un objeto que pertenece a una o varias instancias de shared_ptr, pero no participa en
el recuento de referencias. Utilícelo cuando desee observar un objeto, pero no quiere que
permanezca activo. Es necesario en algunos casos para interrumpir las referencias circulares
entre instancias de shared_ptr. Archivo de encabezado: <memory>.

Punteros inteligentes para objetos COM (programación clásica de Windows)

Cuando trabaje con objetos COM, encapsule los punteros de interfaz en un tipo de puntero
inteligente adecuado. Active Template Library (ATL) define varios punteros inteligentes para
propósitos diferentes. También puede usar el tipo de puntero inteligente _com_ptr_t, que el
compilador utiliza cuando crea clases contenedoras de archivos .tlb. Es la mejor opción si no desea
incluir los archivos de encabezado ATL.

 CComPtr Class
Utilice esta opción a menos que no puede usar ATL. Realiza el recuento de referencias
mediante los métodos AddRef y de Release..

 CComQIPtr Class
Se parece a CComPtr, pero también proporciona la sintaxis simplificada para llamar a
QueryInterface en objetos COM.

 CComHeapPtr Class
Puntero inteligente a objetos que utilizan CoTaskMemFree para liberar memoria.

 CComGITPtr Class
Puntero inteligente para las interfaces que se obtienen de la tabla de interfaz global (GIT).

 _com_ptr_t (Clase)
Se parece a CComQIPtr en funcionalidad, pero no depende de los encabezados ATL.

Punteros inteligentes ATL para objetos POCO

Además de punteros inteligentes para los objetos COM, ATL también define punteros
inteligentes y colecciones de punteros inteligentes para objetos estándar de C++. En la programación
clásica de Windows, estos tipos son alternativas útiles a las colecciones STL, especialmente cuando
no es necesaria la portabilidad de código o cuando no se quiere mezclar los modelos de programación
de STL y ATL.

 CAutoPtr Class
Puntero inteligente que exige una propiedad única al transferir la propiedad en la copia. Puede
compararse con la clase std::auto_ptr desusada.
 CHeapPtr Class
Puntero inteligente para objetos asignados mediante la función malloc de C.

 CAutoVectorPtr Class
Puntero inteligente para matrices que se asignan mediante new[].

 CAutoPtrArray Class
Clase que encapsula una matriz de elementos CAutoPtr.

 CAutoPtrList Class
Clase que encapsula los métodos para manipular una lista de nodos de CAutoPtr.
 QT en C++

¿Qué es?

Qt es un framework de desarrollo de aplicaciones multiplataforma para desktop,

embebido y móvil. Las plataformas soportadas incluyen Linux, OS X, Windows, VxWorks,
QNX, Android, iOS, BlackBerry, Sailfish OS y otros.

Qt no es un lenguaje de programación por sí solo. Es un framework escrito en C++.

Un preprocesador, MOC (Meta-Object Compiler), se utiliza para extender el lenguaje c++
con funciones como Signals y Slots. Antes del paso de compilación, MOC analiza los
archivos de origen escritos en Qt-extended C++ y genera código fuente C++ estándar
compatibles de ellos. Por lo tanto, el propio framework y las aplicaciones/librerías que lo
utilizan pueden ser compilados por cualquier compilador compatible con C++ estándar como
Clang, GCC, ICC, MinGW y MSVC.

Ventajas

 Rápido
En desarrollo de software, tiempo es dinero. Ese es el motivo por el que Qt te da un
completo espacio de trabajo productivo con bibliotecas multiplataforma, APIs y
herramientas para llegar al mercado lo antes posible

 Fácil
Soluciones sencillas – Qt es fácil de usar y un flexible entorno de desarrollo y
herramientas de diseño que incluyen controles ya hechos y funcionalidad prediseñada
para un diseño de usuario eficiente

 Está preparado para el futuro

¿Han cambiado los requisitos de nuevo? No hay problema. Qt es un framework de
C++ abierto, extensible y modular que soporta unos ciclos de desarrollo de bajo coste

 Financiación y soporte: Qt es de código abierto y tiene mucha contribución de la

comunidad, pero avanza más rápido que proyectos similares porque está financiado
y apoyado por Nokia (y se compromete a seguir trabajando en su desarrollo).
 Usa un editor visual: Las herramientas de desarrollo visuales permiten a los
diseñadores crear interfaces más lindas y fluidas trabajando junto con los
desarrolladores. También ayuda mucho a la hora de ajustar dimensiones y
características de algunos elementos de la UI.

 Usa un IDE completo y potente: Qt Creator combina edición, depuración, gestión

de proyectos, localización y herramientas de compilación. Tiene todo lo necesario
para crear programas para pcs y smartphones. Y todo pensado para trabajar en
conjunto sin tener que cambiar de entornos gráficos o aplicaciones.

 Es gratuito: Todas las herramientas de Qt son gratuitas para bajar y usar y está
permitido usarlas para crear proyectos comerciales. Y, obviamente, si decidimos que
Qt no nos sirve no importa porque no nos costó nada.

 Multi-plataforma: Desarrollar aplicaciones que funcionen tanto en Mac como en

Windows es bastante complicado sin Qt. Por eso algunas aplicaciones populares
como Google Earth o Skype lo utilizan. También hay que mencionar que sirve para
Symbian, Maemo y próximamente dispositivos MeeGo.

 Estabilidad y calidad: Qt existe desde 1992 y la última versión (4.7.2) salió la

semana pasada. Todo ha sido probado, usado profesionalmente y mejorado muchas
veces, resultando en muy buena fiabilidad y facilidad de uso.

 Gran comunidad online: Ante cualquier problema o duda siempre habrá una
comunidad amable, bien informada y dispuesta a ayudar.

 Programadores con experiencia pueden usar C++: Qt no es un nuevo lenguaje de

programación, si sabemos C++ y/o Java no nos debería resultar difícil utilizar Qt ya
que la mayoría de los proyectos de Qt están escritos en C++ (mejorado con extras
para hacer el trabajo más rápido).

 Uso de QML para escribir código más rápido: Si recién empezamos o queremos
crear algo rápidamente, probablemente nos convenga utilizar Qt Quick (Qt User
Interface Creation Kit). Con el mismo, utilizamos el constructor de interfaz visual y
 el código JavaScript QML para crear la aplicación. También se puede combinar C++
y QML en una misma aplicación.

 Uso de Python para escribir código reutilizable: La comunidad Qt acaba de

anunciar el lanzamiento de PySide, permitiendo a los desarrolladores de Python usar
la interfaz de Qt para crear aplicaciones multi-plataforma.

 [Próximamente] Dispositivos Android: Muchos complementos provienen de los

miembros de la comunidad online de Qt y recientemente se exploró la posibilidad de
portar aplicaciones Qt a smartphones Android con resultados positivos. Si se sigue
desarrollando, esto abre muchas posibilidades para desarrolladores Qt para
smartphones.

 El código abierto abre oportunidades: El ejemplo anterior de Android es sólo una

forma en la que Qt demuestra los beneficios de la comunidad Open Source. Nuevas
herramientas y complementos aparecen de forma regular.

 Mucha documentación: Luego de 18 años, la gente de Qt acumuló una gran cantidad

de documentación. Desde tutoriales hasta fragmentos de código.

Ejemplos

El siguiente es un ejemplo usando Qt del conocido programa ¡Hola Mundo!, donde

se crea una ventana con una etiqueta (QLabel) mostrando el texto ¡Hola Mundo!
Compilación y ejecución
1. Se crea la carpeta Hola
2. Se crea el archivo Hola.cpp en la carpeta Hola
3. En un emulador de terminal descender a la carpeta Hola y ejecutar:
a) qmake -project
b) qmake
c) make/gmake/nmake - según el sistema operativo o de compilación
4. Para ejecutar el programa:
d) ./release/Hola (en Windows: release\Hola.exe)

Crear una ventana

Descripción

 linea 5
Aquí se agrega la referencia a la librería QWidget

 linea 11
Se crea el objeto QWidget que se llamará ventana.

 linea 12
Se ajusta el tamaño del objeto ventana.
  linea 14
En esta linea se observa la referencia que se hace al crear el objeto boton_salir. En
vez de crearse una estancia en aplicacion se crea en la estancia ventana.

 linea 17
Se agrega una nueva propiedad al boton_salir; setGeometry ajusta los valores de la
posición gráfica (20,50,150,40) en que se deberá encontrar el boton_salir. Esta
posición es relativa de acuerdo al contenedor, en este caso es relativa a ventana.

 linea 10
Finalmente mostramos la aplicación(ventana.show()) en los ejemplos anteriores se
observa que para mostrar la aplicación el código era aplicacion.show() sin embargo
en este caso nuestra estancia que contiene los widgets (el boton_salir) es ventana por
lo consiguiente es el que queremos mostrar.

Compilar
Compilar con qmake -project, qmake y make.

Emulador de sonido a bajo nivel para C++.

FMOD

El lenguaje de programación C++ no tiene el concepto de sonido, pero se pueden

utilizar librerias externas, de terceros tales como FMOD o las que la API del sistema
operativo ofrece.

Algunas funciones para mp3:

 Para abrir * .mp3:

 mciSendString("open \"*.mp3\" type mpegvideo alias mp3", NULL, 0, NULL);

 Para play * .mp3:

mciSendString("play mp3", NULL, 0, NULL);

 Para reproducir y esperar hasta que el * .mp3 haya terminado de reproducirse:

mciSendString("play mp3 wait", NULL, 0, NULL);

 Para reproducir (reproducir de nuevo desde el inicio) el * .mp3:

mciSendString("play mp3 from 0", NULL, 0, NULL);

 Para reproducir y esperar hasta que * .mp3 haya terminado de reproducirse:

mciSendString("play mp3 from 0 wait", NULL, 0, NULL);

 Para reproducir el * .mp3 y reproducirlo cada vez que termina como un bucle:
mciSendString("play mp3 repeat", NULL, 0, NULL);
 To pause the *.mp3 in middle:
mciSendString("pause mp3", NULL, 0, NULL);

 and to resume it:

mciSendString("resume mp3", NULL, 0, NULL);

 To stop it in middle:
mciSendString("stop mp3", NULL, 0, NULL);

Ejemplo
MMSystem.h

Esta librería pertenece a "Windows.h"

PlaySound

La función PlaySound reproduce un sonido especificado por el nombre de archivo, el

recurso o el evento del sistema. (Un evento del sistema puede estar asociado con un sonido
en el registro o en el archivo WIN.INI).

Sintaxis

Parámetros

 pszSound
Una cadena que especifica el sonido para jugar. La longitud máxima, incluido el
terminador nulo, es de 256 caracteres. Si este parámetro es NULL , cualquier sonido
de forma de onda que se esté reproduciendo se detendrá. Para detener un sonido que
no sea de onda, especifique SND_PURGE en el parámetro fdwSound .

Tres indicadores en fdwSound ( SND_ALIAS , SND_FILENAME y

SND_RESOURCE ) determinan si el nombre se interpreta como un alias para un
evento del sistema, un nombre de archivo o un identificador de recursos. Si no se
especifica ninguno de estos indicadores, PlaySound busca en el registro o en el
archivo WIN.INI una asociación con el nombre de sonido especificado. Si se
encuentra una asociación, se reproduce el evento de sonido. Si no se encuentra
ninguna asociación en el registro, el nombre se interpreta como un nombre de archivo.

 hmod
Diríjase al archivo ejecutable que contiene el recurso que se va a cargar. Este
parámetro debe ser NULL a menos SND_RESOURCE se especifica en fdwSound .
  fdwSound
Banderas para tocar el sonido.

Observaciones

El sonido especificado por pszSound debe caber en la memoria física disponible y

reproducirse mediante un controlador de dispositivo de audio con forma de onda instalada.

PlaySound busca en los siguientes directorios los archivos de sonido: el directorio

actual; el directorio de Windows; el directorio del sistema de Windows; directorios
enumerados en la variable de entorno PATH; y la lista de directorios mapeados en una red.
Si la función no puede encontrar el sonido especificado y no se especifica el indicador
SND_NODEFAULT , PlaySound utiliza en su lugar el sonido de evento del sistema
predeterminado. Si la función no puede encontrar la entrada predeterminada del sistema ni el
sonido predeterminado, no emite sonido y devuelve FALSO.

Ejemplos
 Referencias
(04 de abril de 2018). Obtenido de
https://es.wikibooks.org/wiki/Introducci%C3%B3n_a_Patrones_de_Dise%C3%B1o
_en_C%2B%2B_con_Qt4
Alexandrescu, A. (2002). Modern C++ Design: Generic Programming and Design
Patterns Applied. Addison-Wesley.
Josuttis, N. M. (1999). The C++ Standard Library - A Tutorial and Reference.
Microsoft. (05 de abril de 2018). Obtenido de https://msdn.microsoft.com/es-
es/library/hh279674.aspx
Microsoft. (06 de abril de 2018). Obtenido de Función PlaySound:
https://msdn.microsoft.com/en-
us/library/windows/desktop/dd743680%28v=vs.85%29.aspx
Qt. (07 de abril de 2018). Obtenido de The Qt Company: https://www1.qt.io/es/
r4miro. (08 de abril de 2018). Obtenido de Hipertextual:
https://hipertextual.com/archivo/2011/03/13-razones-para-utilizar-qt/
Sutter, H. (06 de abril de 2018). The New C++: Smart(er) Pointers. Obtenido de Wayback
Machine:
https://web.archive.org/web/20060220195924/http://www.cuj.com/documents/s=79
80/cujcexp2008sutter/
Taringa. (05 de abril de 2018). Obtenido de Como poner sonidos en C++(Muy Fácil):
https://www.taringa.net/posts/hazlo-tu-mismo/18417230/Como-poner-sonidos-en-
C-Muy-Facil.html
WikiBooks. (05 de abril de 2018). Obtenido de Programación con Qt4/Crear una ventana:
https://es.wikibooks.org/wiki/Programaci%C3%B3n_con_Qt4/Crear_una_ventana