Este documento describe las similitudes y diferencias entre arrays y punteros en C++. Explica que un puntero puede apuntar al primer elemento de un array y acceder a los elementos del array de forma equivalente. También cubre temas como el incremento de punteros, el paso de arrays como parámetros de funciones, arrays dinámicos utilizando punteros a punteros, funciones amigas y la sobrecarga de operadores.
Este documento describe un carrusel de citas que muestra citas de forma automática cada 2 segundos. También permite cambiar la cita mostrada al hacer clic en los botones de una barra de navegación inferior que representa cada cita. Las citas se almacenan en un array externo y la barra de navegación se genera dinámicamente para permitir cambiar entre ellas.
Este documento describe diferentes tipos de arrays o vectores en C++, incluyendo arrays unidimensionales, bidimensionales, de estructuras y uniones. Explica cómo declarar, acceder y recorrer elementos dentro de cada tipo de array. También proporciona ejemplos de código C++ para ilustrar el uso de arrays unidimensionales, bidimensionales y de estructuras. Finalmente, enumera algunas de las bibliotecas estándar más importantes de C++ relacionadas con cadenas y arrays.
Este documento proporciona una introducción al lenguaje de programación C++. Explica que C++ extiende C con capacidades de orientación a objetos. Luego resume los principales temas cubiertos, incluidos clases, herencia, sobrecarga de operadores, plantillas, excepciones y la biblioteca estándar. Finalmente, detalla conceptos básicos de C como tipos de datos, control de flujo, estructuras de datos estáticas y punteros.
Este documento presenta una introducción al lenguaje C#. Explica que C# es un lenguaje derivado de C y C++ diseñado para el desarrollo en .NET. Describe las características principales de C# como su sintaxis, tipos de datos, variables, operadores, sentencias de control de flujo y estructuras como clases y métodos. También explica conceptos como espacios de nombres, tipos por valor y referencia, arrays, constantes y excepciones.
Este documento proporciona una introducción a Visual C#.Net 2005. Explica los sistemas de tipos, clases, estructuras, arrays y matrices. También cubre la definición de clases, la instanciación de objetos y el manejo de excepciones mediante bloques try-catch.
Swift es un nuevo lenguaje de programación seguro, moderno y potente desarrollado por Apple para crear aplicaciones en iOS y OS X. Algunas características clave de Swift incluyen gestión automática de memoria, sintaxis sencilla, tipos y clases mejorados, y compatibilidad con Objective-C. Swift también introduce nuevos conceptos como closures, opciones y genéricos.
Este documento describe diferentes métodos de interpolación polinomial como Lagrange, Newton y Neville. Explica cómo se han implementado estos métodos como funciones en C++ y proporciona ejemplos de programas que ilustran su uso para interpolar diferentes funciones. También presenta programas adicionales para generar datos, visualizar resultados y estudiar la convergencia de los polinomios interpoladores.
Este documento describe un carrusel de citas que muestra citas de forma automática cada 2 segundos. También permite cambiar la cita mostrada al hacer clic en los botones de una barra de navegación inferior que representa cada cita. Las citas se almacenan en un array externo y la barra de navegación se genera dinámicamente para permitir cambiar entre ellas.
Este documento describe diferentes tipos de arrays o vectores en C++, incluyendo arrays unidimensionales, bidimensionales, de estructuras y uniones. Explica cómo declarar, acceder y recorrer elementos dentro de cada tipo de array. También proporciona ejemplos de código C++ para ilustrar el uso de arrays unidimensionales, bidimensionales y de estructuras. Finalmente, enumera algunas de las bibliotecas estándar más importantes de C++ relacionadas con cadenas y arrays.
Este documento proporciona una introducción al lenguaje de programación C++. Explica que C++ extiende C con capacidades de orientación a objetos. Luego resume los principales temas cubiertos, incluidos clases, herencia, sobrecarga de operadores, plantillas, excepciones y la biblioteca estándar. Finalmente, detalla conceptos básicos de C como tipos de datos, control de flujo, estructuras de datos estáticas y punteros.
Este documento presenta una introducción al lenguaje C#. Explica que C# es un lenguaje derivado de C y C++ diseñado para el desarrollo en .NET. Describe las características principales de C# como su sintaxis, tipos de datos, variables, operadores, sentencias de control de flujo y estructuras como clases y métodos. También explica conceptos como espacios de nombres, tipos por valor y referencia, arrays, constantes y excepciones.
Este documento proporciona una introducción a Visual C#.Net 2005. Explica los sistemas de tipos, clases, estructuras, arrays y matrices. También cubre la definición de clases, la instanciación de objetos y el manejo de excepciones mediante bloques try-catch.
Swift es un nuevo lenguaje de programación seguro, moderno y potente desarrollado por Apple para crear aplicaciones en iOS y OS X. Algunas características clave de Swift incluyen gestión automática de memoria, sintaxis sencilla, tipos y clases mejorados, y compatibilidad con Objective-C. Swift también introduce nuevos conceptos como closures, opciones y genéricos.
Este documento describe diferentes métodos de interpolación polinomial como Lagrange, Newton y Neville. Explica cómo se han implementado estos métodos como funciones en C++ y proporciona ejemplos de programas que ilustran su uso para interpolar diferentes funciones. También presenta programas adicionales para generar datos, visualizar resultados y estudiar la convergencia de los polinomios interpoladores.
El documento resume las principales características del lenguaje de programación C++. C++ extiende el lenguaje C con conceptos de orientación a objetos como clases, herencia y sobrecarga de operadores. El documento también cubre conceptos básicos de C como tipos de datos, control de flujo, punteros y funciones, así como mejoras introducidas por C++ como referencias.
Este documento contiene información sobre funciones, estructuras de datos y arreglos unidimensionales en el lenguaje de programación C. Explica conceptos como declaración de funciones, llamadas a funciones, declaración y acceso a elementos de arreglos. También presenta ejemplos de código para ilustrar el uso de funciones, arreglos y el producto algebraico de matrices.
Este documento contiene información sobre funciones, estructuras de datos y arreglos unidimensionales en el lenguaje de programación C. Explica que un programa está formado por la estructura de datos y el algoritmo, y define conceptos como funciones, declaración de arreglos, arreglos unidimensionales y su indexación. También incluye ejemplos de código C para ilustrar estos conceptos.
La habilidad más importante que debería tener un programador es la capacidad de resolver problemas de manera lógica y sistemática. Un buen programador puede analizar un problema de forma clara y desarrollar una solución de manera ordenada y metódica. Otras habilidades importantes incluyen la capacidad de comunicarse efectivamente, trabajar en equipo, aprender constantemente y tener una actitud de mejora continua.
Este documento presenta los temas a cubrir en la Clase 1 de Programación Java: repaso de Java, estándares de codificación Java y buenas prácticas. Los estándares de codificación incluyen normas sobre la estructura de archivos, nomenclatura, indentación y declaración de variables. Las buenas prácticas se enfocan en usar nombres descriptivos, evitar NullPointerExceptions, utilizar colecciones genéricas y constantes en lugar de strings mágicos.
El documento describe las funciones y procedimientos en C, incluyendo su declaración, implementación y uso. Explica que las funciones permiten dividir un problema grande en subproblemas más pequeños y fáciles de resolver, y que los procedimientos son funciones que no retornan ningún valor.
El documento describe los tipos de datos básicos en Java como enteros, flotantes, booleanos y caracteres. Explica que Java es fuertemente tipado y cada variable debe tener un tipo declarado. También cubre operadores aritméticos, lógicos y de asignación, así como estructuras de control como if/else y bucles for y while.
Este documento describe la sobrecarga de operadores para la clase Arreglo en C++. Presenta la sobrecarga de operadores como el constructor, destructor, operador de asignación, operador de subíndice, operadores de comparación, operadores de entrada y salida para la clase Arreglo. Estos permiten tratar los objetos de la clase Arreglo de manera similar a los arreglos integrados de C++.
Este documento describe cómo crear un programa en C que utilice vectores y funciones para ingresar números entre 5 y 55 en un vector, encontrar los elementos pares, guardarlos en un nuevo vector y mostrarlos de forma ascendente y descendente mediante el uso de al menos dos funciones. Explica cómo declarar vectores, recorrerlos, definir funciones y llamar a funciones dentro del programa principal para realizar las tareas requeridas.
Este documento describe conceptos avanzados de programación como métodos, clases estáticas, la clase Math, declaración de métodos con múltiples parámetros, y arreglos. Explica cómo los métodos permiten dividir un programa en partes más pequeñas, evitar la repetición de código, y facilitar la depuración y reutilización. También describe cómo declarar y llamar métodos, incluyendo métodos estáticos y sobrecargados, y cómo declarar, crear y pasar arreglos a métodos.
Este documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, constructores, destructores y funciones miembro. También cubre sobrecarga de operadores, funciones amigas y constructores de copia. El documento proporciona ejemplos para ilustrar cómo se implementan estos conceptos en C++.
El documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, métodos públicos y privados. Explica el uso de constructores y destructores para inicializar y liberar recursos de objetos. También cubre temas como E/S con flujos, manejo de archivos y constructores parametrizados.
Este documento presenta un cronómetro digital creado con JavaScript y HTML que cuenta décimas de segundo de forma precisa. Explica cómo el cronómetro almacena el tiempo transcurrido en un elemento DOM y en localStorage para mantener la cuenta entre usos. También describe cómo JSON permite serializar y deserializar datos como objetos JavaScript para su almacenamiento y intercambio.
El documento describe el algoritmo de backpropagation para redes neuronales. Explica que el algoritmo consiste en cuatro pasos principales: 1) inicializar los pesos de forma aleatoria, 2) calcular las salidas de la red, 3) calcular los errores y ajustar los pesos para minimizar el error, 4) repetir los pasos anteriores hasta satisfacer un criterio de parada. También describe cómo se utiliza el algoritmo en la aplicación para reconocer caracteres mediante la propagación hacia adelante y el cálculo de las salidas más altas.
Este documento describe las funciones en el lenguaje de programación C. Explica que una función es una porción de código que realiza una tarea específica y puede ser llamada desde otras partes del programa. Detalla la sintaxis básica de una función en C, incluyendo el tipo de datos, nombre, parámetros y cuerpo. Además, distingue entre variables globales y locales y los diferentes tipos de paso de parámetros.
El resumen resume brevemente los pasos para usar punteros en C++ y las listas enlazadas: 1) Se define el tipo de puntero, 2) se declaran las variables puntero y se les asigna memoria, 3) se accede y modifica la memoria apuntada por los punteros, 4) cuando ya no se necesitan, se libera la memoria asignada a los punteros. Para listas enlazadas, se definen los nodos con punteros al siguiente nodo, se crea la lista enlazada insertando y borrando nodos.
El documento describe cadenas (strings) en C. Explica que las cadenas en C son arrays de caracteres terminados en '\0'. Detalla cómo declarar, inicializar y asignar cadenas, y describe funciones comunes para manipular cadenas como strcpy(), strcmp(), strlen(), gets(), puts() y más. También incluye ejemplos de programas que usan estas funciones con cadenas.
El documento describe los conceptos de herencia y polimorfismo en programación orientada a objetos. La herencia permite crear nuevas clases a partir de clases existentes adoptando sus atributos y mejorándolos. El polimorfismo permite que diferentes objetos respondan de forma diferente a los mismos mensajes o operaciones. Se proveen ejemplos de herencia simple y sobrecarga de operadores como ilustración de estos conceptos.
02 python Programación orientada a objetos y funcionalJuan Rodríguez
Este documento describe los conceptos básicos de programación orientada a objetos en Python. Explica cómo crear clases, objetos, herencia y polimorfismo. También cubre temas como sobrecarga de operadores, métodos especiales y tratamiento de excepciones.
Este documento presenta el código de varios ejercicios de programación en C++ que involucran el uso de funciones, procedimientos, recursividad y estructuras. Los ejercicios incluyen calcular factoriales, sumatorias, combinatorias y secuencias de Fibonacci de manera recursiva y mediante el uso de vectores y arreglos de estructuras para almacenar datos de estudiantes y realizar operaciones sobre ellos.
Este documento describe los arreglos y su estructura en C. Los arreglos permiten almacenar múltiples datos del mismo tipo en una sola variable. Un arreglo tiene un tamaño, tipo y nombre. Los elementos de un arreglo se acceden mediante índices enteros. Los arreglos pueden ser unidimensionales o multidimensionales y se pueden inicializar y recorrer con bucles.
Un programa en C consta de tres partes principales: 1) el encabezamiento que declara variables y tipos de datos globales, 2) la función principal main que define la estructura del programa, y 3) funciones auxiliares llamadas por main. Los programas grandes se dividen en múltiples módulos compilados y enlazados separadamente. Las variables reservan memoria para almacenar valores de datos mientras que las constantes definen valores fijos a través de nombres simbólicos.
El documento resume las principales características del lenguaje de programación C++. C++ extiende el lenguaje C con conceptos de orientación a objetos como clases, herencia y sobrecarga de operadores. El documento también cubre conceptos básicos de C como tipos de datos, control de flujo, punteros y funciones, así como mejoras introducidas por C++ como referencias.
Este documento contiene información sobre funciones, estructuras de datos y arreglos unidimensionales en el lenguaje de programación C. Explica conceptos como declaración de funciones, llamadas a funciones, declaración y acceso a elementos de arreglos. También presenta ejemplos de código para ilustrar el uso de funciones, arreglos y el producto algebraico de matrices.
Este documento contiene información sobre funciones, estructuras de datos y arreglos unidimensionales en el lenguaje de programación C. Explica que un programa está formado por la estructura de datos y el algoritmo, y define conceptos como funciones, declaración de arreglos, arreglos unidimensionales y su indexación. También incluye ejemplos de código C para ilustrar estos conceptos.
La habilidad más importante que debería tener un programador es la capacidad de resolver problemas de manera lógica y sistemática. Un buen programador puede analizar un problema de forma clara y desarrollar una solución de manera ordenada y metódica. Otras habilidades importantes incluyen la capacidad de comunicarse efectivamente, trabajar en equipo, aprender constantemente y tener una actitud de mejora continua.
Este documento presenta los temas a cubrir en la Clase 1 de Programación Java: repaso de Java, estándares de codificación Java y buenas prácticas. Los estándares de codificación incluyen normas sobre la estructura de archivos, nomenclatura, indentación y declaración de variables. Las buenas prácticas se enfocan en usar nombres descriptivos, evitar NullPointerExceptions, utilizar colecciones genéricas y constantes en lugar de strings mágicos.
El documento describe las funciones y procedimientos en C, incluyendo su declaración, implementación y uso. Explica que las funciones permiten dividir un problema grande en subproblemas más pequeños y fáciles de resolver, y que los procedimientos son funciones que no retornan ningún valor.
El documento describe los tipos de datos básicos en Java como enteros, flotantes, booleanos y caracteres. Explica que Java es fuertemente tipado y cada variable debe tener un tipo declarado. También cubre operadores aritméticos, lógicos y de asignación, así como estructuras de control como if/else y bucles for y while.
Este documento describe la sobrecarga de operadores para la clase Arreglo en C++. Presenta la sobrecarga de operadores como el constructor, destructor, operador de asignación, operador de subíndice, operadores de comparación, operadores de entrada y salida para la clase Arreglo. Estos permiten tratar los objetos de la clase Arreglo de manera similar a los arreglos integrados de C++.
Este documento describe cómo crear un programa en C que utilice vectores y funciones para ingresar números entre 5 y 55 en un vector, encontrar los elementos pares, guardarlos en un nuevo vector y mostrarlos de forma ascendente y descendente mediante el uso de al menos dos funciones. Explica cómo declarar vectores, recorrerlos, definir funciones y llamar a funciones dentro del programa principal para realizar las tareas requeridas.
Este documento describe conceptos avanzados de programación como métodos, clases estáticas, la clase Math, declaración de métodos con múltiples parámetros, y arreglos. Explica cómo los métodos permiten dividir un programa en partes más pequeñas, evitar la repetición de código, y facilitar la depuración y reutilización. También describe cómo declarar y llamar métodos, incluyendo métodos estáticos y sobrecargados, y cómo declarar, crear y pasar arreglos a métodos.
Este documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, constructores, destructores y funciones miembro. También cubre sobrecarga de operadores, funciones amigas y constructores de copia. El documento proporciona ejemplos para ilustrar cómo se implementan estos conceptos en C++.
El documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, métodos públicos y privados. Explica el uso de constructores y destructores para inicializar y liberar recursos de objetos. También cubre temas como E/S con flujos, manejo de archivos y constructores parametrizados.
Este documento presenta un cronómetro digital creado con JavaScript y HTML que cuenta décimas de segundo de forma precisa. Explica cómo el cronómetro almacena el tiempo transcurrido en un elemento DOM y en localStorage para mantener la cuenta entre usos. También describe cómo JSON permite serializar y deserializar datos como objetos JavaScript para su almacenamiento y intercambio.
El documento describe el algoritmo de backpropagation para redes neuronales. Explica que el algoritmo consiste en cuatro pasos principales: 1) inicializar los pesos de forma aleatoria, 2) calcular las salidas de la red, 3) calcular los errores y ajustar los pesos para minimizar el error, 4) repetir los pasos anteriores hasta satisfacer un criterio de parada. También describe cómo se utiliza el algoritmo en la aplicación para reconocer caracteres mediante la propagación hacia adelante y el cálculo de las salidas más altas.
Este documento describe las funciones en el lenguaje de programación C. Explica que una función es una porción de código que realiza una tarea específica y puede ser llamada desde otras partes del programa. Detalla la sintaxis básica de una función en C, incluyendo el tipo de datos, nombre, parámetros y cuerpo. Además, distingue entre variables globales y locales y los diferentes tipos de paso de parámetros.
El resumen resume brevemente los pasos para usar punteros en C++ y las listas enlazadas: 1) Se define el tipo de puntero, 2) se declaran las variables puntero y se les asigna memoria, 3) se accede y modifica la memoria apuntada por los punteros, 4) cuando ya no se necesitan, se libera la memoria asignada a los punteros. Para listas enlazadas, se definen los nodos con punteros al siguiente nodo, se crea la lista enlazada insertando y borrando nodos.
El documento describe cadenas (strings) en C. Explica que las cadenas en C son arrays de caracteres terminados en '\0'. Detalla cómo declarar, inicializar y asignar cadenas, y describe funciones comunes para manipular cadenas como strcpy(), strcmp(), strlen(), gets(), puts() y más. También incluye ejemplos de programas que usan estas funciones con cadenas.
El documento describe los conceptos de herencia y polimorfismo en programación orientada a objetos. La herencia permite crear nuevas clases a partir de clases existentes adoptando sus atributos y mejorándolos. El polimorfismo permite que diferentes objetos respondan de forma diferente a los mismos mensajes o operaciones. Se proveen ejemplos de herencia simple y sobrecarga de operadores como ilustración de estos conceptos.
02 python Programación orientada a objetos y funcionalJuan Rodríguez
Este documento describe los conceptos básicos de programación orientada a objetos en Python. Explica cómo crear clases, objetos, herencia y polimorfismo. También cubre temas como sobrecarga de operadores, métodos especiales y tratamiento de excepciones.
Este documento presenta el código de varios ejercicios de programación en C++ que involucran el uso de funciones, procedimientos, recursividad y estructuras. Los ejercicios incluyen calcular factoriales, sumatorias, combinatorias y secuencias de Fibonacci de manera recursiva y mediante el uso de vectores y arreglos de estructuras para almacenar datos de estudiantes y realizar operaciones sobre ellos.
Este documento describe los arreglos y su estructura en C. Los arreglos permiten almacenar múltiples datos del mismo tipo en una sola variable. Un arreglo tiene un tamaño, tipo y nombre. Los elementos de un arreglo se acceden mediante índices enteros. Los arreglos pueden ser unidimensionales o multidimensionales y se pueden inicializar y recorrer con bucles.
Un programa en C consta de tres partes principales: 1) el encabezamiento que declara variables y tipos de datos globales, 2) la función principal main que define la estructura del programa, y 3) funciones auxiliares llamadas por main. Los programas grandes se dividen en múltiples módulos compilados y enlazados separadamente. Las variables reservan memoria para almacenar valores de datos mientras que las constantes definen valores fijos a través de nombres simbólicos.
El documento describe los conceptos básicos de los archivos, incluyendo su estructura, tipos (texto y binario), y operaciones comunes como abrir, leer, escribir y cerrar. También explica cómo manejar archivos en C++ usando streams y seek para moverse por el archivo.
El documento describe diferentes temas relacionados con punteros en C, incluyendo cómo declarar y utilizar punteros, punteros a arrays, punteros a funciones y punteros a estructuras. También incluye ejemplos de código y ejercicios propuestos para practicar el uso de punteros.
Este documento presenta varios problemas de programación en C++ resueltos utilizando punteros, ordenamiento, búsqueda, recursividad y estructuras. El último problema propone un programa para una clínica privada que permita introducir información de pacientes, buscarla por número de DNI, listar pacientes con alergias y ordenar alfabéticamente pacientes que no pertenecen a la seguridad social.
El documento describe las estructuras y uniones en C. Las estructuras permiten agrupar múltiples tipos de datos bajo un solo nombre, mientras que las uniones almacenan múltiples campos en la misma posición de memoria. El documento explica cómo declarar, definir variables, acceder e inicializar estructuras, así como el uso de estructuras anidadas, arrays de estructuras y estructuras como parámetros. También cubre uniones, enumeraciones y campos de bits.
Este documento proporciona una introducción a los arreglos unidimensionales y multidimensionales en C++. Explica cómo declarar y acceder a elementos de arreglos, asignar valores entre arreglos, y realizar operaciones básicas como llenado y visualización de arreglos. También incluye ejemplos de código para ilustrar el uso de arreglos unidimensionales y multidimensionales.
El documento explica los diferentes tipos de ciclos en programación (while, do-while y for) y cómo funcionan. Proporciona ejemplos de código para ilustrar cómo se usan estos ciclos para repetir bloques de código un número determinado de veces o mientras se cumpla una condición. También advierte sobre los ciclos infinitos que pueden ocurrir si la condición nunca se vuelve falsa.
El documento explica las estructuras de control en C++, incluyendo el estatuto if, if-else, y switch. El estatuto if ejecuta una sección de código si una condición es verdadera, y if-else ejecuta una sección u otra dependiendo de si la condición es verdadera o falsa. El estatuto switch ejecuta diferentes secciones de código dependiendo del valor de una variable. También cubre if anidados, que permiten múltiples condiciones.
Este documento presenta una guía para leer y entender programas escritos en C++. Explica conceptos fundamentales como llamadas por valor y referencia, uso de punteros, clases y objetos. Muestra ejemplos simples de funciones, programas y una clase Point completa con diferentes constructores, operadores y funciones miembro. El objetivo es proporcionar una introducción básica a la sintaxis y características del lenguaje C++.
El documento describe los conceptos básicos de las funciones en C, incluyendo su estructura, parámetros, prototipos, ámbito y tipos. Explica que una función es un conjunto de instrucciones agrupadas bajo un nombre que puede ser llamado múltiples veces, y que las funciones permiten dividir un programa en módulos independientes.
Un puntero es un dato que contiene una dirección de memoria. Se declara con un tipo de dato seguido de un asterisco, como int *ptr. Los punteros permiten acceder y modificar los valores de las variables a las que apuntan usando los operadores & para obtener la dirección y * para acceder al valor. Los punteros se pueden utilizar para pasar parámetros, implementar estructuras de datos dinámicas como vectores y matrices, y realizar operaciones como intercambiar valores.
El documento describe las funciones en lenguaje C. Explica que las funciones dividen un programa en bloques más pequeños y reutilizables. Detalla que las funciones pueden recibir parámetros, devolver valores, y tener variables locales y globales. También cubre temas como prototipos de funciones, paso de parámetros por valor y referencia, y el uso de funciones para resolver problemas de manera más eficiente.
El documento contiene varios programas de C++ que muestran ejemplos del uso de diferentes tipos de datos, operadores, estructuras de control y funciones. Los programas cubren temas como variables enteras, flotantes y booleanas, operadores aritméticos, de comparación y lógicos, condicionales if-else y switch-case, bucles while, for y do-while, arrays, funciones y clases.
El documento contiene varios ejemplos de código C++ que muestran el uso de diferentes tipos de variables (enteras, booleanas, float, double), operadores (aritméticos, de comparación, lógicos), estructuras de control (if, switch, while, for), funciones, clases y métodos. Los ejemplos van desde "Hola Mundo" hasta cálculos más complejos como el cálculo del sueldo de empleados y operaciones matemáticas con números.
El documento contiene varios programas de C++ que muestran ejemplos del uso de diferentes tipos de datos, operadores, estructuras de control y funciones. Los programas cubren temas como variables enteras, flotantes y booleanas, operadores aritméticos, de comparación y lógicos, condicionales if-else y switch-case, bucles while, for y do-while, arrays, funciones y clases.
Las funciones son bloques de construcción básicos en C que dividen un problema en subtareas más simples. Las funciones facilitan el diseño del programa, permiten reutilizar código y ocultar detalles de implementación. Pueden transferir información por valor o por referencia y devolver un valor. Los prototipos especifican el tipo y número de parámetros de una función.
Este documento describe los conceptos básicos de la programación orientada a objetos en C++. Explica las clases, objetos, constructores, destructores, sobrecarga de operadores, funciones amigas y constructores de copia. También cubre temas como el manejo de ficheros, formatos de entrada y salida, y constructores parametrizados.
Este documento presenta varias actividades relacionadas con estructuras de datos y algoritmos de ordenamiento. La primera actividad muestra el uso de un arreglo bidimensional para almacenar y mostrar datos. Otras actividades incluyen el cálculo de promedios, el uso de estructuras para almacenar nombres y edades, y realizar operaciones matemáticas básicas. También se explican conceptos como recursividad, apuntadores, árboles y métodos de ordenamiento como quicksort, radix sort y shellsort.
Introducción a la programación en c++.
Contenido:
-Tipos de datos
-Entrada y salida por consola
-String
-Preprocesador
-Operadores y sentencias de control
-Punteros
-Arrays
-Cadenas de caracteres
-Memoria dinámica
-Introducción a la POO en c++
-Referencias
El documento presenta una introducción al lenguaje de programación C++. Explica que C++ extiende el lenguaje C con conceptos de orientación a objetos. Luego, resume los principales temas que se cubrirán, incluyendo clases, herencia, sobrecarga de operadores, plantillas, excepciones y la biblioteca estándar de C++. Finalmente, incluye una breve bibliografía.
El documento presenta una introducción al lenguaje de programación C++. Explica que C++ extiende el lenguaje C con conceptos de orientación a objetos. Luego, resume los principales temas que se abordarán, incluyendo clases, herencia, sobrecarga de operadores, plantillas, excepciones y la biblioteca estándar de C++. Finalmente, incluye una breve bibliografía sobre el tema.
El documento describe los métodos en Java, incluyendo métodos de objeto y métodos de clase. Explica las características de cada tipo de método como la visibilidad, los parámetros, el cuerpo y cómo se llaman. También proporciona ejemplos de cómo definir y usar métodos en una clase.
El documento presenta ejemplos del uso de plantillas (templates) en C++. En primer lugar, muestra ejemplos de templates de función para comparar valores y ordenar arrays genéricos. Luego, presenta un template de clase para comparar valores que define métodos para obtener el valor mínimo, máximo e igualdad. Finalmente, implementa un template de clase Pila y su uso para apilar y desapilar valores genéricos.
Este documento presenta una introducción a la programación orientada a objetos en Python. Explica conceptos clave como clases, objetos, atributos, métodos, constructores y variables de instancia. También muestra ejemplos de cómo definir una clase Circle que modela un círculo, crear instancias de objetos Circle y acceder a sus atributos y métodos.
Este documento proporciona una introducción a C++, describiendo conceptos como programación orientada a objetos, clases, objetos, encapsulación, polimorfismo, herencia, constructores y destructores. Explica las diferencias entre C y C++ y ofrece ejemplos de cómo crear clases, objetos y usar funciones miembro. También cubre temas como entrada/salida por consola y formato de salida.
Este documento introduce el lenguaje C# y sus características principales. Explica que C# es un lenguaje derivado de C y C++ diseñado para el desarrollo en .NET. Detalla la estructura básica de un programa C# incluyendo espacios de nombres, clases, estructuras e interfaces. También describe variables, constantes, arrays, expresiones, operadores, sentencias de control de flujo y otros elementos del lenguaje.
El documento habla sobre arreglos (arrays) unidimensionales. Explica que un arreglo es una colección ordenada de elementos del mismo tipo y que los arreglos unidimensionales son secuencias de elementos como x[1], x[2], ..., x[n]. También describe operaciones básicas con arreglos como lectura, escritura, actualización y ordenamiento de elementos.
El seminario destacó la importancia de que los gobiernos locales y regionales tomen decisiones para gestionar mejor los cambios climáticos y reducir riesgos de desastres. La sequía en la región de Puno amenaza al sector agropecuario, disminuyendo los rendimientos de cultivos, pastos y ganado, y poniendo en riesgo la seguridad alimentaria. Se proponen estrategias como el uso eficiente del agua, cultivos resistentes, protección de suelos y sistemas silvopastoriles para reducir los ries
Este documento presenta una introducción a las nuevas etiquetas semánticas de HTML5 como <header>, <nav>, <section>, <article>, <aside> y <footer>. Estas etiquetas reemplazan el uso de <div> para darle significado semántico a las diferentes secciones de una página web como la cabecera, navegación, contenido principal, contenido relacionado y pie de página. El documento también incluye un ejemplo de cómo usar estas etiquetas en la estructura básica de un blog construido con HTML5.
Este documento describe las características y funcionalidades del paquete de oficina Microsoft Office 365. Incluye programas como Word, Excel, PowerPoint, Outlook y OneDrive. Explica que Office 365 se alquila por un año y permite el acceso a los programas desde cualquier dispositivo. También incluye instrucciones paso a paso para crear documentos en Word, agregar formato a texto e imágenes, crear tablas y encabezados, e insertar referencias y citas bibliográficas.
Este documento trata sobre el emprendimiento en la era del conocimiento. Brevemente describe cómo la sociedad actual es una sociedad de la información basada en el conocimiento, la innovación y la tecnología. También resalta la importancia de la innovación para las empresas y la necesidad de que los países mejoren sus indicadores de innovación para ser más competitivos a nivel global.
Este documento presenta los fundamentos de la programación. Explica conceptos clave como informática, computadoras, hardware, software, programación e historia de los lenguajes de programación. También introduce conceptos de sintaxis y semántica de los lenguajes de programación y presenta un primer programa "Hola Mundo" en C++.
El documento presenta organizadores visuales sobre las corrientes contemporáneas de la educación en un curso de Planificación Curricular Universitaria impartido en la Universidad Nacional del Altiplano, Facultad de Ciencias de la Educación, Programa de Segunda Especialidad.
Este documento es un reporte de un estudiante de la Universidad Nacional del Altiplano en la Facultad de Ciencias de la Educación. El estudiante se llama Aldo Zanabria Gálvez y está cursando la Unidad de Segunda Especialidad.
El documento discute la importancia del aprendizaje mutuo entre maestro y alumno, y propone una metodología de enseñanza basada en formas sociales, esquemas de acción y pasos de la enseñanza que constituyen una amplia forma metódica. También critica las tradiciones educativas centradas en el maestro más que en el aprendizaje del alumno. Finalmente, argumenta que la enseñanza debe adaptarse a los cambios sociales y hacer un uso efectivo de las nuevas tecnologías para apoyar contextos
El documento discute las diferentes escuelas de pensamiento en didáctica, incluyendo la escuela anglosajona que busca estandarizar los contenidos, la escuela alemana que se enfoca en lo formativo y la normativa estatal, la escuela francesa que aplica métodos científicos, la escuela soviética con énfasis colectivo y descentralización del maestro, y la escuela latinoamericana que evalúa la diversidad cultural. Concluye que mientras las primeras escuelas enfatizan más lo político, las últimas
Los carolinos del milenio pasado nacieron entre 1980 y 1989. Jugaban en la calle y disfrutaban programas como "Las Tortugas Ninja" y "Los Pitufos". Creían que eran la última generación cuerda porque crecieron sin mucha tecnología pero se divertían igual. Ahora se reúnen en Facebook y aseguran que fueron felices en esa época.
El documento habla sobre la carrera de Ingeniería de Sistemas en la Universidad Nacional. Explica que a pesar de ser una carrera relativamente nueva, es importante para preparar recursos humanos calificados en informática. También define la naturaleza de la profesión de Ingeniería de Sistemas y discute las aplicaciones e importancia de esta carrera para el desarrollo del país. Finalmente, presenta estadísticas sobre la carrera e información sobre sus objetivos.
Este documento describe las principales fuentes de energía renovable en Perú, incluyendo energía hidroeléctrica, solar, eólica, biomasa y geotérmica. Explica sus ventajas y el potencial de cada recurso en el país. También resume el marco normativo para promover la generación eléctrica con energías renovables a través de subastas, donde se otorgan contratos de concesión de 20 años con una tarifa garantizada. El objetivo es mejorar la calidad de vida y proteger el medio ambiente mediante la inversión en
El documento describe los diferentes tipos de variables que pueden utilizarse en una investigación. Explica que las variables pueden ser cualitativas o cuantitativas, individuales o colectivas, y nominales, ordinales o de intervalo/razón dependiendo de la escala de medición. También distingue entre variables independientes, dependientes e indicadores operacionales.
En 3 oraciones o menos:
El documento presenta información sobre un diplomado especializado en gestión pública de gobiernos regionales y locales. Incluye definiciones de siglas comunes, diagramas de la estructura y niveles de articulación de los gobiernos, y discute conceptos como diseño institucional, desarrollo organizacional municipal y nueva gestión pública.
Este documento describe el marco legal y las funciones de la Autoridad Nacional del Agua (ANA) en Perú relacionadas con la gestión de la calidad del agua. La ANA es responsable de clasificar los cuerpos de agua, autorizar los vertimientos de aguas residuales tratadas, y realizar el monitoreo y vigilancia de la calidad del agua a nivel nacional. El documento también explica los procedimientos para obtener una autorización de vertimiento de aguas residuales tratadas de acuerdo con la legislación peruana.
Este documento resume las principales herramientas digitales que pueden ser útiles para el emprendimiento turístico. Incluye plataformas como WordPress, Facebook, TripAdvisor y Booking que pueden usarse para crear sitios web, realizar publicidad y reservas. También describe software como CRM y gestores de procesos que pueden usarse para administrar clientes, tareas y operaciones. Finalmente, menciona algunos servicios y aplicaciones desarrollados por GrupoSistemas para el sector turístico.
Este documento describe brevemente algunos componentes básicos de una computadora como el interruptor, la memoria y el procesador. Explica que el interruptor puede abrir o cerrar un circuito eléctrico para conectar o desconectar líneas telefónicas. La memoria se usa para almacenar datos en celdas direccionables. El procesador es el circuito integrado que procesa la información y controla las demás partes de la computadora. También menciona algunos dispositivos de entrada y salida como teclados,
Este documento describe un foro panel sobre la importancia y representatividad política de la mujer trabajadora que se llevará a cabo en Puno, Perú. El foro se centrará en promover la participación activa de las mujeres en la sociedad y generar mayor liderazgo femenino a nivel local, regional y nacional. Se presentarán ponencias sobre el pasado, presente y futuro de la mujer trabajadora, su realidad socioeconómica, y la ideología de la emancipación femenina. El evento contará con debates, intercambio de experiencias
Este documento presenta el marco normativo referencial existente para realizar tasaciones de bienes inmuebles en Perú. Incluye regulaciones como el Reglamento Nacional de Tasaciones, el Código Civil, el Código de Procedimientos Civiles, entre otros. También define términos clave relacionados a tasaciones como predio urbano, edificación, depreciación, valor comercial, entre otros. Finalmente, resume los componentes requeridos en un informe de tasación para predios urbanos como la memoria descriptiva, tasación del terreno, edificaciones y
El documento trata sobre la producción en empresas turísticas. Explica las características de la producción de servicios y las específicas de las empresas turísticas. Define el sistema de producción como el proceso de transformar insumos en productos a través de entradas, procesos de transformación y salidas. Finalmente, cubre la administración y control de la producción a través de objetivos, decisiones y presupuestos.
1. Tema 3: C++ Parte II
Arrays vs punteros, Consideraciones Prácticas
Existe una equivalencia casi total entre arrays y punteros
✑ Declaramos un puntero del mismo tipo que los elementos del array, y que apunta
al primer elemento del array.
✒ Reservamos memoria para todos los elementos del array. Los elementos de un
array se almacenan internamente en el ordenador en posiciones consecutivas de la
memoria.
✓ el nombre de un array es un puntero constante, no podemos hacer que apunte a otra dirección de
memoria.
✔ ✥l compilador asocia una zona de memoria para los elementos del array, cosa que no hace para
los elementos apuntados por un puntero auténtico.
Ejemplo:
int vector[10];
int *puntero;
puntero = vector; /* Equivale a puntero = &vector[0];
esto se lee como "dirección del primer de vector" */
(*puntero)++; /* Equivale a vector[0]++; */
puntero++; /* puntero equivale a &vector[1] */
¿Qué hace cada una de estas instrucciones?:
La primera incrementa el contenido de la memoria apuntada por "puntero", que es
vector[0].
La segunda incrementa el puntero, esto significa que apuntará a la posición de memoria
del siguiente "int", pero no a la siguiente posición de memoria. El puntero no se
incrementará en una unidad, como tal vez sería lógico esperar, sino en la longitud de un
"int".
int main(int argc, char *argv[])
{
Objeto vector[10];
Objeto *puntero;
for(int i=0;i<10;i++) vector[i].nombrar();;
puntero = vector; // Equivale a puntero =
&vector[0];
puntero +=5; //Avanza 5 posiciones en
tamaños de Objeto
cout <<"n";
for(int i=0;i<5;i++) {
puntero->nombrar();
(*puntero).nombrar();
puntero++;
}
1
2. Uso del Puntero Generico y el operador de casting
#include <iostream>
using namespace std;
int main() {
char cadena[10] = "Hola";
char *c;
int *n;
void *v;
c = cadena; // c apunta a cadena
n = (int *)cadena; // n también apunta a cadena
v = (void *)cadena; // v también
cout << "carácter: " << *c << endl;
cout << "entero: " << *n << endl;
cout << "float: " << *(float *)v << endl;
cin.get();
return 0;
}
El resultado será:
carácter: H
entero: 1634496328
float: 2.72591e+20
2
3. Punteros como parámetros de funciones: referencia y valor
#include <iostream>
using namespace std;
void funcion(int *q);
int main() {
int a;
int *p;
a = 100;
p = &a;
// Llamamos a funcion con un puntero funcion(p);
cout << "Variable a: " << a << endl;
cout << "Variable *p: " << *p << endl;
// Llamada a funcion con la dirección de "a" (constante)
funcion(&a);
cout << "Variable a: " << a << endl;
cout << "Variable *p: " << *p << endl;
}
void funcion(int *q) {
// Cambiamos el valor de la variable apuntada por
// el puntero
*q += 50;
q++;
}
//para hacerlo por referencia
void funcionRef(int *&q) {
// Cambiamos el valor de la variable apuntada por
// el puntero y el puntero
*q += 50;
q++;
}
3
4. Arrays como parámetros de funciones
Se pasa un puntero al primer elemento.
• si sólo pasamos el nombre del array de más de una dimensión no podremos
• acceder a los elementos del array mediante subíndices, ya que la función no tendrá información
sobre el tamaño de cada dimensión. declarar el parámetro como un array
void funcion(int tabla[][10]) {
...
cout << tabla[2][4] << endl;
}
int main() {
int Tabla[5][10];
...
funcion(Tabla);
...
return 0;
}
Arrays Dinámicos
los arrays tienen un inconveniente: hay que definir su tamaño y después no puede ser
modificado.
Solución : punteros a puntero : int **tabla; //Puntero a puntero a int
#include <iostream>
using namespace std;
int main() {
int **tabla;
int n = 134;
int m = 231;
int i;
// Array de punteros a int:
tabla = new int*[n];
// n arrays de m ints
for(i = 0; i < n; i++)
tabla[i] = new int[m];
tabla[21][33] = 123;
cout << tabla[21][33] << endl;
// Liberar memoria:
for(i = 0; i < n; i++) delete[] tabla[i];
delete[] tabla;
cin.get();
return 0;
}
4
5. Funciones friend
Dentro de una clase se pueden declarar funciones como amigas. Las funciones amigas no son
métodos de clase sino funciones que se definen realmente fuera del ámbito de la clase, esto es, son
accesibles desde nuestro programa como una llamada a función normal, no como una invocación de
método.
Las funciones amigas de una clase tienen acceso a todos los atributos y métodos de la clase,
incluyendo tanto públicos como privados y protegidos.
Son un detalle excepcional de C++ y violan el principio de encapsulamiento de la programación
orientada a objetos. Sin embargo, son útiles en ciertas ocasiones. Sobre todo para determinados casos de
sobrecarga operadores.
Punto #include <cstdlib>
#include <iostream>
- int x
- int y using namespace std;
+ Punto( int x=0, int y=0 ) class Punto{
// función amiga
+ void pinta() friend Punto sumapuntos( const Punto p1, const Punto p2 );
Friend Punto sumapuntos
private:
( const Punto p1, const Punto p2 ) int x;
int y;
public:
Punto( int nx=0, int ny=0 ){ x=nx; y=ny; }
void pinta(){ cout << "(" << x << "," << y << ")n"; }
};
Punto sumapuntos( Punto p1, Punto p2 ){
Punto res;
/* ¡¡ Acceso a atributos privados !!*/
res.x = p1.x + p2.x;
res.y = p1.y + p2.y;
return res;
}
int main(int argc, char *argv[])
{
Punto p1(10,10), p2(20,20);
Punto p3 = sumapuntos( p1,p2 );
p3.pinta();
system("PAUSE");
return EXIT_SUCCESS;
}
5
6. Clases friend
Dentro de una clase se pueden declarar otras clases como amigas. Las clases amigas tendrán
acceso a todos los atributos y métodos de la clase, incluyendo tanto públicos como privados y
protegidos.
Punto #include <cstdlib>
#include <iostream>
- int x
using namespace std;
- int y
class Punto{
+ Punto( int x=0, int y=0 ) friend class Amiga; // clase amiga
+ void pinta() private:
int x;
Friend class Amiga
int y;
public:
Punto( int nx=0, int ny=0 ){ x=nx; y=ny; }
void pinta(){ cout << "(" << x << "," << y << ")n"; }
};
Amiga
class Amiga{
public:
+ void ponACero( Punto &p ) void ponACero( Punto &p ){
p.x = 0;
p.y = 0;
}
};
int main(int argc, char *argv[])
{
Punto p1(10,10);
Amiga a;
a.ponACero( p1 );
p1.pinta();
system("PAUSE");
return EXIT_SUCCESS;
}
6
7. Clases friend (caso de referencia cruzada)
Es posible que tengamos dos clases tales que la primera deba ser amiga de la segunda y la
segunda de la primera también. En este caso, tenemos el problema de que no podemos utilizar una clase
antes de declararla. La solución consiste en redirigir la declaración de la clase que definimos en
segundo lugar.
Cuando se redirige una clase, se pueden declarar variables de ese tipo y punteros. Básicamente,
podemos declarar los prototipos pero, como aún no se han declarado los atributos y métodos reales de la
clase redirigida, no se pueden invocar. La solución es sólo hacer las declaraciones primero y luego
definir los métodos.
Amiga1 #include <cstdlib>
#include <iostream>
- int privada using namespace std;
+ void modificaAmiga2 class Amiga2; // Redirección de la declaración
( Amiga2 &a2, int val )
class Amiga1{
+ void pinta() friend class Amiga2;
Friend class Amiga2
private:
int privada;
public:
Amiga2 void modificaAmiga2( Amiga2 &a2, int val );
/* Aquí no podemos definir el método porque aún no hemos declarado
- int privada que la clase Amiga2 tiene un atributo int privada... */
void pinta(){ cout << privada << "n"; }
+ void modificaAmiga1 };
( Amiga1 &a1, int val )
class Amiga2{
+ void pinta()
friend class Amiga1;
Friend class Amiga1
private:
int privada;
public:
void modificaAmiga1( Amiga1 &a1, int val );
/* Aquí sí podríamos definir porque ya hemos declarado Amiga1 */
void pinta(){ cout << privada << "n"; }
};
/* Ahora sí que podemos definir el método porque ya hemos declarado
que la clase Amiga2 tiene un atributo int privada... */
void Amiga1::modificaAmiga2( Amiga2 &a2, int val ){
a2.privada = val;
}
void Amiga2::modificaAmiga1( Amiga1 &a1, int val ){
a1.privada = val;
}
int main(int argc, char *argv[])
{
Amiga1 a1;
Amiga2 a2;
a1.modificaAmiga2(a2,10);
a2.modificaAmiga1(a1,20);
a1.pinta();
a2.pinta();
system("PAUSE");
return EXIT_SUCCESS;
}
7
8. Sobrecarga de Operadores
Operadores que tienen varios usos, como por ejemplo *,+,-
C++ podemos definir varias funciones con el mismo nombre, con la única
condición de que el número y/o el tipo de los parámetros sean distintos
Si ninguna de las funciones se adapta a los parámetros indicados, se
aplicarán las reglas implícitas de conversión de tipos.
No se pueden definir nuevos operadores ni cambiar la aridad.
Se pueden sobrecargar como funciones o como métodos de clase.
En los operadores definidos como métodos miembros, el objeto perteneciente a la clase
dónde se define el método es el primer operando siempre, de modo que si queremos que
nuestros objetos puedan operar funcionando como operandos en la parte derecha, será
necesario hacerlo en una función (posiblemente friend) o en un método de la clase del
operando que quede a la izquierda (posiblemente friend)…
Prototipo:
<tipo> operator <operador> (<argumentos>);
Definición:
<tipo> operator <operador> (<argumentos>)
{
<sentencias>;
}
class complejo
{public:
float a,b;
complejo( int entera=0, int compleja=0){
a=entera;
b=compleja;
}
};
complejo operator +(complejo a, complejo b) {
complejo temp (a.a+b.a, a.b+b.b);
return temp;
}
int main() {
complejo x(10,32);
complejo y (21,12);
complejo z;
/* Uso del operador sobrecargado + con complejos */
z = x + y;
cout << z.a << "," << z.b << endl;
8
9. La forma adecuada de implementar el operador es con un parámetro:
class complejo
{public:
float a,b;
complejo( int entera=0, int compleja=0){
a=entera;
b=compleja;
}
complejo operator +(complejo comp) {
complejo temp;
temp.a+=a+ comp.a;
temp.b+=b+ comp.b;
return temp;
}
};
int main() {
complejo x(10,32);
complejo y (21,12);
complejo z;
/* Uso del operador sobrecargado + con complejos */
z = x + y;
cout << z.a << "," << z.b << endl;
}
También hemos usado el operador =, a pesar de que nosotros no lo hemos
definido. Esto es porque el compilador crea un operador de asignación por defecto si
nosotros no lo hacemos.
Sobrecarga Operador =
Si en nuestro programa declaramos dos objetos de tipo Cadena, y los asignamos, estaremos
apuntando al mismo objeto cadena en lugar de producir una copia.
class Cadena {
public:
Cadena(char *cad);
Cadena() : cadena(NULL) {};
~Cadena() { delete[] cadena; };
void Mostrar() const;
private:
char *cadena;
};
Cadena::Cadena(char *cad) {
cadena = new char[strlen(cad)+1];
strcpy(cadena, cad);}
9
10. Cadena &Cadena::operator=(const Cadena &c) {
if(this != &c) {//si soy yo hacer nada
delete[] cadena;
if(c.cadena) {//si no es NULL
cadena = new char[strlen(c.cadena)+1];
strcpy(cadena, c.cadena);
}
else cadena = NULL;
}
return *this;
}
Esto permite realizar asignaciones del tipo
Cadena c1(“hola”), c2;
c2=c1;
Sobrecarga de operadores unarios
class complejo {
…
complejo operator ++(int sufijo) {// el parámetro no se utiliza, pero lo diferencia del prefijo
a++;
b++;
return *this;
}
complejo operator ++() {//prefijo
++ a;
++b;
return *this;
}
};
int main() {
complejo z(10,32);
z++;
cout << z.a << "," << z.b << endl;
++z;
cout << z.a << "," << z.b << endl;
}
Los operadores =, [], () y -> sólo pueden sobrecargarse en el interior de clases.
10
11. Sobrecarga de <<
Punto #include <cstdlib>
#include <iostream>
- static int numserie
- int *identificador using namespace std;
+ int x
+ int y class Punto{
+ Punto( int x, int y ) friend ostream& operator<<( ostream &salida, const Punto p ){
+ ~Punto() // acceso a datos protected y private...
+ int operator==( Punto p ) salida << *p.identificador <<":(" << p.x << "," << p.y << ")";
+ Punto operator=( Punto p ) return salida;
Friend: ostream& operador<< }
( ostream &salida,
const Punto p ) private:
static int numserie;
En funciones friend: int *identificador;
Primer parámetro: operando de public:
izquierda. int x;
Segundo parámetro: operando int y;
de la derecha (en binarios). Punto(int nx, int ny){ x=nx; y=ny; identificador=new int(numserie++); }
En miembros, a la izquierda va ~Punto(){ delete identificador; }
el objeto. int operator==( Punto p ){ return (x==p.x)&&(y==p.y); }
Se usan friend para Punto operator=( Punto p )
conmutatividad también. { x=p.x, y=p.y; /*no se sobrescribe la serie*/
return p;}
};
int Punto::numserie = 0;
Cuando una función friend se
define fuera de la clase, no se int main(int argc, char *argv[])
escribe friend ni el resolutor de {
ámbito. La función no es Punto p1(10,15), p2(10,15), p3(0,0);
realmente un método. cout << p1 << ((p1==p2)?"==":"!=") <<p2 << "n" ;
p2.x++;
cout << p1 << ((p1==p2)?"==":"!=") <<p2 << "n" ;
Existen casos especiales con el p3=p2=p1;
operador de asignación cuando cout << p1 << " " << p2 << " " << p3 << "n";
el objeto que se copia se cout << p1 << ((p1==p3)?"==":"!=") <<p3 << "n" ;
declaró como un puntero. Hay
que comprobar si se copia el system("PAUSE");
mismo o si se le asigna un return EXIT_SUCCESS;
NULL. }
Operadores sobrecargables:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <=
>= && || ++ -- ->* , -> [] () new new[] delete delete[]
Operadores no sobrecargables:
. .* :: ?: sizeof
Con la sobrecarga del operador << es necesario utilizar la funcion friend. Es posible tener
comportamiento similar sobrecargando char*
11
12. Conversiones de Tipos
Tiempo T1(12,23);
unsigned int minutos = 432;
T1 += minutos;
Con toda probabilidad no obtendremos el valor deseado, no hemos definido el
comportamiento para un casting entero a Tiempo.
Para ello hace falta sobre cargar el constructor:
Tiempo(unsigned int m) : hora(0), minuto(m) {
while(minuto >= 60) {
minuto -= 60;
hora++;
}
}
Pero si lo que queremos es producir un entero:
Tiempo T1(12,23);
int minutos;
minutos = T1;
class Tiempo {
...
operator int();
...
operator int() {
return hora*60+minuto;
}
12
13. Ejemplo 2: Operador de conversión de tipo
Punto #include <cstdlib>
#include <iostream>
- static int numserie #include <stdio.h>
- int *identificador #include <string.h>
+ int x
+ int y using namespace std;
+ Punto( int x, int y ) class Punto{
+ ~Punto()
+ int operator==( Punto p ) private:
+ Punto operator=( Punto p ) static int numserie;
+ operator char*() int *identificador;
public:
int x;
int y;
Punto(int nx, int ny){ x=nx; y=ny; identificador=new int(numserie++); }
~Punto(){ delete identificador; }
int operator==( Punto p ){ return (x==p.x)&&(y==p.y); }
Punto operator=( Punto p ){
x=p.x, y=p.y;/*no se sobrescribe la serie*/
return p;}
operator char*(){
char salida[30];
sprintf( salida, "%i:(%i,%i)",*identificador, x, y );
return strdup( salida );
}
};
int Punto::numserie = 0;
int main(int argc, char *argv[])
{
Punto p1(10,15), p2(10,15);
cout << p1 << ((p1==p2)?"==":"!=") <<p2 << "n" ;
system("PAUSE");
return EXIT_SUCCESS;
}
13
14. Espacios con nombre
namespace [<identificador>] {
...
<declaraciones y definiciones>
...
#include <iostream>
namespace uno {
int x;
}
namespace dos {
int x;
}
using namespace uno;
int main() {
x = 10;
dos::x = 30;
std::cout << x << ", " << dos::x << std::endl;
std::cin.get();
return 0;
}
14
15. Punto (grafico) #include <cstdlib>
+ int x #include <iostream>
+ int y using namespace std;
+ int color
namespace grafico{
+ Punto()
+ operator char* () class Punto{
public:
int x;
int y;
int color;
Punto(){ x=0; y=0; }
Circulo (grafico) operator char*(){ return "Punto gráficon"; }
};
class Circulo: public Punto{
+ operator char* () public:
operator char*(){ return "Círculon"; }
};
}
Punto (matematico)
+ double x namespace matematico{
+ double y
class Punto{
+ operator char* ()
public:
double x;
double y;
operator char*(){ return "Punto matemáticon"; }
};
}
using namespace grafico;
int main(int argc, char *argv[])
{
Punto p1;
matematico::Punto p2;
grafico::Circulo c1;
cout << p1 << p2 << c1;
system("PAUSE");
return EXIT_SUCCESS;
}
15
16. Funciones miembro constantes
Cuando una función miembro no modifique el valor de la clase, se debe declarar constante .
Se pueden crear objetos constantes. Los métodos de estos objetos no modifican el estado del objeto.
Sintaxis
const detrás del nombre y la lista de argumentos del método. Los métodos definidos como const están
disponibles para los objetos normales.
Dentro de un método const no se pueden modificar los atributos de clase y sólo se puede llamar a
los métodos const de la clase.
class Ejemplo2 {
public:
Ejemplo2(int a = 0) : A(a) {}
void Modifica(int a) { A = a; }
int Lee() const { return A; }
private:
int A;
};
int main() {
Ejemplo2 X(6);
cout << X.Lee() << endl;
X.Modifica(2);
cout << X.Lee() << endl;
}
Valores de retorno constantes
class cadena {
public:
cadena(char *c){cad=c;}
const char *Leer() {
return cad; // el compilador no dejará modificarlo
}
private:
char *cad;
};
int main() {
char *cadena2;
cadena Cadena1("hola");
cout << Cadena1.Leer() << endl; // Legal
cadena2= Cadena1.Leer() ; // Ilegal
Cadena1.Leer()[1] = 'O'; // Ilegal
}
La declaración de variables constantes evita que se puedan utilizar métodos que no sean constantes.
Const Punto p(0,0). // cuando un punto de origen no debe cambiar durante la ejecución.
Otros ejemplos:
16
17. Punto #include <cstdlib>
#include <iostream>
#include <stdio.h>
- int x #include <string.h>
- int y
using namespace std;
+ Punto( int x, int y )
+ operator char* () const class Punto{
+ int getx () const private:
+ int gety () const int x;
+ void setx ( int x ) int y;
public:
+ void sety ( int y ) Punto( int nuevax, int nuevay ){
x = nuevax;
y = nuevay;
}
/* Los métodos de cambio de las coordenadas no
deben ser invocados por objetos constantes */
void setx( int nuevax ){ x = nuevax; }
void sety( int nuevay ){ y = nuevay; }
/* Los métodos de lectura de las coordenadas sí
deben ser invocados por objetos constantes */
int getx() const { return x; }
int gety() const { return y; }
/* La conversión también es accesible para constantes */
operator char*() const {
char salida[30];
sprintf( salida, "(%i,%i)",x,y );
return strdup( salida );
}
};
int main(int argc, char *argv[])
{
Punto p1(10,20);
const Punto p2(5,5);
cout << p1 << ":" << p2 << "n";
p1.setx(40);
// p2.setx(100); ¡ no se permite !
cout << p1 << ":" << p2 << "n";
system("PAUSE");
return EXIT_SUCCESS;
}
17
18. const
Punto #include <cstdlib>
#include <iostream>
- int x #include <stdio.h>
- int y #include <string.h>
+ Punto( int x, int y )
+ operator char* () const using namespace std;
+ int getx () const class Punto{
+ int gety () const private:
+ void setx ( int x ) int x;
+ void sety ( int y ) int y;
+ void setx ( int x ) const public:
Punto( int nuevax, int nuevay ){
+ void sety ( int y ) const x = nuevax;
y = nuevay;
}
/* Los métodos de cambio de las coordenadas no
deben ser invocados por objetos constantes */
Se pueden hacer dos
versiones para un método, void setx( int nuevax ){ x = nuevax; }
void sety( int nuevay ){ y = nuevay; }
una const y la otra no… void setx( int nuevax ) const{}
void sety( int nuevay ) const{}
/* Los métodos de lectura de las coordenadas sí
deben ser invocados por objetos constantes */
int getx() const { return x; }
int gety() const { return y; }
/* La conversión también es accesible para constantes */
operator char*() const {
char salida[30];
sprintf( salida, "(%i,%i)",x,y );
return strdup( salida );
}
};
int main(int argc, char *argv[])
{
Punto p1(10,20);
const Punto p2(5,5);
cout << p1 << ":" << p2 << "n";
p1.setx(40);
p2.setx(100); // se permite
cout << p1 << ":" << p2 << "n";
system("PAUSE");
return EXIT_SUCCESS;
}
18
19. Clases proxy
Existe un problema con las inclusiones de los .hpp: las declaraciones dejan ver gran parte de la
implementación. Todo lo que no es público se podría ocultar al programador externo. Esto es consistente
con el principio de ocultación.
ClaseImplementacion.hpp ClaseImplementacion
- int ocultable
#ifndef CLASEIMPLEMENTACION_HPP - int tope
#define CLASEIMPLEMENTACION_HPP
- metodoInterno()
class ClaseImplementacion{ # metodoInternoSubclase
private: + ClaseImplementacion( int tope )
int ocultable; + void apilar( int elemento )
int tope;
void metodoInterno();
protected:
void metodoInternoSubclases();
public:
ClaseImplementacion( int tope );
void apilar( int elemento );
};
#endif
ClaseImplementacion.cpp
#include <iostream>
#include "ClaseImplementacion.hpp"
void ClaseImplementacion::metodoInterno(){}
void ClaseImplementacion::metodoInternoSubclases(){}
ClaseImplementacion::ClaseImplementacion( int ntope ){
tope = ntope;
}
void ClaseImplementacion::apilar( int elemento ){
std::cout << "Apilando:" << elemento;
}
19
20. ClaseProxy.hpp
ClaseProxy
#ifndef CLASEPROXY_HPP
#define CLASEPROXY_HPP
+ ClaseProxy( int tope )
class ClaseImplementacion; + void apilar( int elemento )
+ ~ClaseProxy()
class ClaseProxy{
public:
ClaseProxy( int tope ); Se redirige la declaración de
void apilar( int elemento ); la clase ClaseImplementacion
~ClaseProxy()
private:
ClaseImplementacion *imp;
Se guarda una referencia a
};
ClaseImplementacion que se
inicializará en el constructor
#endif
ClaseProxy.cpp
Sólo ClaseProxy.cpp incluye
#include "ClaseProxy.hpp" las declaraciones en
#include "ClaseImplementacion.hpp" ClaseImplementacion.hpp, con
lo que se oculta la declaración
ClaseProxy::ClaseProxy( int tope ){ real
imp = new ClaseImplementacion( tope );
}
void ClaseProxy::apilar( int elemento ){
imp->apilar( elemento );
} Para compilar la prueba nos basta
ClaseProxy::~ClaseProxy(){ delete imp; } con tener ClaseProxy.hpp y el
objeto (o biblioteca) ya
Prueba.cpp compilado de la implementación.
Normalmente, ese fichero objeto
#include <cstdlib> (o biblioteca) incluirá el código
#include <iostream> (objeto) tanto de
#include "ClaseProxy.hpp" ClaseImplementacion como de
ClaseProxy
using namespace std;
int main(int argc, char *argv[])
{
ClaseProxy c(4);
c.apilar( 10 );
cout << "n";
system("PAUSE");
return EXIT_SUCCESS;
}
20
21. Static y Dinamic cast
Información de tipo (clase) en tiempo de ejecución: <typeinfo>
typeid y dynamic_cast.
static_cast<>
int a;
float b;
b = static_cast<float>(a);
#include <iostream>
using namespace std;
class Tiempo {
public:
Tiempo(int h=0, int m=0) : hora(h), minuto(m) {}
void Mostrar();
operator int() {
return hora*60+minuto;
}
private:
int hora;
int minuto;
};
void Tiempo::Mostrar() {
cout << hora << ":" << minuto << endl;
}
int main() {
Tiempo Ahora(12,24);
int minutos;
Ahora.Mostrar();
minutos = static_cast<int> (Ahora);
// minutos = Ahora; // Igualmente legal, pero implícito
cout << minutos << endl;
}
21
22. Punto #include <cstdlib>
#include <iostream>
+ virtual void pinta() using namespace std;
#include <typeinfo>
class Punto{
public:
Circulo virtual void pinta(){ cout << "Punton"; }
};
+ void pinta()
class Circulo:public Punto{
public:
virtual void pinta(){ cout << "Circulon"; }
};
int main(int argc, char *argv[])
{
Punto **array = new Punto * [2];
array[0] = new Punto;
array[1] = new Circulo;
for (int i=0; i<2; i++){
// Se pueden hacer comparaciones del tipo:
// if (typeid( *array[i] )==typeid( Punto ))
cout << typeid( *array[i] ).name() <<" ";
if ( Circulo *c = dynamic_cast<Circulo*>(array[i]) ){
cout << "Molde validon";
c->pinta();
}else
cout << "Molde NO validon";
}
system("PAUSE");
return EXIT_SUCCESS;
}
Permite acceder con un puntero base a funciones sólo existentes en la derivada.
22
23. String
Cadenas con <string>
C++, en su biblioteca estándar, nos provee de la clase string, que resuelve muchos problemas
clásicos con las cadenas C.
Puede buscar una referencia completa en Internet.
Por ejempo:
http://www.msoe.edu/eecs/cese/resources/stl/string.htm
http://www.cppreference.com/cppstring/
La cabecera está en <string>.
Existen varios constructores y se definen operadores como la concatenación (+, +=) y las
comparaciones ( <, >, ==, != ).
Se pueden transformar en una cadena C normal (método c_str)
Versión C++ Versión C
#include <cstdlib> #include <stdlib.h>
#include <iostream> #include <stdio.h>
#include <string> #include <string.h>
using namespace std; int main(int argc, char *argv[])
{
int main(int argc, char *argv[]) char *cad1="Una cadena";
{ char *cad2;
string cad1 = "Una cadena"; char *tmp;
string *cad2 = new string("Otra cadena"); cad2 = strdup( "Otra cadena" );
cad1 += " y " + *cad2 + "n";
/* Hay que reservar espacio suficiente!! */
cout << cad1; tmp = (char*)malloc(
(strlen(cad1)+
delete cad2; strlen(" y ")+
strlen(cad2)+
system("PAUSE"); strlen("n")+1)*sizeof(char) );
return EXIT_SUCCESS;
} strcpy( tmp, cad1 );
strcat( tmp, " y " );
strcat( tmp, cad2 );
strcat( tmp, "n" );
Se puede sustituir por:
printf( "%s", tmp );
sprintf( tmp,”%s y %sn” cad1, cad2 );
free(tmp);
free(cad2);
system("PAUSE");
return EXIT_SUCCESS;
}
23
24. Cadenas con <string>
Las cadenas de C++ sobrecargan también el operador [] de modo que se pueden usar como
arrays.
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <string> #include <string>
using namespace std; using namespace std;
int main(int argc, char *argv[]) void funcion( string str ){
{ for ( int i=0; i<str.size(); i++ )
string strCPP = "Una cadena C++n"; str[i] = '.';
char *strC = "Una cadena Cn"; }
int tamCPP, tamC;
int main(int argc, char *argv[])
tamCPP = strCPP.size(); {
tamC = strlen( strC ); string str = "ORIGINAL";
funcion(str);
for ( int i=0; i<tamCPP; i++ ) cout << str;
cout << " " << strCPP[i];
for ( int i=0; i<tamC; i++ ) system("PAUSE");
cout << " " << strC[i]; return EXIT_SUCCESS;
}
system("PAUSE");
return EXIT_SUCCESS;
}
Atención: las cadenas C++, al contrario que los arrays, son objetos, no punteros, de modo que se pasan
por copia cuando son argumentos de funciones:
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <string> #include <string>
using namespace std; using namespace std;
void f( string str ){ void f( string &str ){
for ( int i=0; i<str.size(); i++ ) for ( int i=0; i<str.size(); i++ )
str[i] = '.'; str[i] = '.';
} }
Paso por
int main(int argc, char *argv[]) referencia int main(int argc, char *argv[])
{ {
string str = "ORIGINAL"; string str = "ORIGINAL";
f( str ); f( str );
cout << str; cout << str;
system("PAUSE"); system("PAUSE");
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
24
25. Cadenas con <string>
String constructors create strings from arrays of characters and other strings
String operators concatenate strings, assign strings, use strings for I/O, compare strings
append append characters and strings onto a string
assign give a string values from strings of characters and other C++ strings
at returns an element at a specific location
begin returns an iterator to the beginning of the string
c str returns a standard C character array version of the string
capacity returns the number of elements that the string can hold
clear removes all elements from the string
compare compares two strings
copy copies characters from a string into an array
data returns a pointer to the first character of a string
empty true if the string has no elements
end returns an iterator just past the last element of a string
erase removes elements from a string
find find characters in the string
find first not of find first absence of characters
find first of find first occurrence of characters
find last not of find last absence of characters
find last of find last occurrence of characters
getline read data from an I/O stream into a string
insert insert characters into a string
length returns the length of the string
max size returns the maximum number of elements that the string can hold
push back add an element to the end of the string
rbegin returns a reverse iterator to the end of the string
rend returns a reverse iterator to the beginning of the string
replace replace characters in the string
reserve sets the minimum capacity of the string
resize change the size of the string
rfind find the last occurrence of a substring
size returns the number of items in the string
substr returns a certain substring
swap swap the contents of this string with another
25
26. • Assigning one string object's value to another string object
• string string_one = "Hello";
• string string_two;
string_two = string_one;
Assigning a C++ string literal to a string object
• string string_three;
string_three = "Goodbye";
• Assigning a single character (char) to a string object
• string string_four;
• char ch = 'A';
• string_four = ch;
string_four = 'Z';
• two string objects
• string str1 = "Hello ";
• string str2 = "there";
string str3 = str1 + str2; // "Hello there"
• a string object and a character string literal
• string str1 = "Hello ";
string str4 = str1 + "there";
• a string object and a single character
• string str5 = "The End";
string str6 = str5 + '!';
The comparison operators return a bool (true/false) value indicating whether the specified relationship
exists between the two operands. The operands may be:
• two string objects
• a string object and a character string literal
The extraction operator reads a character string from an input stream and assigns the value to a string
object.
string str1;
cin >> str1;
26
27. Excepciones en C++
C++ implementa manejo de excepciones. Las excepciones nos sirven para gestionar errores de
una forma homogénea. Previamente (en C) no existía un mecanismo definido para el tratamiento de
errores. Cada programador o grupo de desarrollo decidía cómo realizar esta tarea.
La idea subyacente es que un procedimiento lanzará (o elevará) una excepción de modo que en
el contexto superior se puede detectar una situación anormal.
Será responsabilidad del contexto superior el tomar las decisiones apropiadas en vista del error
detectado. Será posible también ignorar las excepciones que pueda elevar una determinada función o
método.
Las palabras reservadas de C++ en relación con las excepciones son:
throw: declara que una función o método lanza una excepción.
try: declara un bloque dentro del cual se puede capturar una excepción.
catch: declara un bloque de tratamiento de excepción.
Un primer ejemplo: división por 0
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
#include <exception> #include <exception>
using namespace std; using namespace std;
double divide( int dividendo, int divisor ){ double divide( int dividendo, int divisor ){
if ( divisor == 0 ) if ( divisor == 0 )
throw exception(); throw exception();
return (double)dividendo/divisor; return (double)dividendo/divisor;
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
cout << "Division correcta:" << divide(1,2) << cout << "Division correcta:" << divide(1,2) << endl;
endl; /* Este programa captura y trata la excepción */
/* Este programa termina automáticamente */ try{
cout << "Division por cero:" << divide(1,0) << cout << "Division por cero:" << divide(1,0) << endl;
endl; }catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
system("PAUSE"); }
return EXIT_SUCCESS; system("PAUSE");
} return EXIT_SUCCESS;
}
Cuando un bloque try se ejecuta sin lanzar excepciones, el flujo de control pasa a la instrucción
siguiente al último bloque catch asociado con ese bloque try.
27
28. Excepciones en C++
Podemos definir nuestras propias excepciones. Las excepciones se definen como clases.
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
using namespace std; using namespace std;
class ExcepcionDivCero{ class ExcepcionDivCero{
public: public:
ExcepcionDivCero(): mensaje( "Excepción: ExcepcionDivCero(): mensaje( "Excepción: división
división por cero" ) {} por cero" ) {}
const char *what() const{ return mensaje; } const char *what() const{
private: return mensaje;
char *mensaje; }
}; private:
char *mensaje;
double divide( int dividendo, int divisor ){ };
if ( divisor == 0 )
throw ExcepcionDivCero(); double divide( int dividendo, int divisor ){
return (double)dividendo/divisor; if ( divisor == 0 )
} throw ExcepcionDivCero();
return (double)dividendo/divisor;
int main(int argc, char *argv[]) }
{
cout << "Division correcta:" << divide(1,2) << int main(int argc, char *argv[])
endl; {
/* Este programa sale automáticamente... */ cout << "Division correcta:" << divide(1,2) << endl;
cout << "Division por cero:" << divide(1,0) << /* Este programa captura y trata la excepción */
endl; try{
cout << "Division por cero:" << divide(1,0) << endl;
system("PAUSE"); }catch( ExcepcionDivCero e ){
return EXIT_SUCCESS; cout << "Ocurrió una excepción: " << e.what();
} }
system("PAUSE");
return EXIT_SUCCESS;
}
28
29. Excepciones en C++
Las clases de excepciones pueden heredar de otras clases de excepción o no heredar de
nadie. La declaración de la clase básica exception está en la cabecera <exception>. Aunque no es
necesario, se suelen hacer subclases de exception o de otras clases de excepción que hayamos definido.
Esto se hace porque en los bloques match se capturan las excepciones de la clase que aparece o de
cualquier subclase de ella. La herencia debe ser pública.
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
class ExcepcionDivCero: public exception{
public:
ExcepcionDivCero(): mensaje( "Excepción: división por cero" ) {}
const char *what() const throw(){
return mensaje;
}
private:
char *mensaje;
};
double divide( int dividendo, int divisor ){
if ( divisor == 0 )
throw ExcepcionDivCero();
return (double)dividendo/divisor;
}
int main(int argc, char *argv[])
{
cout << "Division correcta:" << divide(1,2) << endl;
/* Este programa captura y trata la excepción */
try{
cout << "Division por cero:" << divide(1,0) << endl;
}catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
}
system("PAUSE");
return EXIT_SUCCESS;
}
29
30. Excepciones en C++
Como es posible que nuestras excepciones no deriven de ninguna clase base, C++ permite una
sentencia catch que capture cualquier clase que se eleve. La forma de hacer esto es con catch ( …)
Un bloque try puede tener varios bloques catch asociados. Cada bloque catch es un ámbito
diferente.
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
class ExcepcionDivCero: public exception{
public:
ExcepcionDivCero(): mensaje( "Excepción: división por cero" ) {}
const char *what() const throw(){
return mensaje;
}
private:
char *mensaje;
};
double divide( int dividendo, int divisor ){
if ( divisor == 0 )
throw ExcepcionDivCero();
return (double)dividendo/divisor;
}
int main(int argc, char *argv[])
{
cout << "Division correcta:" << divide(1,2) << endl;
/* Este programa captura y trata la excepción */
try{
cout << "Division por cero:" << divide(1,0) << endl;
}catch( ExcepcionDivCero e ){
cout << "Ocurrió una excepción: " << e.what();
}catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
}catch( ... ){
cout << "Ocurrió una excepción que no hereda de exception";
}
system("PAUSE");
return EXIT_SUCCESS;
}
30
31. Excepciones en C++
Se pueden tener varios bloques try anidados de modo que, si no se encuentran manejadores de
excepción en un bloque, se pasa a buscarlos al bloque inmediatamente superior. Si se sale de todos los
bloques anidados sin encontrar un manejador, el programa terminará (por defecto).
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
class ExcepcionDivCero: public exception{
public:
ExcepcionDivCero(): mensaje( "Excepción: división por cero" ) {}
const char *what() const throw(){
return mensaje;
}
private:
char *mensaje;
};
double divide( int dividendo, int divisor ){
if ( divisor == 0 )
throw ExcepcionDivCero();
return (double)dividendo/divisor;
}
int main(int argc, char *argv[])
{
cout << "Division correcta:" << divide(1,2) << endl;
/* Este programa captura y trata la excepción */
try{
/* código susceptible de elevar excepciones */
try{
/* Este bloque try lanza una excepcion que
no manejan sus correspondientes catch*/
throw exception();
}catch( ExcepcionDivCero e ){
cout << "Ocurrió una excepción: " << e.what();
}
}catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
}catch( ... ){
cout << "Ocurrió una excepción que no hereda de exception";
}
system("PAUSE");
return EXIT_SUCCESS;
}
31
32. Excepciones en C++
Tenga en cuenta que el bloque try define un ámbito y los objetos declarados en ese ámbito no
están disponibles en el ámbito del bloque catch que, en su caso, se ejecute.
Es posible relanzar la misma excepción que se está tratando. Esto se hará en casos en que el
tratamiento de la excepción no se haga completamente en un único manejador. Si utilizamos un bloque
catch que da nombre a la excepción capturada, podemos volver a lanzarla con throw <nombre>; . En el
caso de estar en un manejador catch( … ), se puede relanzar la excepción con throw;
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
class ExcepcionDivCero: public exception{
public:
ExcepcionDivCero(): mensaje( "Excepción: división por cero" ) {}
const char *what() const throw(){
return mensaje;
}
private:
char *mensaje;
};
double divide( int dividendo, int divisor ){
if ( divisor == 0 )
throw ExcepcionDivCero();
return (double)dividendo/divisor;
}
int main(int argc, char *argv[])
{
char *array;
/* Este programa captura y trata la excepción */
try{
/* bloque susceptible de elevar excepciones */
try{
/* reserva de memoria */
array = new char[200];
/* Este bloque try lanza una excepcion que
no manejan sus correspondientes catch*/
throw exception();
}catch( ... ){
/* Queremos liberar la memoria, aunque la excepción
se tratará en otro bloque try, si procede... */
delete [] array;
throw;
}
}catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
}catch( ... ){
cout << "Ocurrió una excepción que no hereda de exception";
}
system("PAUSE");
return EXIT_SUCCESS;
}
32
33. Excepciones en C++
El comportamiento por defecto cuando no se encuentra un manejador de excepción es la
terminación del programa. Este comportamiento se puede modificar con la función set_terminate(
void(*)() ).
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
double divide( int dividendo, int divisor ){
if ( divisor == 0 )
throw exception();
return (double)dividendo/divisor;
}
void terminar(){
cout << "Final anormal del programa!!n";
system("PAUSE");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
/* Este programa no captura la excepción */
set_terminate( terminar );
divide(1,0);
system("PAUSE");
return EXIT_SUCCESS;
}
33
34. Excepciones en C++
Se puede especificar una lista de excepciones que una función o método puede lanzar. Para ello,
se escribe una lista throw( [lista clases excepcion] ) después del nombre y lista de parámetros de la
función en cuestión. A la hora de heredar, no es posible sobrescribir un método dándole menores
restricciones en cuanto a lanzamiento de excepciones, esto es, un método que sobrescribe a otro puede
lanzar, a lo sumo, las mismas excepciones que el método sobrescrito.
#include <cstdlib>
#include <iostream>
#include <exception>
using namespace std;
class ExcepcionDivCero: public exception{ Con throw() se
public: declara que una
ExcepcionDivCero(): mensaje( "Excepción: división por cero" ) {} función o método
const char *what() const throw(){ no lanza
return mensaje;
excepciones.
}
private:
char *mensaje;
};
double divide( int dividendo, int divisor )
throw (exception,ExcepcionDivCero)
{
if ( divisor == 0 )
throw ExcepcionDivCero();
return (double)dividendo/divisor;
}
int main(int argc, char *argv[])
{
char *array;
/* Este programa captura y trata la excepción */
try{
/* bloque susceptible de elevar excepciones */
try{
/* reserva de memoria */
array = new char[200];
/* Este bloque try lanza una excepcion que
no manejan sus correspondientes catch*/
throw exception();
}catch( ... ){
/* Queremos liberar la memoria, aunque la excepción
se tratará en otro bloque try, si procede... */
delete [] array;
throw;
}
}catch( exception e ){
cout << "Ocurrió una excepción: " << e.what();
}
system("PAUSE");
return EXIT_SUCCESS;
}
34
35. Entrada y salida con iostream
La biblioteca estándar de C++ nos provee de una útil batería de clases de entrada y salida
utilizando flujos. Puede consultar la jerarquía de clases en Internet:
http://www.cplusplus.com/ref/
En iostream tenemos las clases base para flujos de entrada y salida y los flujos predefinidos
cout, cin, cerr, clog.
sstream permite utilizar cadenas como flujos.
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(int argc, char *argv[])
{
stringstream flujoCadena;
char strC1[200], strC2[200];
int dato;
string strCPP;
/* Salida a la cadena */
flujoCadena << " Primera línea 1n Segunda línea 2n";
/* Leer una línea (no ignora los blancos iniciales) */
flujoCadena.getline(strC1,200);
/* Con el operador >> se puede leer también a un char * */
flujoCadena >> strC2;
/* Leer la siguiente entrada. Descarta los blancos iniciales
por defecto... */
flujoCadena >> strCPP;
/* Se pueden leer más tipos de datos */
flujoCadena >> dato;
/* El método .str() nos da un string el contenido del flujo */
cout << "flujoCadena:n" << flujoCadena.str() << "n";
cout << "strC1:n" << strC1 << "n";
cout << "strC2:n" << strC2 << "n";
cout << "strCPP:n" << strCPP << "n";
cout << "dato:n" << dato << "n";
system("PAUSE");
return EXIT_SUCCESS;
}
35
36. Public member functions: (www.cplusplus.com)
stringstream members:
(constructor) Construct an object and optionally initizalize string content.
rdbuf Get the stringbuf object associated with the stream.
str Get/set string value.
members inherited from istream:
operator>> Performs a formatted input operation (extraction)
gcount Get number of characters extracted by last unformatted input operation
get Extract unformatted data from stream
getline Get a line from stream
ignore Extract and discard characters
peek Peek next character
read Read a block of data
readsome Read a block of data
putback Put the last character back to stream
unget Make last character got from stream available again
tellg Get position of the get pointer
seekg Set position of the get pointer
sync Syncronize stream's buffer with source of characters
members inherited from ostream:
operator<< Perform a formatted output operation (insertion).
flush Flush buffer.
put Put a single character into output stream.
seekp Set position of put pointer.
tellp Get position of put pointer.
write Write a sequence of characters.
members inherited from ios:
operator void * Convert stream to pointer.
operator ! evaluate stream object.
bad Check if an unrecoverable error has occurred.
clear Set control states.
copyfmt Copy formatting information.
eof Check if End-Of-File has been reached.
exceptions Get/set the exception mask.
fail Check if failure has occurred.
fill Get/set the fill character.
good Check if stream is good for i/o operations.
imbue Imbue locale.
narrow Narrow character.
rdbuf Get/set the associated streambuf object.
rdstate Get control state.
setstate Set control state.
tie Get/set the tied stream.
widen Widen character.
members inherited from ios_base:
flags Get/set format flags.
getloc Get current locale.
imbue Imbue locale.
iword Get reference to a long element of the internal extensible array.
precision Get/set floating-point decimal presision.
pword Get reference to a void* element of the internal extensible array.
register_callback Register event callback function.
setf Set some format flags.
36
37. Entrada y salida con iostream
fstream nos permite utilizar archivos como flujos.
Los modos de apertura son constantes de máscara de bit, de modo que se puede hacer un or
lógico de ellos para conseguir un modo de apertura combinado.
Ejemplo en modo texto:
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(int argc, char *argv[])
{
fstream archivo;
/* Abrimos el archivo en modo salida y ponemos a 0
, es decir, descartamos el contenido actual... */
archivo.open( "Prueba.txt", fstream::out | fstream::trunc );
if ( archivo.is_open() ){ // Comprobamos que se abrió correctamente
archivo << "Hola " << 5 << endl;
archivo.close();
}
/* Abrimos el archivo en modo salida y añadir
, es decir, mantenemos el contenido actual y nos
disponemos a añadir al final */
archivo.open( "Prueba.txt", fstream::out | fstream::app );
if ( archivo.is_open() ){
archivo << "Adiós " << 4 << endl;
archivo.close();
}
/* Abrimos el archivo en modo entrada */
archivo.open( "Prueba.txt", fstream::in );
if ( archivo.is_open() ){
string lectura;
/* Para controlar en fin de archivo correctamente, es necesario
hacer una lectura antes de comprobar si se ha llegado al fin
de archivo */
archivo >> lectura;
while ( !archivo.eof() ){
cout << lectura;
archivo >> lectura;
}
archivo.close();
}
system("PAUSE");
return EXIT_SUCCESS;
}
37
38. Entrada y salida con iostream (fstream, ejemplo en modo binario con estructuras )
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string.h> Se ha omitido la
using namespace std;
comprobación de apertura
correcta ( is_open() ) por
struct registro{ razones de espacio.
char nombre[21];
char apellido[21];
int edad;
};
int main(int argc, char *argv[])
{
fstream archivo;
registro r1 = { "José","Pérez",20 };
/* Abrimos el archivo en modo salida y ponemos a 0
, es decir, descartamos el contenido actual... */
archivo.open( "Prueba.bin", fstream::out | fstream::trunc | fstream::binary );
archivo.write( (char*)&r1, sizeof( registro ) );
archivo.close();
/* Otro registro */
strcpy( r1.nombre, "Ana" );
strcpy( r1.apellido, "Román" );
r1.edad = 19;
/* Abrimos el archivo en modo salida y añadir
, es decir, mantenemos el contenido actual y nos
disponemos a añadir al final */
archivo.open( "Prueba.bin", fstream::out | fstream::app | fstream::binary );
archivo.write( (char*)&r1, sizeof( registro ) );
archivo.close();
/* Abrimos el archivo en modo entrada */
archivo.open( "Prueba.bin", fstream::in | fstream::binary );
registro lectura;
/* Para controlar en fin de archivo correctamente, es necesario
hacer una lectura antes de comprobar si se ha llegado al fin
de archivo */
archivo.read( (char*)&lectura, sizeof( registro ) );
while (!archivo.eof()){
cout << lectura.nombre << endl
<< lectura.apellido << endl
<< lectura.edad << ende;
archivo.read( (char*)&lectura, sizeof( registro ) );
}
archivo.close();
system("PAUSE");
return EXIT_SUCCESS;
}
38
39. Entrada y salida con iostream (fstream, ejemplo en modo binario con clases)
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string.h>
Se ha omitido la
comprobación de apertura
using namespace std; correcta ( is_open() ) por
razones de espacio.
class Registro{
private:
char nombre[21];
char apellido[21];
int edad;
public:
void pinta(){ cout << nombre << " " << apellido << " " << edad << endl; }
void cambia( char *nom, char *ape, int eda ){
strcpy( nombre, nom );
strcpy( apellido, ape );
edad = eda;
} Pasamos el
void almacena( fstream &archivo ){ archivo como
archivo.write( (char*)this, sizeof( Registro ) );
} referencia
void recupera( fstream &archivo ){
archivo.read( (char*)this, sizeof( Registro ) );
}
};
int main(int argc, char *argv[])
{
fstream archivo;
Registro r1;
r1.cambia("José","Pérez",20);
archivo.open( "Prueba.bin", fstream::out | fstream::trunc | fstream::binary );
r1.almacena( archivo );
archivo.close();
r1.cambia("Ana","Román",19);
archivo.open( "Prueba.bin", fstream::out | fstream::app | fstream::binary );
r1.almacena( archivo );
archivo.close();
archivo.open( "Prueba.bin", fstream::in | fstream::binary );
r1.recupera( archivo );
while (!archivo.eof()){
r1.pinta();
r1.recupera( archivo );
}
archivo.close();
system("PAUSE");
return EXIT_SUCCESS;
}
39
40. Public member functions: (www.cplusplus.com)
fstream members:
(constructor) Construct an object and optionally open a file.
rdbuf Get the filebuf object associated with the stream.
is_open Check if a file has been opened.
open Open a file.
close Close an open file.
members inherited from istream:
operator>> Performs a formatted input operation (extraction)
gcount Get number of characters extracted by last unformatted input operation
get Extract unformatted data from stream
getline Get a line from stream
ignore Extract and discard characters
peek Peek next character
read Read a block of data
readsome Read a block of data
putback Put the last character back to stream
unget Make last character got from stream available again
tellg Get position of the get pointer
seekg Set position of the get pointer
sync Syncronize stream's buffer with source of characters
members inherited from ostream:
operator<< Perform a formatted output operation (insertion).
flush Flush buffer.
put Put a single character into output stream.
seekp Set position of put pointer.
tellp Get position of put pointer.
write Write a sequence of characters.
members inherited from ios:
operator void * Convert stream to pointer.
operator ! evaluate stream object.
bad Check if an unrecoverable error has occurred.
clear Set control states.
copyfmt Copy formatting information.
eof Check if End-Of-File has been reached.
exceptions Get/set the exception mask.
fail Check if failure has occurred.
fill Get/set the fill character.
good Check if stream is good for i/o operations.
imbue Imbue locale.
narrow Narrow character.
rdbuf Get/set the associated streambuf object.
rdstate Get control state.
setstate Set control state.
tie Get/set the tied stream.
widen Widen character.
members inherited from ios_base:
flags Get/set format flags.
getloc Get current locale.
imbue Imbue locale.
iword Get reference to a long element of the internal extensible array.
precision Get/set floating-point decimal presision.
...
40
42. Ejemplo2 Texto , Modos de apertura y lectura
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(int argc, char *argv[]) {
fstream archivo;
// archivo en modo salida y descarta el contenido actual
archivo.open( "Prueba.txt", fstream::out | fstream::trunc );
if ( archivo.is_open() ){
archivo << "Hola " << 5 << endl;
archivo.close();
}
/* archivo en modo salida y añadir */
archivo.open( "Prueba.txt", fstream::out | fstream::app );
if ( archivo.is_open() ){
archivo << "Adiós " << 4 << endl;
archivo.close();
}
/* archivo en modo entrada */
archivo.open( "Prueba.txt", fstream::in );
if ( archivo.is_open() ){
string lectura;
/* Para controlar en fin de archivo correctamente, es necesario
hacer una lectura antes de comprobar si se ha llegado al fin
}
}
return EXIT_SUCCESS;
}
archivo >> lectura;
bit efecto
ios_base::app Va al final del stram antes de cada operacion de escritura.
ios_base::ate Va al finl del stream en la apertura
ios_base::binary Abre el stream en modo binario
ios_base::in Permite operaciones de lectura
ios_base::out Permite operaciones de escritura
ios_base::trunc (truncate) borra el contenido previo del fichero al abrir
42
43. #include <cstdlib>
#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
class Provincias{
private:
char nombre[21];
char capital[21];
int censo;
public:
void pinta(){ cout << nombre << " " << capital << " " << censo << endl; }
Provincias( char *nom, char *cap, int cen ){
strcpy( nombre, nom );
strcpy( capital, cap );
censo = cen;
}
};
int main(int argc, char *argv[])
{
fstream archivo;
Provincias r1("Huelva","Huelva",150000),r2("Mallorca","Palma de Mallorca",250000);
archivo.open( "Prueba.bin", fstream::out | fstream::trunc | fstream::binary );
archivo.write( (char*)&r1, sizeof( Provincias ) );
archivo.close();
//Añadir
archivo.open( "Prueba.bin", fstream::out | fstream::app | fstream::binary );
archivo.write( (char*)&r2, sizeof( Provincias) );
archivo.close();
archivo.open( "Prueba.bin", fstream::in | fstream::binary );
archivo.read( (char*)&r1, sizeof( Provincias) );
while (!archivo.eof()){
r1.pinta();
archivo.read( (char*)&r1, sizeof( Provincias ) );
}
archivo.close();
system("PAUSE");
return EXIT_SUCCESS;
}
43
44. Excepciones en los ficheros
ios:: exceptions
La mascara de excepciones esta copuesta por fags (bits) que representan si se emitirá un aexcepción en
el caso de llegar a uno de dichos estados:
• badbit (critical error in stream buffer)
• eofbit (End-Of-File reached while extracting)
• failbit (failure extracting from stream)
• goodbit (no error condition, represents the absence of the above bits)
#include <iostream>
#include <fstream>
using namespace std;
int main () {
ifstream file;
file.exceptions ( ifstream::eofbit |
ifstream::failbit | ifstream::badbit );
try {
file.open ("test.txt");
while (!file.eof()) file.get();
}
catch (ifstream::failure e) {
cout << "Exception opening/reading file";
}
file.close();
return 0;
}
bool operator ! ( ) (similar a good y fail)
si los flags de excepción están puestos develve el estado del stream
int main () {
ifstream is;
is.open ("test.txt");
if (!is)
cerr << "Error abriendo 'test.txt'n";
return 0;
}
44
45. Genéricos
C++ incluye la posibilidad de definición de funciones y de clases parametrizadas o genéricas. La
forma de definirlos es a través de plantillas (templates) y utilizando variables de clase, es decir, variables
que pueden tomar como valor un tipo o clase.
Función genérica
Punto #include <cstdlib>
+ int x #include <iostream>
#include <stdio.h>
+ int y #include <string.h>
+ Punto( int x, int y )
+ operador char*() using namespace std;
template< class T >
void pinta( T impresion ){
cout << impresion <<"n";
}
class Punto{
public:
int x;
int y;
Punto( int nx, int ny ){ x=nx; y=ny; }
operator char*(){
char tmp[30];
sprintf(tmp,"(%i,%i)",x,y);
return strdup(tmp);
}
};
int main(int argc, char *argv[])
{
pinta<int>( 5 );
pinta<float>( 5.4 );
pinta<char>('B');
pinta<Punto>( *(new Punto(2,3)) );
system("PAUSE");
return EXIT_SUCCESS;
}
45
46. Genéricos
Clase genérica:
Punto< T > #include <cstdlib>
+Tx #include <iostream>
#include <stdio.h>
+Ty #include <string.h>
+ Punto( T x, T y )
+ void pinta() using namespace std;
template <class T>
class Punto{
private:
Complejo T x;
T y;
+ double real public:
+ double imag Punto( T nx, T ny );
+ Complejo void pinta();
( double r=0, double i=0 ) };
+ operator char* ()
template <class T>
Punto<T>::Punto( T nx, T ny ){
x=nx;
Existen casos diferentes y=ny;
}
cuando se utilizan
funciones friend con template <class T>
genéricos. Los estáticos void Punto<T>::pinta(){
son por clase concreta cout << "(" << x << "," << y << ")n";
distinta… }
class Complejo{
public:
double real;
double imag;
Complejo( double r=0, double i=0 ){ real=r; imag=i; }
operator char*(){
char tmp[30];
sprintf(tmp,"[%.2lf,%.2lf]",real,imag);
return strdup(tmp);
}
};
int main(int argc, char *argv[])
{
Punto<int> pi(10,5);
Punto<char> pc('a','b');
Punto<double> pd(10.2345,-0.777);
Punto<Complejo> pcom( *(new Complejo(1,0.45)),
*(new Complejo(3.23,45)) );
pi.pinta(); pc.pinta(); pd.pinta(); pcom.pinta();
system("PAUSE");
return EXIT_SUCCESS;
}
46
47. Genéricos
Clase genérica: variables y métodos de clase (static)
Prueba< T > #include <cstdlib>
+ static int deClase #include <iostream>
+ T deInstancia using namespace std;
template< class T >
class Prueba{
public:
static int deClase;
T deInstancia;
};
template< class T >
int Prueba<T>::deClase=0;
int main(int argc, char *argv[])
{
Prueba<int> p1;
Prueba<int> p2;
Prueba<float> p3;
p1.deClase=1;
p2.deClase=2;
p3.deClase=3;
cout << p1.deClase << ","
<< p2.deClase << ","
<< p3.deClase << "n";
system("PAUSE");
return EXIT_SUCCESS;
}
Nota: Existen casos diferentes cuando se utilizan funciones friend con genéricos que no veremos en este
curso.
47
48. Anexo : Funciones extendidas con punteros
• malloc/free frente a new/delete
Utilización de un bloque de memoria de diferentes maneras:
#include <iostream>
#include <string.h>
using namespace std;
int main(){
int enteros[10];
char *caracteres = (char*)enteros;
for (int i=0; i<(10*sizeof(int))/sizeof(char); i++){
caracteres[i]='A'+i;
cout << caracteres[i];
}
for (int i=0; i<10; i++){
cout << enteros[i] <<" ";
}
system("PAUSE");
exit(EXIT_SUCCESS);
}
48
49. Repaso de punteros, arrays y punteros a funciones
Punteros a funciones:
Se declaran:
<tipo devuelto>(*<nombre>)( [Lista de parámetros] );
Ejemplo: el puntero a función f que se corresponde con una función que devuelve un real y que
toma como argumentos un entero y un puntero a char:
float (*pf)( int entero, char *puntero );
// no es necesario dar nombre a los parámetros:
float (*pf)( int, char* );
El puntero se llama pf.
Al igual que con el resto de los punteros, se les hace apuntar a alguna función. C/C++ toma el
nombre de la función como la dirección de memoria donde está almacenada. No es necesario utilizar &.
Al igual que con los arrays estáticos, & utilizado sobre un nombre de función devuelve la misma
dirección.
pf = funcion;
Podemos utilizar el puntero para invocar a la función a la que apunta.
pf( 10, “Hola” );
Array de punteros a función:
int (*arr[10])( const int, const int );
para llamarlas:
arr[3]( 4, 67 );
49
50. Punteros a funciones: ejemplo con qsort;
#include <cstdlib>
#include <iostream> El prototipo de qsort es:
#include <sstream>
#include <string.h> void qsort ( void * base, size_t num,
using namespace std;
size_t width,
int (*fncompare)(const void *, const void *) );
class Punto{
public:
int x;
int y;
El primer argumento es un puntero
operator char*(){ al inicio del bloque de memoria que
stringstream cad; queremos ordenar.
cad << "(" << x << "," << y << ")"; El segundo argumento es el número
return strdup( (cad.str()).c_str()); de elementos que hay en el bloque
}
};
de memoria.
El tercer argumento es el tamaño en
int menor_a_mayor( const void *e1, const void *e2 ){ bytes de un elemento de los que
Punto *p1=(Punto*)e1, *p2=(Punto*)e2; queremos ordenar.
if ( p1->x == p2->x )
return ( p1->y - p2->y );
else
El cuarto argumento es un puntero
return ( p1->x - p2->x ); a función. Cambiando este puntero
} podemos cambiar el
comportamiento de la función
int mayor_a_menor( const void *e1, const void *e2 ){ qsort. Este es un ejemplo de
return - menor_a_mayor( e1, e2 );
}
función polimórfica en tiempo de
ejecución previa al paradigma de
void muestra_array( Punto array[], int tam ){ programación orientada a objetos.
for (int i=0; i<tam; i++){
cout << array[i] << " , ";
if (i%7 == 6) cout << endl;
}
}
int main(int argc, char *argv[])
{
Punto array[30];
for ( int i=0; i<30; i++ ){
array[i].x=rand()%100;
array[i].y=rand()%100;
}
muestra_array( array, 30 );
cout << "nDe menor a mayor:n";
qsort( array, 30, sizeof(Punto), menor_a_mayor );
muestra_array( array, 30 );
cout << "nDe mayor a menor:n";
qsort( array, 30, sizeof(Punto), mayor_a_menor );
muestra_array( array, 30 );
system("PAUSE");
return EXIT_SUCCESS;
}
50
51. Ejercicio propuesto:
Programe el comportamiento dinámico de la jerarquía de clases que se muestra sin utilizar
objetos (utilice estructuras en su lugar)
Punto
+ virtual void pinta()
Circulo
+ void pinta()
El programa de ejemplo puede crear un array de referencias a puntos, llenarlo con referencias a
puntos y a círculos y luego recorrer el array utilizando la función pinta correspondiente en cada caso.
Sólo se debe utilizar la referencia para realizar la llamada correcta y se debe poder extender con nuevas
formas de pintar sin necesidad de cambiar el código del programa que usa esta funcionalidad.
51