POO (Programación Orientada a Objetos) con Visual C++

Procesamiento de Datos. Encapsulamiento. Ocultación. Instancias. Relaciones Jerárquicas-Semánticas. Propiedades Heredadas. Visual C++

  • Enviado por: Angie Ramirez
  • Idioma: castellano
  • País: Panamá Panamá
  • 37 páginas
publicidad

CREDO DE VISUAL C++

Creo en un solo Lenguaje De Programación

“C” Todopoderoso, creador de Unix y de Windows 98

Creo en un solo “C”, hijo único de “C” antes de “Visual C++”

“C” de “C”, Compilador de Compilador, “C” (C) copyrighted, Compilado, no interpretado, de los mismos programadores que el Padre por quien todo es programado, que por nosotros los hombres y nuestros servidores fue desarrollado y por obra del Lenguaje Binario se encarnó en ensamblado y se hizo Lenguaje y por nuestra causa es ampliamente aceptado en tiempos de Bill Gates.

Decayó y fue olvidado y se renovó al tercer día, según los usuarios.

Y subieron las ventas, y está ubicado dentro de todo Unix.

Por quien todo es programado

Y de nuevo vendrá mejorado para juzgar a virus y programas

Y su dominio no tendrá fin.

Creo en el Lenguaje binario, código y base del sistema

Que precede al padre y al hijo que con el padre y el hijo recibe una misma aplicación y memoria y que hablo por los procesadores...

Creo en la arquitectura IBM, que es una sólida, compacta y compatible.

Confieso que no hay ni un solo “undo” para la corrección de los errores

Espero la resurrección de las Macs y la vida en un mundo con Internet..

Enter

INDICE

Introducción

  • Lenguaje de Programación Orientada a Objetos

  • Beneficios que se obtienen

  • Problemas que se derivan

  • Historia de la Evolución del Lenguaje C.

  • Características de Visual C++

  • 3.1 Características de la versión 6.0

  • Requerimientos de Visual C++

  • Componentes de Visual C++

  • Compiladores C/C++

  • 6.1 Comparativa sobre compiladores de C++

  • Demostración de una aplicación desarrollada en Visual C++

  • 7.1 Código Fuente

    Conclusión

    Bibliografía

    Anexos

    INTRODUCCIÓN

    Actualmente una de las tareas más candentes en la industria y en el ámbito académico es la Orientación a objetos. La Orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad, código que es difícil de modificar, ciclos de desarrollo largos y técnicas de codificación no intuitivas.

    Un Lenguaje Orientado a Objetos ataca estos problemas. Tienes tres características básicas: Debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos lenguajes cumplen uno o dos de estos puntos; mucho menos cumplen los tres. La barrera más difícil de sortear es usualmente la herencia.

    El concepto de programación orientada a objetos (OOP) no es nuevo, lenguajes clásicos como Smalltalk se basan en ella. Dado que la OOP, se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo.

    El elemento fundamental de la OOP, es como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización.

    Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bien estructurados. En segundo lugar, cada objeto no es un ente, sino que forma parte de una organización jerárquica o de otro tipo.

    Con la aparición de C en los años 80 como Lenguaje de Programación extremadamente popular en todas las plataformas, las ampliaciones orientadas a objetos por C han sido una razón fundamental para la atención creciente hacia la propia programación orientada a objetos y la justificación del mayor empleo de C++, sobre Smalltalk dentro de la comunidad de programación C++, la ampliación orientada a objetos de Bjarne Stroustrup para C, han ganado una pronta militancia en el campo de las estaciones de trabajo y mini computadoras, y más recientemente en las realizaciones de DOS de Microsoft y OS/2 de IBM. El rendimiento ha sido un factor clave en el aumento de popularidad de C++. El código producido por C++ es casi igual en el rendimiento al código producido por los compiladores tradicionales de C, debido al cuidadoso diseño de lenguaje que apunta hacia una generación de código eficaz.

  • LENGUAJE DE PROGRAMACIÓN ORIENTADO OBJETO

  • Día a día los costos del hardware decrecen. Así surgen nuevas áreas de aplicación cotidianamente: procesamiento de imágenes y sonido, bases de datos multimediales, automatización de oficinas, ambientes de ingeniería de software, etc. Aún en las aplicaciones tradicionales encontramos que definir interfaces hombre-máquina “a-la-Windows” suele ser bastante conveniente.

    Lamentablemente, los costos de producción de software siguen aumentando; el mantenimiento y la modificación de sistemas complejos suelen ser una tarea trabajosa; cada aplicación, (aunque tenga aspectos similares a otra) suele encararse como un proyecto nuevo etc.

    Todos estos problemas aún no han sido solucionados en forma completa, pero como los objetos son portables (teóricamente) mientras que las herencias permiten la reusabilidad del código orientado a objetos, es más sencillo modificar código existente porque los objetos no interaccionan excepto a través de mensajes; en consecuencia un cambio en la codificación de un objeto no afectará la operación con otro objeto siempre que los métodos respectivos permanezcan intactos. La introducción de tecnología de objetos como una herramienta conceptual para analizar, diseñar e implementar aplicaciones permite obtener aplicaciones más modificables, fácilmente extensibles y partir de componentes reusables. Esta reusabilidad del código disminuye el tiempo que se utiliza en el desarrollo y hace que el desarrollo del software sea más intuitivo porque la gente piensa naturalmente en términos de objetos más que en términos del algoritmos de software.

  • BENEFICIOS QUE SE OBTIENEN

  • La clave decisiva principal de la programación orientada a objetos es la capacidad de implicar las tareas de programación. Ente los beneficios principales se incluyen:

    • Simplificación

    Diseñar un programa resulta más fácil, dado que los objetos se corresponden más estrechamente con las entidades del mundo real.

    • Reutilización

    Dado que los objetos están estrechamente relacionados con los datos con los que operan, es posible reutilizar antiguos objetos en programas nuevos.

    • Reparabilidad

    Al poner al día los programas basados en tecnología orientada a objetos, los objetos aíslan las funciones del programa unas de otras; de esta forma la modificación de una de las funciones no supone el cambio del programa. Los objetos enteros pueden ser modificados sin reescribir el resto del programa.

    • Algunos de los lenguajes de programación que trabajan en el entorno de Windows 3.11 son: (Visual C++, Visual BASIC, Quick C, turbo pascal, ect.)

  • PROBLEMAS QUE SE DERIVAN

  • Un sistema orientado a objetos, por lo visto puede parecer un paraíso virtual.

    El problema sin embargo surge en la implementación de tal sistema.

    Muchas compañías oyen acerca de los beneficios de un sistema orientado a objetos e invierten gran cantidad de recursos, luego comienzan a darse cuenta que han impuesto una nueva cultura que es ajena a los programadores actuales.

    Específicamente los siguientes temas suelen aparecer repetidamente:

    • Curvas de aprendizaje largas

    Un sistema orientado a objetos ve al mundo en una forma única.

    Involucra la conceptualización de todos los elementos de un programa, desde un subsistema a los datos, en la forma de objetos. Toda la comunicación entre los objetos debe realizarse en la forma de mensajes. Esta no es la forma en que están escritos los programas orientados a objetos actualmente; al hacer la transición a un sistema orientado a objetos la mayoría de los programadores deben capacitarse nuevamente antes de poder usarlo.

    • Dependencia del Lenguaje

    A pesar de la portabilidad conceptual de los objetos en un sistema orientado a objetos, en la práctica existen muchas dependencias.

    Muchos lenguajes orientados a objetos están compitiendo actualmente para dominar el mercado. Cambiar el lenguaje de implementación de un sistema orientado a objetos no es una tarea sencilla; por ejemplo C++ soporta el concepto de herencias múltiple mientras que Smalltalk no la soporta; en consecuencia la elección de un lenguaje tienen ramificaciones de diseño muy importantes.

    • Determinación de las Clases

    Una clase es un molde que se utiliza para crear nuevos objetos. En consecuencia es importante crear el conjunto de clases adecuado para un proyecto. Desdichadamente la definición de las clases es más un arte que una ciencia. Si bien hay muchas jerarquías de clase predefinidas usualmente se deben crear clases específicas para la aplicación que sé este desarrollando. Luego, en 6 meses ó un año se da cuenta que las clases que se establecieron no son posibles; en ese caso será necesario reestructurar la jerarquía de clases devastando totalmente la planificación original.

    • Performance

    En un sistema donde todo es un objeto y toda interacción es a través de mensajes, el tráfico de mensajes afecta la performance. A medida que la tecnología avanza y la velocidad de micropocesamiento, potencia y tamaño de la memoria aumentan, la situación mejorará; pero en la situación actual, un diseño de aplicación orientada a objetos que no tienen en cuenta la performance no será viable comercialmente.

    Idealmente, habría una forma de atacar estos problemas eficientemente al mismo tiempo que se obtienen los beneficios del desarrollo de una estrategia orientada a objetos. Debería existir una metodología fácil de aprender e independiente del lenguaje, y fácil de reestructurar que no drene la performance del sistema.

  • HISTORIA DE LA EVOLUCIÓN DEL LENGUAJE C

  • El Lenguaje C reúne características de programación intermedia entre los lenguajes ensambladores y los lenguajes de alto nivel; con gran poderío basado en sus operaciones a nivel de bits (propias de ensambladores) y la mayoría de los elementos de la programación estructurada de los lenguajes de alto nivel, por lo que resulta ser el lenguaje preferido para el desarrollo de software de sistemas y aplicaciones profesionales de la programación de computadoras.

    En 1970 Ken Thompson de los laboratorios Bell se había propuesto desarrollar un compilador para el lenguaje Fortran que corría en la primera versión del sistema operativo Unix tomando como referencias el lenguaje BCPL; el resultado fue el lenguaje B (orientado a palabras) que resulto adecuado para la programación de software de sistemas; con B creó las primeras versiones del sistema operativo UNIX en una computadora DEC PDP-7. Este lenguaje tuvo la desventaja de producir programas relativamente lentos.

    En 1972, Dennis Ritchie, estaba finalizando su proyecto, en los famosos laboratorios Bell. “El lenguaje C”, una evolución del B, implementando originalmente en una DEC PDP-11. Al contrario de sus antecesores, C era un lenguaje con tipos, es decir, que cada elemento de información ocupaba una palabra en memoria y la tarea de tratar cada elemento de datos como número entero real, o arreglos, no recaía en el programador.

    C era conocido como el lenguaje con el cual se desarrolló el sistema operativo UNIX y actualmente la mayoría de los sistemas operativos se codifican en C. Lo bueno de este lenguaje es que no depende de la arquitectura de hardware. Es posible escribir código en C, y llevarlos a otras máquinas. Eso lo convirtió en uno de los lenguajes más portátiles del mercado. A fines de los años 70, evolucionó lo que conocemos como… “C de Kernigham y Ritchie”, y el libro The C Programming Languaje que publicó Prentice May en 1978 se hizo impresionantemente famoso.

    Claro que C tuvo un inconveniente, su amplia difusión ahora le estaba jugando una mala pasada, al ser tan universal, habían muchas variantes, además bastante incompatibles, creando serios problemas para los desarrolladores de software, que necesitaban escribir código para diferentes plataformas, y claro que era imprescindible que exista compatibilidad. Todo el mundo necesitaba que se creará una versión universal de C. Tarea llevada a cabo por la ANSI, que no fue sino hasta 1989 para que se aprobara el estándar. La ANSI cooperó con la ISO, en la estandarización mundial de C, el documento se publicó en 1990 y es posible pedirle a la ANSI una copia de ese documento.

    Ahora, volvemos al principio de los años 80 donde Bjarne Stroustrup, diseñó una extensión del lenguaje C, llamándolo C con clases. El término clase provenía de Simula 67, y servía para entender más el comportamiento del mundo real y llevarlo a los códigos, ocultando los detalles de su implementación.

    En 1984, C con clases fue rediseñado en un compilador y se le denominó C++. En 1985 estuvo disponible la primera versión del Lenguaje C++ y se realizó el libro de Bjarne Struostrup: The C++ Programming Languaje, publicado por Addison-Wesley en 1986.

    El nombre de C++, fue porque éste último era variante del C original. En el lenguaje C, el operador ++ significa, incrementar la variable, se eligió en nombre C++, debido a que éste agregaba al C original el término de Programación Orientada a Objetos (POO), basadas en simula 67.

    Al ser C++ una variación de C, los programas codificados en C pueden correr tranquilamente en C++. En 1990, el lenguaje ha sido descrito por Stroustrup y Ellis en el Annotated C++ Reference Manual editado por Addison-Wesley, existiendo una versión en español del mismo, con el título de C++. Manual de Referencias con anotaciones publicado por Addison Wesley/Días de Santos en 1994.

    La versión estandarizada por ANSI, la versión 3.0 es la que soportan la mayoría de los fabricantes mundiales, como ser, Borland, AT&T, WatCom, Microsoft etc. En sus respectivas actualizaciones. Hoy en día, Borland ofrece el compilador de C++ en la versión 5.5 de forma gratuita.

    Lenguaje C++ Se pronuncia “ce plus plus”. Es un lenguaje extremadamente poderosos y eficiente. C++ es un súper conjunto de C, para aprender C++ significa aprender todo acerca de C, luego aprender programación orientada al objeto y el uso de éstas con C++.

  • CARACTERÍSTICAS DE VISUAL C++

  • Visual C ++ es la herramienta más productiva que sirve para crear aplicaciones de alto rendimiento para Windows y Web. Casi todo el software de clase mundial que va desde coordinar buscadores Web hasta aplicaciones corporativas de misión crítica se elaboran utilizando el sistema de desarrollo Visual C++. Visual C++ proporciona un nivel nuevo de productividad, sin comprometer la flexibilidad, rendimiento o control.

    Características

    • Una librería de clases MFC, que da soporte a los objetos Windows tales como las ventanas, cajas de dialogo, mensajes, controles y objetos GDI (Graphic Device Interface), como lápices, pinceles, fuentes e imágenes.

    • Soporte para integración de datos con otras aplicaciones.

    • Soporte para objetos incrustados y enlazados que permite enlazar información de otras aplicaciones Windows.

    • Interfaz para múltiples documentos que permite crear una aplicación con una ventana de aplicación y múltiples ventanas de documentos.

    • Soporte para establecer enlaces con Windows y con rutinas escritas en otros lenguajes.

    • Un entorno de desarrollo integrado (editor, compilador, depurador, analizador, etc).

    • Soporte a la programación a través de las herramientas Appwizard y Classwizard.

    • Soporte para dibujar la interfaz gráfica del usuario a través de Appstudio que incluye un editor de diálogos, un editor de menús y un editor de gráficos.

    • Soporte para conectarse a diferentes bases de datos.

    • Cabeceras precombinadas que reducen el tiempo de compilación.

  • CARACTERISTICAS DE LA VERSION 6.0

    • Maximize el desarrollo de aplicaciones de productividad

    * Aumenta la velocidad de desarrollo y simplifica, en gran medida, la codificación.

    * Trabaja con mayor rapidez gracias a las funciones Edit (editar) y continue (continuar) en el depurador. Los desarrolladores pueden editar códigos, al tiempo que realizan la depuración sin tener que salir de la sesión, reestructurar, reiniciar el depurador y regresar la aplicación al estado donde se presentó el problema.

    * Ahorra tiempo en el desarrollo con la actualización de Dynamic ClassView. Cuando se agregan clases nuevas, variables y funciones de participantes, ClassView y WizardBar se actualizan de inmediato.

    * Integra fácilmente y sin problema la funcionalidad de Microsoft Word, Microsoft Excel, así como de otras aplicaciones con Active Document Containment (contenido de documento activo). Los usuarios obtienen las funciones y la capacidad total a la que están acostumbrados, mientras el desarrollador debe escribir menos códigos.

    * Genera rápidamente aplicaciones funcionales de manera automática. Los asistentes nuevos mejorados permiten aumentar la productividad de los desarrolladores al incluir un rango amplio de tareas y la compatibilidad con varias tecnologías nuevas.

    • Diseñe Aplicaciones de más alto rendimiento

    * Hace que la recopilación sea más rápida que nunca. El tiempo de recopilación de los proyectos grandes se ha reducido en un 30%, sin sacrificar cualquiera de las optimizaciones.

    * Mejora el rendimiento de la aplicación con más control sobre la carga DLL. La opción de enlace Delay Load Imports (importaciones de carga con retraso) permite que las aplicaciones carguen únicamente las DLL cuando sea necesario para continuar la ejecución, reduciendo los tiempos de arranque y el uso de memoria.

    * Utiliza las más de 150 clases escritas por profesionales incluidas en la biblioteca Microsoft Foundation Classes and Templates.

    * Ahora los ejecutables son más rápidos. La nueva optimización de contraseñas se ha agregado a aquellas que ya son por el recopilador, con el fin de que las aplicaciones tengan acceso a las optimizaciones que necesiten, debido a su plataforma objetivo y sistemas.

    * El soporte para la especificación ANSI/ISO C++ incluye soporte para las contraseñas y tipos más recientes, incluyendo bool, explicit, false, mutable, true, typename. Así mismo, se han agregado.

    • Aproveche las tecnologías de Internet más recientes

    * Proporciona fácilmente a su aplicación la apariencia y sentido irresistible de Microsoft Internet Explorer 4.0 con soporte MFC para los controles comunes, arrastra y coloca cualquiera de estos controles para crear interfaces intuitivas y flexibles para el usuario.

    * Crea página web basadas en multimedia, altamente interactivas con Dynamic HTML que aprovecha totalmente Internet Explorer 4. y aumenta sus habilidades y códigos existentes.

    * Integra la web en sus aplicaciones MFC mediante la estructuración de buscadores web dentro de los usuarios principales MFC. Utilice Dynamic HTML en sus buscadores personalizados para agregar utilidad, manipular la emisión y disminuir los regresos al servidor.

    * Reutilice su código, combinando y extendiendo los controles Actives y de Windows existentes. Ahora los desarrolladores pueden crear, de manera visual, controles compuestos a través de Active Template Library (ATL) (biblioteca de plantilla activa) tan solo simplificando los controles de arrastrar y colocar existentes en un formato.

    * Personaliza fácilmente sus servidores web con el asistente ISAPI y las clases WinInet en MFC.

    • Obtiene la plataforma más reciente y soporte para el modelo de objetos de componentes

    * Crea los controles más dispuestos, más sólidos Actives y objetos COM con el soporte de recopilación de COM nativo total y utilice menos códigos para hacerlo.

    * Desarrolla los componentes del servidor, más pequeños, más escalables rápidamente con Active Template Library. Use los asistentes para crear asistentes COM y registrarlos de manera automática en Microsoft Transaction Server.

    * Vuelva a utilizar el código y los componentes. Los componentes de buscar, enrutar, catalogar y compartir están disponibles dentro de su equipo de desarrollo y a través de su organización con Visual Componente Manager (Administrador de componentes Visual) y Microsoft Repository.

    * Simplifica el desarrollo para las tecnologías de plataforma más recientes de Microsoft. Utilice asistentes para crear proyectos para agrupaciones Windows NT y snap-ins para Microsoft Management Console.

    • Tiene acceso a datos de manera flexible con el más alto rendimiento

    * Utiliza todas las herramientas integradas de Visual Database para diseñar visualmente y modificar el esquema de la base de datos.

    * Simplifica en gran medida el acceso de alto rendimiento a cualquier puente, ya sea relacional o no relacional, correo electrónico y sistemas de archivo, texto y gráficos, objetos de negocios del cliente y más con los asistentes OLE DB.

    * Desarrolla rápidamente aplicaciones de datos utilizando los controles de unión de datos Actives. Actives Data Objets (ADO) proporciona a los usuarios un acceso simplificado a cualquier dato expuesto por OLE DB.

    * Depura interactivamente los procedimientos almacenados de SQL Server dentro de IDE, utilizando la depuración remota SQL.

    * Desarrolle personalizaciones de alto rendimiento para SQL Server. El asistente permite crear procedimientos almacenados extendidos que dan rendimiento al código recopilado de manera natural, y flexibilidad en todo el API de Win 2000.

    • Logre un desarrollo empresarial escalable

    * Colabore, comparta y asegure el código de fuente en proyectos grandes con el sistema de control integrado Visual SourceSafe. Versión 6.0

    * Aproveche el soporte proporcionado por Microsoft SNA Sever 4.0 para acceder datos e integrar códigos con sistemas de computadora central y servicios de transacción.

    * Desarrolle prototipos y pruebe las aplicaciones empresariales con Microsoft SQL Server 6.5 Developer Edition, un sistema administrador de base de datos escalable y de alto rendimiento para sistemas basados en Windows NT.

    * Diseñe arquitectura de aplicación e interfaces de componente para organizar el desarrollo de equipo con Visual Modeler, una herramienta de diseño fácil de utilizar.

  • REQUERIMIENTOS DE VISUAL C++

  • Para utilizar Visual C++ se necesita:

    • PC con procesador 486DX/66 MHZ o superior (Pentium 90 recomendado)

    • Sistema operativo Microsoft Windows 95 o Microsoft Windows NT 4.0 con Service Pack 3 (Service Pack 3 incluido) o posterior.

    • 20 a 24 MB en Ram para Windows 95 (32 MB recomendado); 214 MB para Windows NT 4.0 (32 MB recomendado).

    • Microsoft Internet Explorer 4.01 con Service Pack 1 (incluido).

    • Espacio en disco duro requerido.

        • Instalación típica: 225 a 305 MB.

        • Instalación máxima: 305 a 405 MB.

    • Espacio adicional requerido en disco duro para los siguientes productos:

        • Microsoft Internet Explorer: 43 MB típica, 59 MB máxima.

        • MSDN: 57 MB típica, 493 MB máxima.

        • Windows NT 4.0 Option Pack: 20 MB para Window 95 o posterior; 200 MB, y para Windows NT 4.0.

    • Microsoft SQL Server 6.5 y Microsoft SNA Server 4.0 ejecutables únicamente en Windows NT 4.0, además de requerir el siguiente espacio adicional en disco duro.

        • SQL Server: 80 MB típica, 85 MB máxima.

        • SNA Server: 50 MB típica, 100+ MB máxima.

    • Unidad CD Rom

    • Monitor VGA o de resolución más alta, se recomienda Súper VGA.

    • Microsoft mouse o dispositivo indicador compatible.

  • COMPONENTES DE VISUAL C++

  • El nombre de visual C++ confunde a algunos. Algunos piensan que es un sistema de programación visual puro similar a Microsoft Visual Basic, y durante los primeros días la ilusión se mantiene. Sin embargo pronto aprende que realmente debe escribir código en C++.

    Visual C++ esta formado por dos sistemas completos de desarrollo de aplicación para Windows, Visual C++ incluye plantillas de Actives (ATL), que se pueden utilizar para desarrollar controles actives.

    • El Compilador C/C++

    El Compilador de Visual C++ puede procesar código fuente tanto de C como de C++, dándonos la pauta para poder programar con el tipo de lenguaje acostumbrado o mezclar dichas fuentes.

    • Editor de Código Fuente

    Visual C++ incluye un sofisticado editor de códigos fuente que permite muchas características, como la asignación dinámica de colores en función de la sintaxis. Posee una característica llamada Auto Complete.

    • El compilador de Recursos

    El compilador de recursos de Visual C++ lee un archivo de Guión de recursos (RC) en ASCII. Que se encuentra en los editores de recursos y escribe un archivo binario RES que es el que utiliza el enlazador.

    • AppWizard

    El AppWizard (Asistente de Aplicaciones) es un generador de código que crea un esqueleto de trabajo de una aplicación de Windows con características, nombres de clases y nombres de archivos de código fuente que se especifican a través de cuadros de diálogos. El código del AppWizard es mínimo. La funcionalidad se encuentra en las clases de base del armazón de la aplicación con el AppWizard se comienza a crear una nueva aplicación con gran rapidez.

  • COMPILADORES C/C++

  • ¿Qué es compilador?

    El compilador es un programa que nos permite convertir nuestro código fuente (los programas que escribimos) en un programa ejecutable. Es el encargado de traducir nuestro código fuente al idioma del ordenador.

    Existen multitud de compiladores de C/C++, unos gratuitos y otros comerciales. Los gratuitos no desmerecen de los comerciales, y en algunos casos son incluso superiores a éstos.

    Un compilador crea programas para el sistema operativo en el que trabaja (DOS, Windows, Linux,...), aunque algunos pueden crearlos para otros distintos (son los compiladores cruzados).

    Compiladores C/C++

    • DJGPP: Compilador C/C++ de 32 bits para Ms-DOS/Windows. Es de libre distribución e incluye código fuente.

    • Pacific C: Compilador de C para Dos. Es freeware.

    • Turbo C 2.01: El clásico compilador de C de Borland. Ahora es gratuito. Es la versión completa: 1074 bytes.

    • Borland C++: Compilador ANSI C++ de 32 bits para Windows.

    • XS Compiler

    • Visual C++

    • GNU C++

    6.1 COMPARATIVA SOBRE COMPILADORES DE C/C++

    En este punto se trata de mostrar una comparación acerca de los diferentes tipos de compiladores del lenguaje de programación C++. Los compiladores a los que se le realizaron las pruebas y determinaron cual de ellos era el mejor son:

    Turbo C++

    Borland C++

    Visual C++

    GNU C++.

    Los tres primeros compiladores fueron ejecutados sobre el sistema operativo WINDOWS 95, y pueden generar código tanto para Windows como para MS-DOS. Y el compilador GNU de C++ (llamado G++) en el sistema operativo LINUX. Las mediciones que se llevaron a cabo fueron sobre el mismo ordenador, para evitar que los resultados obtenidos se vean influenciados por las características del ordenador y así es posible obtener datos más fiables y verídicos. Las características del ordenador fueron las siguientes.

    Pentium MMX 200Mhz.

    32 Mb Memoria Ram.

    3.2 Gb de Disco Duro.

    512 Kb Memoria Caché.

    • Mediciones

    Las pruebas en las que se baso el estudio para determinar cual de los compiladores de C++ es mejor son las siguientes:

    La velocidad del programa ejecutable obtenido.

    El tamaño del ejecutable.

    El tiempo de compilación.

    Para determinar cual de los compiladores generaba un código ejecutable más rápido se ejecuto cada prueba (bench mark) en un tiempo fijo de 10 segundos, obteniéndose el número de iteraciones que se ha ejecutado la prueba en los distintos compiladores. Cada prueba se realizaba varias veces en cada compilador y se hacia la media de las iteraciones obtenidas en cada ocasión para el mismo compilador. De esta forma se calculaba el número de iteraciones por segundo que ejecutaba cada compilador y comprobábamos cual de ellos generaba un código más rápido. Midiendo el tamaño del código ejecutable que cada compilador generaba para los distintos benchmarks, se podía determinar que compilador generaba un ejecutable de tamaño menor, ventaja que es deseable a la hora de elegir un compilador de C++. La última prueba que se llevo a cabo en los compiladores fue la de medir el tiempo que tardaba en compilar unos programas fuente, realizándose varias veces estas mediciones sobre cada compilador y calculándose la media.

    Tras las diversas pruebas e investigaciones realizadas se determino que las operaciones que implican el uso de clases se realizan con mayor velocidad con el código ejecutable generado por Borland C++ y con menor velocidad en el Turbo C++. Sin embargo, para estas mismas operaciones el tamaño mayor del ejecutable ha sido el generado por el Borland C++ y el menor por el GNU. Se ha observado de forma notoria que el compilador GNU ha generado el código ejecutable más rápido a excepción de la salida por pantalla, siendo mejor el Turbo C++. El que se ejecuta más lentamente en todas las operaciones ha sido el Visual C++. Con respecto al tamaño o el compilador que ha generado el ejecutable más pequeño ha sido el GNU para todas las operaciones de forma muy significativa y el que ocupa más espacio es el del Borland C++ con gram diferencia. Finalmente, hemos observado que el compilador que tarda menos tiempo en generar el código ejecutable ha sido el Borland C++ y el que tarda más, con diferencia, ha sido Visual C++.

    En conclusión, el más preferible para nuestro punto de vista es el GNU C++, seguido del Borland C++, Turbo C++ y por último el Visual C++. Aunque esta elección depende de las características que se considere más importante a la hora de compilar cualquier programa de C++.

  • DEMOSTRACIÓN DE UNA APLICACIÓN DESARROLLADA EN VISUAL C++

  • Esta demostración esta concretada en el diseño y manejo de una calculadora. La misma se ha elaborado siguiendo los estándares de una calculadora convencional.

    Ha sido todo un reto poder plasmar las funciones de una calculadora convencional, en una calculadora programada en Visual C++. De allí el origen del nombre ha esta demostración “My First Calculator.”

    • Elementos empleados en el cuadro de dialogo:

    El diseño exclusivo de My First Calculator fue realizado utilizando los siguientes objetos del lenguaje:

    Objeto Propiedad Valor

    Dialog Box ID IDD_CALCULATOR_DIALOG

    Caption My First Calculator

    Font System, Size 10

    Minimize Box Checked

    Maximize Box Checked

    Group Box ID IDC_STATIC

    Caption Bienvenido

    Client Edge Checked

    Static Edge Checked

    Modal Frame Checked

    Edit Box ID IDC_Pantalla visible

    ID IDC_Acum invisible

    ID IDC_Signos invisible

    ID IDC_Mar invisible

    Push Button ID IDC_CERO

    IDC_UNO

    IDC_DOS

    IDC_TRES

    IDC_CUATRO

    IDC_CINCO

    IDC_SEIS

    Push Button ID IDC_SIETE

    IDC_OCHO

    IDC_NUEVE

    IDC_SUMA

    IDC_RESTA

    IDC_MULTIPLICAR

    IDC_DIVIDIR

    IDC_UNOENTREX

    IDC_ELEVADO

    IDC_IGUAL

    IDC_SQRT

    IDC_MASMENOS

    IDC_BORRARTODO

    IDC_Mmas

    IDC_Mmenos

    IDC_MB

    IDC_MA

    IDC_MR

    • Funciones y variables creadas en My First Calculator

    Variables:

    M_PANTALLA VALUE DOUBLE

    M_ACUM VALUE DOUBLE

    M_SIGNOS VALUE DOUBLE

    M_MAR VALUE DOUBLE

    Funciones:

    SQRT

    POW

    • Procedimientos utilizados en My First Calculator

    Las operaciones que realizará la calculadora fueron creadas en bases a operaciones matemáticas en conjunto con variables que almacenaran los valores y reflejaran un resultado.

    Cabe señalar que se expreso en el #include una función llamada Math.h para que la misma pudiera permitir la ejecución de las funciones SQRT y POW que se señalan en el programa.

    El SQRT fue utilizado para la operación de raíz cuadrada y POW para la operación de un número elevado a otro número.

  • PROGRAMA FUENTE

  • // MY CALCULATORDlg.cpp : implementation file

    //

    #include "stdafx.h"

    #include "MY CALCULATOR.h"

    #include "MY CALCULATORDlg.h"

    #include "math.h"

    #ifdef _DEBUG

    #define new DEBUG_NEW

    #undef THIS_FILE

    static char THIS_FILE[] = __FILE__;

    #endif

    /////////////////////////////////////////////////////////////////////////////

    // CAboutDlg dialog used for App About

    class CAboutDlg : public CDialog

    {

    public:

    CAboutDlg();

    // Dialog Data

    //{{AFX_DATA(CAboutDlg)

    enum { IDD = IDD_ABOUTBOX };

    //}}AFX_DATA

    // ClassWizard generated virtual function overrides

    //{{AFX_VIRTUAL(CAboutDlg)

    protected:

    virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support

    //}}AFX_VIRTUAL

    // Implementation

    protected:

    //{{AFX_MSG(CAboutDlg)

    //}}AFX_MSG

    DECLARE_MESSAGE_MAP()

    };

    CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)

    {

    //{{AFX_DATA_INIT(CAboutDlg)

    //}}AFX_DATA_INIT

    }

    void CAboutDlg::DoDataExchange(CDataExchange* pDX)

    {

    CDialog::DoDataExchange(pDX);

    //{{AFX_DATA_MAP(CAboutDlg)

    //}}AFX_DATA_MAP

    }

    BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)

    //{{AFX_MSG_MAP(CAboutDlg)

    // No message handlers

    //}}AFX_MSG_MAP

    END_MESSAGE_MAP()

    /////////////////////////////////////////////////////////////////////////////

    // CMYCALCULATORDlg dialog

    CMYCALCULATORDlg::CMYCALCULATORDlg(CWnd* pParent /*=NULL*/)

    : CDialog(CMYCALCULATORDlg::IDD, pParent)

    {

    //{{AFX_DATA_INIT(CMYCALCULATORDlg)

    m_acum = 0.0;

    m_signos = 0.0;

    m_mar = 0.0;

    m_pantalla = 0.0;

    //}}AFX_DATA_INIT

    // Note that LoadIcon does not require a subsequent DestroyIcon in Win32

    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

    }

    void CMYCALCULATORDlg::DoDataExchange(CDataExchange* pDX)

    {

    CDialog::DoDataExchange(pDX);

    //{{AFX_DATA_MAP(CMYCALCULATORDlg)

    DDX_Text(pDX, IDC_ACUM, m_acum);

    DDX_Text(pDX, IDC_SIGNOS, m_signos);

    DDX_Text(pDX, IDC_MAR, m_mar);

    DDX_Text(pDX, IDC_PANT1, m_pantalla);

    //}}AFX_DATA_MAP

    }

    BEGIN_MESSAGE_MAP(CMYCALCULATORDlg, CDialog)

    //{{AFX_MSG_MAP(CMYCALCULATORDlg)

    ON_WM_SYSCOMMAND()

    ON_WM_PAINT()

    ON_WM_QUERYDRAGICON()

    ON_BN_CLICKED(IDC_CERO, OnCero)

    ON_BN_CLICKED(IDC_UNO, OnUno)

    ON_BN_CLICKED(IDC_DOS, OnDos)

    ON_BN_CLICKED(IDC_TRES, OnTres)

    ON_BN_CLICKED(IDC_CUATRO, OnCuatro)

    ON_BN_CLICKED(IDC_CINCO, OnCinco)

    ON_BN_CLICKED(IDC_SEIS, OnSeis)

    ON_BN_CLICKED(IDC_SIETE, OnSiete)

    ON_BN_CLICKED(IDC_OCHO, OnOcho)

    ON_BN_CLICKED(IDC_NUEVE, OnNueve)

    ON_BN_CLICKED(IDC_SUMA, OnSuma)

    ON_BN_CLICKED(IDC_RESTA, OnResta)

    ON_BN_CLICKED(IDC_MULTIPLICAR, OnMultiplicar)

    ON_BN_CLICKED(IDC_DIVISION, OnDivision)

    ON_BN_CLICKED(IDC_BORRARTODO, OnBorrartodo)

    ON_BN_CLICKED(IDC_UNOENTREX, OnUnoentrex)

    ON_BN_CLICKED(IDC_CAMBIOSIGNO, OnCambiosigno)

    ON_BN_CLICKED(IDC_ELEVADO, OnElevado)

    ON_BN_CLICKED(IDC_SQRT, OnSqrt)

    ON_BN_CLICKED(IDC_Mmas, OnMmas)

    ON_BN_CLICKED(IDC_Mmenos, OnMmenos)

    ON_BN_CLICKED(IDC_MR, OnMr)

    ON_BN_CLICKED(IDC_MA, OnMa)

    ON_BN_CLICKED(IDC_MB, OnMb)

    ON_BN_CLICKED(IDC_IGUAL, OnIgual)

    //}}AFX_MSG_MAP

    END_MESSAGE_MAP()

    /////////////////////////////////////////////////////////////////////////////

    // CMYCALCULATORDlg message handlers

    BOOL CMYCALCULATORDlg::OnInitDialog()

    {

    CDialog::OnInitDialog();

    // Add "About..." menu item to system menu.

    // IDM_ABOUTBOX must be in the system command range.

    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);

    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);

    if (pSysMenu != NULL)

    {

    CString strAboutMenu;

    strAboutMenu.LoadString(IDS_ABOUTBOX);

    if (!strAboutMenu.IsEmpty())

    {

    pSysMenu->AppendMenu(MF_SEPARATOR);

    pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);

    }

    }

    // Set the icon for this dialog. The framework does this automatically

    // when the application's main window is not a dialog

    SetIcon(m_hIcon, TRUE); // Set big icon

    SetIcon(m_hIcon, FALSE); // Set small icon

    // TODO: Add extra initialization here

    return TRUE; // return TRUE unless you set the focus to a control

    }

    void CMYCALCULATORDlg::OnSysCommand(UINT nID, LPARAM lParam)

    {

    if ((nID & 0xFFF0) == IDM_ABOUTBOX)

    {

    CAboutDlg dlgAbout;

    dlgAbout.DoModal();

    }

    else

    {

    CDialog::OnSysCommand(nID, lParam);

    }

    }

    // If you add a minimize button to your dialog, you will need the code below

    // to draw the icon. For MFC applications using the document/view model,

    // this is automatically done for you by the framework.

    void CMYCALCULATORDlg::OnPaint()

    {

    if (IsIconic())

    {

    CPaintDC dc(this); // device context for painting

    SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

    // Center icon in client rectangle

    int cxIcon = GetSystemMetrics(SM_CXICON);

    int cyIcon = GetSystemMetrics(SM_CYICON);

    CRect rect;

    GetClientRect(&rect);

    int x = (rect.Width() - cxIcon + 1) / 2;

    int y = (rect.Height() - cyIcon + 1) / 2;

    // Draw the icon

    dc.DrawIcon(x, y, m_hIcon);

    }

    else

    {

    CDialog::OnPaint();

    }

    }

    // The system calls this to obtain the cursor to display while the user drags

    // the minimized window.

    HCURSOR CMYCALCULATORDlg::OnQueryDragIcon()

    {

    return (HCURSOR) m_hIcon;

    }

    void CMYCALCULATORDlg::OnCero()

    {

    m_pantalla=m_pantalla * 10 + 0;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnUno()

    {

    m_pantalla=m_pantalla * 10 + 1;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnDos()

    {

    m_pantalla=m_pantalla * 10 + 2;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnTres()

    {

    m_pantalla=m_pantalla * 10 + 3;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnCuatro()

    {

    m_pantalla=m_pantalla * 10 + 4;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnCinco()

    {

    m_pantalla=m_pantalla * 10 + 5;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnSeis()

    {

    m_pantalla=m_pantalla * 10 + 6;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnSiete()

    {

    m_pantalla=m_pantalla * 10 + 7;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnOcho()

    {

    m_pantalla=m_pantalla * 10 + 8;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnNueve()

    {

    m_pantalla=m_pantalla * 10 + 9;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnSuma()

    {

    m_signos='+';

    m_acum=m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnResta()

    {

    m_signos='-';

    m_acum=m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnMultiplicar()

    {

    m_signos='*';

    m_acum=m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnDivision()

    {

    m_signos='/';

    m_acum=m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnBorrartodo()

    {

    m_pantalla=0;

    m_acum=0;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnUnoentrex()

    {

    m_pantalla=1/m_pantalla;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnCambiosigno()

    {

    if(m_pantalla>0)

    m_pantalla=m_pantalla*(-1);

    else

    m_pantalla=-(m_pantalla)*1;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnElevado()

    {

    m_acum=m_pantalla;

    m_signos='**';

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnSqrt()

    {

    m_pantalla=sqrt(m_pantalla);

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnMmas()

    {

    m_mar=m_mar+m_pantalla;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnMmenos()

    {

    m_mar=m_mar-m_pantalla;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnMr()

    {

    m_pantalla=m_mar;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    void CMYCALCULATORDlg::OnMa()

    {

    m_mar=m_pantalla;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnMb()

    {

    m_mar=0;

    UpdateData(FALSE);

    }

    void CMYCALCULATORDlg::OnIgual()

    {

    if (m_signos=='+')

    {

    m_pantalla=m_acum+m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    else

    if (m_signos=='-')

    {

    m_pantalla=m_acum-m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    else

    if (m_signos=='*')

    {

    m_pantalla=m_acum*m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    else

    if (m_signos=='/')

    {

    m_pantalla=m_acum/m_pantalla;

    UpdateData(FALSE);

    m_pantalla=0;

    }

    else

    if (m_signos=='**')

    {

    m_pantalla=pow(m_acum,m_pantalla);

    UpdateData(FALSE);

    m_pantalla=0;

    }

    }

    Conclusión

    La programación orientada a objetos no es un destello pasajero. Tampoco es una idea poco práctica proveniente de una torre de marfil: agradable en teoría, pero inútil en la práctica. Las personas que inventaron y desarrollaron la programación orientada a objetos no empezaron con las frases básicas y las características del lenguaje, y pasaron después a hacer una práctica de programación con bases en esas frases y características. Eran programadores expertos con mucha experiencia que utilizaron, junto con su conocimiento, buscar formas de simplificar el proceso de programación y acabar con la frustración por las herramientas y técnicas existentes. En resumen, empezaron con un concepto general y una motivación: hacer que los programas fueran más fáciles de construir y comprender.

    Ahora esta nueva generación que se esta abriendo camino en el horizonte podrá disfrutar y aprovechar gracias al esfuerzo de estos programadores, uno de los grandes adelantos dentro de la programación “Lenguajes orientados a objetos” del cual este proyecto es una pequeña muestra de las infinitas cosas que se pueden realizar solo con imaginación, creatividad y empeño.

    BIBLIOGRAFÍA