METODOS DE PROGRAMACION MODULO II

Contenido
TEMA 1. INTRODUCCIN A LA PROGRAMACIN................................................................................ 4 1.1 1.2 1.3 1.4 Algunas definiciones y conceptos importantes: ................................................................. 4 Historia de la Programacin ................................................................................................ 5 Tipos de lenguajes de programacin .................................................................................. 8 Paradigmas de la programacin .......................................................................................... 9

1.4.1 Programacin Imperativa ................................................................................................... 9 1.4.2 Programacin Orientada por Objeto................................................................................ 10 1.5 Programacin Estructurada .............................................................................................. 11

1.5.1 Definicin de las estructuras bsicas de control lgico ................................................... 11 1.6 1.7 Lenguajes de Programacion Pascal y C++ ......................................................................... 13 Diagramas de Flujo ............................................................................................................ 13 Smbolos y operadores de los diagramas de flujo..................................................... 14

1.7.1

1.7.2 Reglas para la construccin de un diagrama de flujo ...................................................... 16 1.8 1.9 1.10 1.11 Uso de pseudocdigo ........................................................................................................ 16 Compilador Dev C++ .......................................................................................................... 18 El primer programa Hola Mundo en C++ ....................................................................... 20 Ejercicios............................................................................................................................ 22

TEMA 2. ESTRUCTURAS DE CONTROL. .............................................................................................. 25 2.1 Secuencia, Condicin y Ciclos de Repeticin .................................................................... 25 Secuencia................................................................................................................... 25 Bifurcacin Condicional ............................................................................................. 25 Ciclos De Repeticin .................................................................................................. 27

2.1.1 2.1.2 2.1.3 2.2

Tipos de Datos y Variables ................................................................................................ 30 Tipos de datos ........................................................................................................... 30 Variables .................................................................................................................... 31

2.2.1 2.2.2 2.3

Uso de comentarios en programacin .............................................................................. 32

TEMA 3. PROGRAMACIN MODULAR (FUNCIONES Y PROCEDIMIENTOS) ...................................... 33 3.1 3.2 3.3 Introduccin ...................................................................................................................... 33 Funciones .......................................................................................................................... 33 Procedimientos ................................................................................................................. 35

3.4

Paso de parmetros por referencia .................................................................................. 36

TEMA 4. VECTORES Y MATRICES ....................................................................................................... 38 4.1 4.2 4.3 Vectores ............................................................................................................................ 38 Matrices............................................................................................................................. 40 Estructuras ........................................................................................................................ 43

TEMA 5. PUNTEROS Y MEMORIAS DINAMICAS ................................................................................ 45 5.1 5.2 5.3 5.4 Introduccin ...................................................................................................................... 45 Aritmtica de punteros ..................................................................................................... 46 Comparacin de punteros ................................................................................................. 47 Vectores Dinmicos ........................................................................................................... 48

TEMA 6. PROGRAMACION ORIENTADA A OBJETOS.......................................................................... 49 6.1 6.2 6.3 6.4 6.5 6.6 6.7 Que es la programacin orientada a objetos? .................................................................. 49 Definicin de clase ............................................................................................................ 50 Definicin de objeto .......................................................................................................... 52 Herencia ............................................................................................................................ 54 Polimorfismo ..................................................................................................................... 56 Sobrecarga......................................................................................................................... 57 Declaracin de clases en C++ ............................................................................................ 57 Especificadores de acceso ......................................................................................... 58 Operador de resolucin de ambito ........................................................................... 60 El apuntador this ....................................................................................................... 61

6.7.1. 6.7.2 6.7.3

TEMA 1. INTRODUCCIN A LA PROGRAMACIN

1.1

Algunas definiciones y conceptos importantes:

Qu es un Algoritmo? En matemticas, ciencias de la computacin y disciplinas relacionadas, un algoritmo es un conjunto preescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos que no generen dudas a quien deba realizar dicha actividad. Dados un estado inicial y una entrada, siguiendo los pasos sucesivos se llega a un estado final y se obtiene una solucin. En la vida cotidiana, se emplean algoritmos frecuentemente para resolver problemas. Algunos ejemplos son los manuales de usuario, que muestran algoritmos para usar un aparato, o las instrucciones que recibe un trabajador por parte de su patrn. Algunos ejemplos en matemtica son el algoritmo de la divisin para calcular el cociente de dos nmeros, el algoritmo de Euclides para obtener el mximo comn divisor de dos enteros positivos, o el mtodo de Gauss para resolver un sistema lineal de ecuaciones. Muchos autores definen a los algoritmos como listas de instrucciones para resolver un problema abstracto, es decir, que un nmero finito de pasos convierten los datos de un problema (entrada) en una solucin (salida).

Qu es un Diagrama de Flujo? Los diagramas de flujo son descripciones grficas de algoritmos; usan smbolos conectados con flechas para indicar la secuencia de instrucciones y estn regidos por ISO. Los diagramas de flujo son usados para representar algoritmos pequeos, ya que abarcan mucho espacio y su construccin es laboriosa. Por su facilidad de lectura son usados como introduccin a los algoritmos, descripcin de un lenguaje y descripcin de procesos a personas ajenas a la computacin. Qu es Programar? Es la accin de escribir instrucciones correctas para que sean interpretadas por una mquina. Qu es el Software? Son programas que para que tengan sentido de software deben ser ejecutados sobre una mquina.

En qu medida nos compete programar?

Depende del inters. De todas formas hoy en da es un must para cualquier ingeniero o tcnico debe de conocer. En qu medida dependemos de software? Depende de su estilo de vida, pero para el ciudadano comn la dependencia es bastante: celulares, controles remotos (TV, DVD, radios, mp3 players, etc.), cajeros automticos, etc. Qu es un programa o cdigo fuente? Es un programa escrito en algn lenguaje y que no ha sido traducido a lenguaje de mquina. Qu es un programa o cdigo objeto? Es un programa que ya se encuentra en lenguaje de mquina y que ya es ejecutable. Qu es un compilador? Es aquel programa de software que traduce todo el cdigo fuente escrito y genera un cdigo objeto que es entendible por la mquina y se encuentra listo para funcionar Qu es un Lenguaje de Programacin? Son conjuntos de instrucciones con que se pueden escribir los algoritmos para que un sistema lo ejecute. Existen mltiples tipos de lenguajes de programacin:

1.2

Historia de la Programacin

Los ordenadores son uno ms de los inventos del hombre, aunque debemos decir que las tecnologas para su fabricacin y explotacin han tenido un desarrollo sorprendente a partir de la segunda mitad del siglo XX. Esta herramienta por s sola no es capaz de efectuar ninguna tarea, es tan slo un conjunto de cables y circuitos que necesitan recibir instruccin por parte de los humanos para desempear alguna tarea. El problema entonces, se puede fijar en cmo vamos a poder hacer que un conjunto de circuitos desempeen una determinada tarea y nos entreguen los resultados que nosotros esperamos?, es decir, de qu manera se puede lograr la comunicacin entre el hombre y el ordenador? As pues, tratando de dar una solucin al problema planteado, surgieron los lenguajes de programacin, que son como un lenguaje cualquiera, pero simplificado y con ciertas normas, para poder trasmitir nuestros deseos al ordenador. Por otro lado, como se sabe, un conjunto de circuitos no entendera ningn lenguaje que nosotros conozcamos, por ms sencillo que ste parezca. Los circuitos en todo caso, slo reconocen presencia o ausencia de energa, es decir que debemos hablarle a la mquina en su propio lenguaje (presencia y ausencia de energa, 0 y 1), o nuestro lenguaje deber de ser traducido a un lenguaje binario cuyo alfabeto es el 0 y el 1, mediante las herramientas desarrolladas para llevar a cabo esta tarea, las cuales reciben el nombre de traductores, y como veremos ms adelante, los hay de muchos tipos, dependiendo de caractersticas ms especficas del lenguaje a traducir y de la manera de llevar a cabo su traduccin.

1946: Konrad Zuse , un ingeniero Alemn mientras trabajaba en los Alpes de Bavaria, desarroll el lenguaje Plankalkul, el cual, fue aplicado entre otras cosas para jugar al ajedrez. 1949: Aparece Short Code, que viene a ser el primer lenguaje que fue usado en un dispositivo de cmputo electrnico, aunque se debe decir que se trata de un lenguaje traducido a mano. 1951: Grace Hopper , trabajando para Remington Rand, comenz el trabajo de diseo del primer compilador conocido ampliamente, el A-0, el cual, al ser liberado por la compaa en 1957, lo hizo con el nombre de MATH-MATIC. 1952: Alick E. Glennie, durante su tiempo libre en la Universidad de Manchester, concibe un sistema de programacin llamado AUTOCODE, que viene a ser un compilador muy rudimentario. 1957: aparece FORTRAN (FORmula TRANslating) sistema traductor de frmulas matemticas. Fue desarrollado por un equipo, al frente del cual se encontraba John Backus quien despus vendra a contribuir en el desarrollo del compilador para el lenguaje ALGOL y de la notacin usada para la especificacin sintctica de los lenguajes, conocida como BNF (Backus Naur Form). A partir de los aos sesenta, empiezan a surgir diferentes lenguajes de programacin, atendiendo a diversos enfoques, caractersticas y propsitos, que ms adelante describiremos. Por lo pronto, puede decirse, que actualmente existen alrededor de ms 2000 lenguajes de programacin y continuamente, estn apareciendo otros ms nuevos, que prometen hacer mejor uso de los recursos computacionales y facilitar el trabajo de los programadores. Tratando de resumir un poco, se presenta a continuacin un cuadro donde aparecen los lenguajes que por su uso y comercializacin, han resultado ser los ms populares a lo largo de este medio siglo.

1.3

Tipos de lenguajes de programacin

Los lenguajes ms prximos a la arquitectura hardware se denominan lenguajes de bajo nivel y los que se encuentran ms cercanos a los programadores y usuarios se denominan lenguajes de alto nivel. A continuacin hacemos una breve descripcin de ambos tipos.

Lenguajes de Bajo Nivel Son lenguajes totalmente dependientes de la mquina, es decir que el programa que se realiza con este tipo de lenguajes no se pueden migrar o utilizar en otras maquinas. Al estar prcticamente diseados a medida del hardware, aprovechan al mximo las caractersticas del mismo. Dentro de este grupo se encuentran: El lenguaje maquina: este lenguaje ordena a la mquina las operaciones fundamentales para su funcionamiento. Consiste en la combinacin de 0's y 1's para formar las ordenes entendibles por el hardware de la mquina. Este lenguaje es mucho ms rpido que los lenguajes de alto nivel. La desventaja es que son bastantes difciles de manejar y usar, adems de tener cdigos fuente enormes donde encontrar un fallo es casi imposible. El lenguaje ensamblador es un derivado del lenguaje mquina y est formado por abreviaturas de letras y nmeros llamadas mnemotcnicos. Con la aparicin de este lenguaje se crearon los programas traductores para poder pasar los programas escritos en lenguaje ensamblador a lenguaje mquina. Como ventaja con respecto al cdigo mquina es que los cdigos fuentes eran ms cortos y los programas creados ocupaban menos memoria. Las desventajas de este lenguaje siguen siendo prcticamente las mismas que las del lenguaje de maquina aadiendo la dificultad de tener que aprender un nuevo lenguaje difcil de probar y mantener.

Lenguajes de Alto Nivel Son aquellos que se encuentran ms cercanos al lenguaje natural que al lenguaje mquina. Estn dirigidos a solucionar problemas mediante el uso de Estructura Dinmicas de Datos, algo muy utilizado en todos los lenguajes de programacin. Son estructuras que pueden cambiar de tamao durante la ejecucin del programa. Nos permiten crear estructuras de datos que se adapten a las necesidades reales de un programa. Se tratan de lenguajes independientes de la arquitectura del ordenador. Por lo que, en principio, un programa escrito en un lenguaje de alto nivel, lo puedes migrar de una mquina a otra sin ningn tipo de problema. Estos lenguajes permiten al programador olvidarse por completo del funcionamiento interno de la maquina/s para la que estn diseando el programa. Tan solo necesitan un traductor que entiendan el cdigo fuente como las caractersticas de la mquina. Algunos de ellos son: Basic, C, C++, Pascal, Cobol, Fortran, etc.

1.4

Paradigmas de la programacin

Un paradigma de programacin es una propuesta tecnolgica que es adoptada por una comunidad de programadores cuyo ncleo central es incuestionable en cuanto a que unvocamente trata de resolver uno o varios problemas claramente delimitados. La resolucin de estos problemas debe suponer consecuentemente un avance significativo en al menos un parmetro que afecte a la ingeniera de software. Tiene una estrecha relacin con la formalizacin de determinados lenguajes en su momento de definicin. Un paradigma de programacin est delimitado en el tiempo en cuanto a aceptacin y uso ya que nuevos paradigmas aportan nuevas o mejores soluciones que la sustituyen parcial o totalmente. Si bien existen varios paradigmas de programacin haremos una descripcin de aquellos que consideramos ms importantes como son la programacin imperativa y la orientada a objetos. 1.4.1 Programacin Imperativa El paradigma imperativo debe su nombre al papel dominante que desempean las sentencias imperativas, es decir aquellas que indican realizar una determinada operacin que modifica los datos guardados en memoria. Su esencia es resolver un problema complejo mediante la ejecucin repetitiva y paso a paso de operaciones y clculos sencillos con la asignacin de los valores calculados a posiciones de memoria. La programacin en este paradigma consiste en determinar qu datos son requeridos para el clculo, asociar a esos datos una direccin de memoria, y efectuar, paso a paso, una secuencia de transformaciones en los datos almacenados, de forma que el estado final represente el resultado correcto. Los conceptos bsicos del paradigma son representados por la arquitectura Von Neumann, ya que utiliza este modelo de mquina para conceptualizar las soluciones. Principales caractersticas Celdas de memoria

El principal componente de la arquitectura es la memoria, compuesta por un gran nmero de celdas que contienen los datos. Las celdas, llamadas variables, tienen nombres que las referencian y se organizan en diferentes estructuras de datos. Asignacin

Estrechamente ligado a la arquitectura de memoria se encuentra la idea de que cada valor calculado debe ser almacenado, o sea, asignado, en una variable. Estas asignaciones se realizan repetitivamente sobre la misma celda de memoria, remplazando los valores anteriores. La asignacin determina el estado de una variable, que consiste en el valor que

contiene en un momento en particular. Por lo tanto los resultados corresponden al estado final que asumen las variables. Algoritmos

Un programa imperativo, normalmente realiza su tarea ejecutando repetidamente una secuencia de pasos elementales, ya que en este modelo computacional la nica forma de ejecutar algo complejo es repitiendo una secuencia de instrucciones. La programacin requiere la construccin de algoritmos, a modo de receta, mtodo, tcnica, procedimiento o rutina, que se definen como conjuntos finito de sentencias, ordenadas de acuerdo a sus correspondientes estructuras de control, que marcan el flujo de ejecucin de operaciones para resolver un problema especfico.

Programacin estructurada y estructuras de control

La programacin estructurada surge como un conjunto de tcnicas para facilitar el desarrollo de sistemas en lenguajes del paradigma imperativo, pero presenta ideas que tambin fueron tenidas en cuenta en lenguajes de otros paradigmas. La base terica de la programacin estructurada plantea que cualquier programa, por ms grande y complejo que fuera, puede representarse mediante tres tipos de estructuras de control: secuencia, seleccin e iteracin.

Modularizacin

Tambin propone desarrollar el programa en forma TOP-DOWN, de arriba hacia abajo. Es decir, modularizar el programa creando porciones ms pequeas de programas con tareas especficas, que se subdividen a su vez en otros subprogramas, cada vez ms pequeos y operativos. Estos subprogramas, denominados rutinas, funciones, procedimientos, mdulos y de otras maneras en los diferentes lenguajes, deben tener slo un punto de entrada y uno de salida, y realizar conceptualmente una sola tarea. Existen numerosos lenguajes del paradigma imperativo, como son PASCAL, C, C++, FORTRAN, ALGOL, COBOL, ADA, CLIPPER, FOX, PL/1, etc. Muchos de ellos incluyen extensiones que permiten soportar otros paradigmas, en mayor o menor grado; no obstante, sigue predominando en ellos el modelo de mquina imperativa.

1.4.2 Programacin Orientada por Objeto La programacin Orientada a objetos (POO) es una forma especial de programar, ms cercana a como expresaramos las cosas en la vida real que otros tipos de programacin. La POO no es difcil, pero es una manera especial de pensar, a veces subjetiva de quien la programa, de manera que la forma de hacer las cosas puede ser diferente segn el programador.

Aunque podamos hacer los programas de formas distintas, no todas ellas son correctas, lo difcil no es programar orientado a objetos sino programar bien. Programar bien es importante porque as nos podemos aprovechar de todas las ventajas de la POO. Actualmente el paradigma de programacin ms usado es el de la programacin orientada a objetos, donde podemos mencionar los siguientes lenguajes: C++, Objective C, Java, Smalltalk, Eiffel, Ruby, Python, Object Pascal, Visual .net, Actionscript, Perl, C#, PHP, Delphi, etc.

Otros paradigmas. Programacin Funcional (Tarea) Programacin por Eventos (Tarea) Programacin Concurrente (Tarea) Programacin en la Nube (Tarea)

1.5

Programacin Estructurada

La programacin estructurada es un estilo de programacin con el cual el programador elabora programas, cuya estructura es la ms clara posible, mediante el uso de tres estructuras bsicas de control lgico, a saber: SECUENCIA, SELECCIN, ITERACIN Un programa estructurado se compone de funciones, segmentos, mdulos y/o subrutinas, cada una con una sola entrada y una sola salida. Cada uno de estos mdulos, se denomina programa apropiado cuando, adems de estar compuesto slamente por las tres estructuras bsicas, tiene slo una entrada y una salida y en ejecucin no tiene partes por las cuales nunca pasa ni tiene ciclos infinitos. La programacin estructurada tiene un teorema estructural o teorema fundamental, el cual afirma que cualquier programa, no importa el tipo de trabajo que ejecute, puede ser elaborado utilizando nicamente las tres estructuras bsicas (secuencia, seleccin, iteracin). 1.5.1 Definicin de las estructuras bsicas de control lgico Secuencia Indica que las instrucciones de un programa se ejecutan una despus de la otra, en el mismo orden en el cual aparecen en el programa. Se representa grficamente como una caja despus de otra, ambas con una sola entrada y una nica salida.

A
B
Las cajas A y B pueden ser definidas para ejecutar desde una simple instruccin hasta un mdulo o programa completo, siempre y cuando que estos tambin sean programas apropiados. Seleccin Tambin conocida como la estructura SI-CIERTO-FALSO, plantea la seleccin entre dos alternativas con base en el resultado de la evaluacin de una condicin o predicado; equivale a la instruccin IF de todos los lenguajes de programacin y se representa grficamente de la siguiente manera:

En el diagrama de flujo anterior, C es una condicin que se evala; A es la accin que se ejecuta cuando la evaluacin de este predicado resulta verdadera y B es la accin ejecutada cuando indica falso. La estructura tambin tiene una sola entrada y una sola salida; y las funciones A y B tambin pueden ser cualquier estructura bsica o conjunto de estructuras.

Iteracin Tambin llamada la estructura HACER-MIENTRAS-QUE, corresponde a la ejecucin repetida de una instruccin mientras que se cumple una determinada condicin. El diagrama de flujo para esta estructura es el siguiente:

A
V

C
F

Aqu el bloque A se ejecuta repetidamente mientras que la condicin C se cumpla o sea cierta. Tambin tiene una sola entrada y una sola salida; igualmente A puede ser cualquier estructura bsica o conjunto de estructuras.

1.6

Lenguajes de Programacion Pascal y C++

Qu es Pascal? Pascal es un lenguaje de programacin de ordenadores, de propsito general. Es muy estructurado, y bastante adecuado para introducirse en la programacin de ordenadores. Turbo Pascal ha sido durante mucho tiempo la versin ms extendida del lenguaje Pascal. Fue desarrollada por la compaa Borland, para el sistema operativo Dos. Este puesto actualmente lo ocupa una versin de libre distribucin (y cdigo fuente abierto) llamada Free Pascal, disponible para varios sistemas operativos. Qu es Pascal C/C++? C es un lenguaje de programacin de ordenadores, de propsito general. Su uso est muy extendido, y existen compiladores para muchos sistemas operativos. C++ (C plus plus o C ms ms) es una evolucin del lenguaje C, que soporta la Programacin Orientada a Objetos.

1.7

Diagramas de Flujo

Un Diagrama de Flujo representa la esquematizacin grfica de un algoritmo, el cual muestra grficamente los pasos o procesos a seguir para alcanzar la solucin de un problema. Su correcta construccin es sumamente importante porque, a partir del mismo se escribe un programa en algn Lenguaje de Programacin. Si el Diagrama de Flujo est completo y correcto, el paso del mismo a un Lenguaje de Programacin es relativamente simple y directo.

La creacin del diagrama de flujo es una actividad que agrega valor, pues el proceso que representa est ahora disponible para ser analizado, no slo por quienes lo llevan a cabo, sino tambin por todas las partes interesadas que aportarn nuevas ideas para cambiarlo y mejorarlo. Ventajas de los Diagramas de Flujo: Favorecen la comprensin del proceso a travs de mostrarlo como un dibujo. El cerebro humano reconoce fcilmente los dibujos. Un buen diagrama de flujo reemplaza varias pginas de texto. Permiten identificar los problemas y las oportunidades de mejora del proceso. Se identifican los pasos redundantes, los flujos de los reprocesos , los conflictos de autoridad, las responsabilidades, los cuellos de botella, y los puntos de decisin. Muestran las interfases cliente-proveedor y las transacciones que en ellas se realizan, facilitando a los empleados el anlisis de las mismas. Son una excelente herramienta para capacitar a los nuevos empleados y tambin a los que desarrollan la tarea, cuando se realizan mejoras en el proceso

Determinar las necesidades de una aplicacin. Divisin de la aplicacin en tareas. Utilizacin de organigramas para representar algoritmos. Utilizacin de pseudocdigo para la representacin de algoritmos. Utilizacin de pseudocdigo para especificar algoritmos. 1.7.1 Smbolos y operadores de los diagramas de flujo

Los Diagramas de flujo se dibujan generalmente usando algunos smbolos estndares; sin embargo, algunos smbolos especiales pueden tambin ser desarrollados cuando san requeridos. Los smbolos tienen significados especficos y se conectan por medio de flechas que indican el flujo entre los distintos pasos o etapas. Algunos smbolos estndares, que se requieren con frecuencia para diagramar programas de computadora se muestran a continuacin:

Inicio o Fin del Programa Pasos, procesos o lneas de instruccin de programa de computo

Operaciones de entra y salida

Toma de decisiones

Conector para unir flujo a otra parte del diagrama.

Lneas de flujo

Disco magntico o base de datos

Enva datos a la impresora.

Los operadores son utilizados especficamente para para operaciones aritmticas y relaciones condicionales. La siguiente es una lista de los smbolos ms comnmente utilizados: + Sumar Menos

* Multiplicacin / Divisin Ms o menos = Equivalente a > Mayor que < Menor que >= Mayor o igual que <= Menor o igual que <> Diferente de Si No True

False

1.7.2 Reglas para la construccin de un diagrama de flujo Las reglas para la creacin de diagramas de flujo son: 1. Los Diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda a derecha. 2. Los smbolos se unen con lneas, las cuales tienen en la punta una flecha que indica la direccin que fluye la informacin procesos, se deben de utilizar solamente lneas de flujo horizontal o verticales (nunca diagonales). 3. Se debe evitar el cruce de lneas, para lo cual se quisiera separar el flujo del diagrama a un sitio distinto, se pudiera realizar utilizando los conectores. Se debe tener en cuenta que solo se van a utilizar conectores cuando sea estrictamente necesario. 4. No deben quedar lneas de flujo sin conectar 5. Todo texto escrito dentro de un smbolo debe ser legible, preciso, evitando el uso de muchas palabras. 6. Todos los smbolos pueden tener ms de una lnea de entrada, a excepcin del smbolo final. 7. Solo los smbolos de decisin pueden y deben tener ms de una lnea de flujo de salida. Ejemplo: Sumar dos nmeros:

1.8

Uso de pseudocdigo

El principal objetivo del pseudocdigo es el de representar la solucin a un algoritmo de la forma ms detallada posible, y a su vez lo ms parecida posible al lenguaje que posteriormente se utilizara para la codificacin del mismo.

Las principales caractersticas de este lenguaje son: Se puede ejecutar en un ordenador Es una forma de representacin sencilla de utilizar y de manipular. Facilita el paso del programa al lenguaje de programacin. Es independiente del lenguaje de programacin que se vaya a utilizar. Es un mtodo que facilita la programacin y solucin al algoritmo del programa.

Todo documento en pseudocdigo debe permitir la descripcin de: Instrucciones primitivas Instrucciones de proceso Instrucciones de control Instrucciones compuestas Instrucciones de descripcin La Estructura a seguir en su realizacin: Cabecera: Programa: Modulo: Tipos de datos: Constantes: Variables: Cuerpo Inicio Instrucciones Fin Para comentar en pseudocdigo se le antepone al comentario dos asteriscos (*)

Ejemplos * Programa que calcula el rea de un cuadrado a partir de un lado dado por teclado. Programa: area_cuadrado Modulo: main **( tambin se puede llamar principal) Variables: lado: natural area: natural Inicio Visualizar "Introduce el lado del cuadrado" Leer lado Area<- lado * lado Visualizar "El rea del cuadrado es", area Fin

* Programa que visualice la tabla de multiplicar del numero introducido por teclado Programa: Tabla multiplicar Modulo: main Variables: t: entero num : entero Inicio Visualizar "Introduce un nmero" Leer num Desde t=1 hasta t=10 repetir Visualizar num, " X", t, "=", num*t Fin desde Fin Una vez que tenemos preparado un diagrama de flujos (ordinograma u organigrama) y un pseudocdigo ya podemos comenzar con la codificacin del programa en nuestro ordenador. A partir de aqu todo vara dependiendo del lenguaje de programacin que utilicemos, pero en todos los programas tendremos que definir los tipos de datos que utilizaremos. De todo esto hablar en el siguiente artculo.

1.9

Compilador Dev C++

El compilador del cual se va a hacer uso durante el desarrollo del curso ser el Dev C++ v. 4.9.9.2. Dev C++ es totalmente gratuito que genera cdigo objeto para DOS (modo consola) y para Windows (95/98/2000/NT) con un entorno de programacin visual integrado (IDE). Est basado en el compilador Mingw (Minimalist GNU* for Windows) version MSCVRT 2.95.2-1 que est incluido en el propio entorno, el cual a su vez es una particularizacin del compilador GCC (el compilador g++ del GNU). Tambin permite integrar el depurador gratuito para C++ Cygnus Insight Debugger. Alguna de las principales caractersticas del entorno Dev C++ son: Depurador integrado (GDB o Insight) Editor de programas fuente sensible a la sintaxis C-C++ configurable. Editor multiventana con mltiples opciones de edicin. Se puede trabajar con ficheros independientes o con proyectos multi-ficheros. Generador de paquetes de instalacin de programas para entorno Windows. Puede generar programas DOS (modo consola), aplicaciones Windows y DLLs. Edicin de ficheros de recursos windows con generador de mens integrado Ventanas independientes para el gestor de proyectos, editor y resultados de compilacin. Resultados de compilacin, enlace (linker) y generacin de recursos. Genera automticamente esqueletos de programas en C y C++.

Generacin automtica de "Makefile" Dos juegos de iconos para los mens y las barras de herramientas Permite integrar herramientas externas mediante el "tool manager Plantillas para la creacin de nuevos tipos de proyectos.

En el siguiente grfico se muestra la interfaz del compilador. Las configuraciones y distribucin de opciones y herramientas generalmente son muy parecidas entre estos tipos de programas. Es as por ejemplo que la barra de herramientas contiene las opciones de creacin y guardado de proyectos, bsquedas y ediciones de texto. Tambin se encuentran las opciones de compilacin y ejecucin del cdigo. Son tambin frecuentes las ventas de navegacin que facilitan la manipulacin de diferentes archivos. El editor de texto, el cual es sensible a la sintaxis del lenguaje. Y finalmente la barra de estado que facilita la identificacin de errores.
Barra de herramientas

Editor de Texto

Barra de Navegacin

Barra de Estado

1.10 El primer programa Hola Mundo en C++

Como en la mayora de los cursos de lenguajes de programacin uno de los primeros programas que generalmente se escriben es el famoso Hola Mundo, a travs del cual se nos permite dar un vistazo a la sintaxis y estructura del programa. Pasos a seguir: 1. En primer lugar creamos un nuevo proyecto, haciendo click en el men Archivo->Nuevo, selecciones la opcin Nuevo Proyecto. 2. A continuacin se muestra la siguiente pantalla, donde se deber seleccionar el tipo de proyecto que vamos a construir. Seleccionamos la opcin Console Application, proporcionamos el nombre del proyecto, que nuestro caso ser Hola Mundo y finalizamos haciendo click en el botn aceptar.

3. Terminamos estableciendo la ubicacin donde se guardarn todos los archivos del proyecto. Una vez construido el proyecto, el editor de texto contiene las siguientes lneas de cdigo. #include <cstdlib> #include <iostream> using namespace std int main(int argc, char *argv[]) {

system("PAUSE"); return EXIT_SUCCESS; } Tal como vimos en la seccin de pseudocdigo, este programa contiene una cabecera donde se definen el uso de libreras, variables, mdulos y un cuerpo que contiene las instrucciones. El significado de cada palabra se ver ms adelante, simplemente nos concentramos en el cuerpo del programa donde se establece todo lo necesario para construir nuestros programas. /* Primer Programa Hola Mundo */ #include <cstdlib> #include <iostream> using namespace std; int main(int argc, char *argv[]) { cout<<"Hola Mundo\n"; system("PAUSE"); return EXIT_SUCCESS; } Para compilar nuestro cdigo ingresamos la men->ejecutar y seleccionamos la opcin Compilar y para ejecutarlo realizamos los mismos pasos solo que en este caso seleccionamos la opcin Ejecutar. Es importante hacer notar que siempre es necesario compilar primero nuestro cdigo antes de ejecutarlo puesto que esto nos permite actualizar los cambios que hayamos hecho en nuestro cdigo. Un acceso rpido a estas opciones es mediante la combinacin de teclas CTRL + F9 para compilar y F9 para ejecutar el programa. La salida en pantalla se muestra a continuacin:

1.11 Ejercicios
a) Hacer el diagrama de flujo para sumar dos nmeros ledos por teclado y escribir el resultado.

b) Modificar el anterior pero para sumar 100 nmeros ledos por teclado.

c) Hacer un diagrama de flujo que permita escribir los 100 primeros pares

P: Variable para contener el siguiente par que se debe escribir. I: Contador de pares que quedan por escribir. El proceso es similar al anterior. Necesitamos un bucle para contar 100 veces y dentro de l escribimos el par e incrementamos para obtener el siguiente.

d) La sucesin de Fibonacci se define de la siguiente forma: a1=1, a2=1 y an=an-1+an-2 para n>2, es decir los dos primeros son 1 y el resto cada uno es la suma de los dos anteriores, los primeros son: 1, 1, 2, 3, 5, 8, 13, 21, ... Hacer un diagrama de flujo para calcular el Nsimo trmino de la sucesin.

Dado N, el proceso es el siguiente: - si N2 se escribe directamente 1 y se acaba. - en otro caso se guardan en A y B los 2 ltimos (al principio 1) y se suman, pasando despus a llamar A al antiguo B, y B a la suma. Se decrementa N y cuando valga 2, en B tenemos lo que queremos. Vamos a ver como funciona paso a paso. Para ello vamos a numerar cada uno de los pasos y ver como se van realizando. (1) Leemos N, supongamos N=4. (2) N2? NO (3) A=1 (4) B=1 (5) C=A+B=1+1=2 (6) A=B=1 (7) B=C=2 (8) N=N-1=4-1=3 (9) N=2? NO (5) C=A+B=1+2=3

TEMA 2. ESTRUCTURAS DE CONTROL.

Las estructuras de control determinan la secuencia en que deben ejecutarse las instrucciones de un algoritmo. Existen tres Estructuras de control bsicas primitivas y combinndolas se puede escribir cualquier algoritmo. Estas estructuras primitivas son: la secuencia, la bifurcacin condicional y el ciclo.

2.1
2.1.1

Secuencia, Condicin y Ciclos de Repeticin

Secuencia

La estructura de control ms simple es la secuencia. Esta estructura permite que las instrucciones que la constituyen se ejecuten una tras otra en el orden en que se listan. Por ejemplo, considrese el siguiente fragmento de un algoritmo:

En este fragmento se indica que se ejecute la operacin 1 y a continuacin la operacin 2. 2.1.2 Bifurcacin Condicional

a) Condicin Simple (if else) La estructura de bifurcacin condicional permite elegir una de dos opciones en una alternativa, dependiente del resultado obtenido al evaluar la condicin. Vase el siguiente fragmento de algoritmo:

La palabra clave si indica que estamos en una sentencia de bifurcacin condicional. Si la condicin es verdadera se ejecuta la operacin 1, de otra manera se ejecutar la operacin 2. Cuando la condicin se hace falsa el ciclo termina. En lenguaje C++ la estructura condicional seria de la siguiente manera: if (condicion) { // instrucciones que hay que ejecutar si la condicin es verdadera } else { // Instrucciones que hay que ejecutar si la condicin es falsa } b) La sentencia switch Mediante la sentencia switch se puede seleccionar entre varias sentencias segn el valor de cierta expresin. La sentencia switch evala la expresinMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la clusula case cuyo valor corresponda con el de la expresinMultivalor. Cada sentencia case debe ser nica y el valor que evala debe ser del mismo tipo que el devuelto por la expresinMultivalor de la sentencia switch. Las sentencias break que aparecen tras cada conjunto de sSentencias provocan que el control salga del switch y contine con la siguiente instruccin al switch. Las sentencias break son necesarias porque sin ellas se ejecutaran secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habr que eliminar algunos break. Finalmente, se puede usar la sentencia default para manejar los valores que no son explcitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado.

En lenguaje C++ la estructura condicional switch seria de la siguiente manera: switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break; } Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operacin: switch (meses){ case 1: cout<<"Enero"<<endl; break; case 2: cout<<"Febrero"<<endl; break; case 3: cout<<"Marzo"<<endl; break; case 4: cout<<"Abril"<<endl; break; case 5: cout<<"Mayo"<<endl; break; case 6: cout<<"Junio"<<endl; break; case 7: cout<<"Julio"<<endl; break; case 8: cout<<"Agosto"<<endl; break; case 9: cout<<"Septiembre"<<endl; break; case 10: cout<<"Octubre"<<endl; break; case 11: cout<<"Noviembre"<<endl; break; case 12: cout<<"Diciembre"<<endl; break; default: cout<<"No existe el mes"<<endl; break; }

2.1.3

Ciclos De Repeticin

Los ciclos son estructuras de control que permiten ejecutar varias veces una operacin. Existen varios tipos de ciclos: a) Ciclo Mientras (WHILE)

Este ciclo repite una operacin, mientras se cumpla una cierta condicin. Por ejemplo:

En lenguaje C++ la estructura mientras seria de la siguiente manera: While (condicion) { // Instrucciones a ejecutar una y otra //vez mientras la condicin sea cierta } La palabra clave mientras, seala que se trata de un ciclo mientras. La condicin se verifica antes de ejecutar la operacin. b) Ciclo Hacer-mientras (DO-WHILE)

En este ciclo la operacin se ejecuta y despus se evala la condicin. Si es verdadera, la operacin se evala de nuevo, y as sucesivamente.

En lenguaje C++ la estructura hacer mientras seria de la siguiente manera: do { // Instrucciones a ejecutar una y otra //vez mientras la condicin sea cierta }while(condicion) c) Ciclo Desde (FOR) En este ciclo se ejecuta una operacin un cierto nmero de veces, especificando en un contador el incremento unitario, desde un Valor Inicial hasta un Valor Final que marcar la condicin de salida del ciclo. Por ejemplo:

En lenguaje C++ la estructura repetir seria de la siguiente manera: for (valor inicial; condicin; ejecutar en cada bucle) { // Instrucciones a ejecutar mientras la condicin sea cierta

2.2

Tipos de Datos y Variables

2.2.1

Tipos de datos

Es uno de los conceptos fundamentales de cualquier lenguaje de programacin. Estos definen los mtodos de almacenamiento disponibles para representar informacin, junto con la manera en que dicha informacin ha de ser interpretada. Todos los programas gestionan algunos tipos de informacin que normalmente se pueden representar utilizando uno de los ocho (8) tipos de datos bsicos de C y C++: texto o char, valores enteros o int, valores de coma flotante o float, valores en como flotante de doble precisin o doubl (long double), enumerados o enum, sin valor o void, punteros y booleanos. 1. Texto (tipo de dato char) est constituido por caracteres simples, como a, Z, , 3 y cadenas, como Esto es una prueba (normalmente, de 8 bits o un byte por carcter, con un rango de 0 a 255). 2. Los valores enteros (tipo de dato int) son aquellos nmeros que se aprendieron a contar (1, 4, -2, 1354); normalmente, tienen un tamao de 16 bits, 2 bytes o una palabra, con rango de -32768 a 32767. En Windows 98 y Windows NT, los valores enteros tienen un tamao de 32 bits con un rango de -2147483648 a 2147483647. 3. Los valores en coma flotante (tipo de datofloat) son nmeros que tienen una parte fraccional, como por ejemplo pi (3,14159), y exponentes (7,5631021). Tambin se conocen como nmeros reales (normalmente, son de 32 bits, 4 bytes o 2 palabras, con un rango de +/-3,4E-38 a 3,4E+38). 4. Los valores en coma flotante de doble precisin (tipo de datodouble) tienen un rango superior (normalmente de 64 bits, 8 bytes 4 palabras, con un rango de 1, 7E-308 a 1, 7E+308). Los valores en coma flotante long double (doble precisin largos) son incluso ms precisos (normalmente, tamao de 80 bits 5 palabras, con un rango de +/-1,18E-4932 a 1,18E-4932). 5. Los tipos de datos enumerados (tipo de dato enum) permiten al usuario definir tipos de datos. 6. El tipo void se utiliza para especificar valores que ocupan cero bits y no tienen valor (este tipo tambin se puede utilizar para la creacin de punteros genricos. 7. El tipo de dato puntero no contiene informacin en el mismo sentido que el resto de los tipos de datos; en su lugar, cada puntero contiene la direccin de la posicin de memoria que almacena el dato actual. 8. El tipo de dato bool, al que se le puede asignar las constantes true (verdadero) y false (falso)

Rango de los tipos de datos

2.2.2

Variables

Es un nombre que representa el valor de un dato. Es una zona o posicin de memoria en la computadora donde se almacena informacin. Un objeto de datos que el programador define y nombra explcitamente en un programa. Una variable simple es un objeto elemental de datos con nombre. El valor o valores de una variable es modificable por operaciones de asignacin; es decir, el enlace de objeto de datos a valor puede cambiar durante su tiempo de vida. Las operaciones que se pueden realizar con dos o ms valores exigen que stas sean del mismo tipo de datos. No se puede sumar una variable carcter a otra numrica y/o viceversa. Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador que la identificar de forma nica. La sintaxis de declaracin de variables es la siguiente: TipodeDato Identificador1, Identificador2; Esta sentencia indica al compilador que reserve memoria para dos variables del tipo de dato TipodeDato con nombres Identificador1 e Identificador2. Reglas para definicin de variables Pueden tener hasta 40 caracteres. Debe empezar obligatoriamente con una letra (a-z / A-Z), el resto de los dgitos pueden ser nmeros. No pueden contener espacios en blanco, se pueden incluir caracteres especiales como el guin o el punto.

2.3

Uso de comentarios en programacin

Los comentarios son anotaciones, observaciones, recordatorios, etc. en el programa. Son para uso exclusivo del programador, y eliminados del cdigo fuente en la fase de preprocesado. Aunque los comentarios son voluntarios (no es obligatorio escribirlos), representan una ayuda inestimable durante la construccin del programa. Siendo imprescindibles para el programador original, o los que le sucedan en las tareas de mantenimiento, cuando es necesario habrselas con el cdigo un tiempo despus de que fue escrito. Adems de clarificar ideas, los comentarios son tambin un valioso instrumento de depuracin, pues permiten eliminar provisionalmente secciones enteras de cdigo. Un comentario C/C++ es cualquier secuencia de caracteres contenida entre los delimitadores /* ... */. La totalidad de la secuencia, incluyendo los delimitadores /* y */ son sustituidos por un simple espacio despus de la expansin de macros. C++ tambin admite comentarios de una sola lnea utilizando dos barras inclinadas (//) como seal de comienzo. El comentario empieza en este punto (incluyendo las seales de comienzo) y contina hasta el prximo carcter de nueva lnea. Ejemplos de comentarios: /* Esto es un comentario */ A = B + C; //Esto es un comentario de una lnea C = C + D;

TEMA 3. PROGRAMACIN MODULAR (FUNCIONES Y PROCEDIMIENTOS)

3.1 Introduccin

Uno de los mtodos ms conocidos para resolver un problema es dividirlo en problemas ms pequeos, llamados subproblemas. De esta manera, en lugar de resolver una tarea compleja y tediosa, resolvemos otras ms sencillas y a partir de ellas llegamos a la solucin. Esta tcnica se usa mucho en programacin ya que programar no es ms que resolver problemas, y se le suele llamar diseo descendente, metodologa del divide y vencers o programacin top-down. La programacin modular consiste en dividir un algoritmo (programa) en unidades de menor tamao, donde cada fragmento realiza una tarea explcita y nica. Cada uno de esos fragmentos recibe el nombre de subalgoritmo o mdulo. Por tanto, los subalgoritmos (sean funciones o procedimientos) nos permiten hacer pequeas porciones de cdigo reutilizable, que pueden ser llamados desde el resto del programa sin necesidad de repetir esas partes de cdigo cada vez que se necesiten. En el siguiente grafico se muestra con un ejemplo sencillo la programacin modular, donde para obtener la nota final recurrimos a utilizar una funcin o procedimiento promedio que realiza el clculo.

3.2

Funciones

La funcin desde el punto de vista de programacin, se define como un proceso que recibe valores de entrada (llamados argumentos) y el cual retorna un valor resultado. Adicionalmente las funciones son subprogramas que se pueden invocar (ejecutar) , desde cualquier parte del programa, es decir desde otra funcin, desde la misma funcin o desde el programa principal, cuantas veces sea necesario. Las funciones se utilizan cuando dos o ms porciones de un algoritmo que son iguales o similares, para lo cual se extrae es parte de cdigo similar y se crea una funciona que tiene como cuerpo dicho codigo. Luego se reemplaza el cdigo extrado en el algoritmo principal con el nombre de la nueva funcin creada. Una funcin en C++, se declara de la siguiente manera tipo nombre(arg1:tipo1, arg2:tipo2,, argn:tipon){ <instrucciones> retornar <valor> } Donde: tipo: es tipo de dato que retorna o devuelve la funcin nombre: es el nombre de la funcin, Dicho nombre no puede contener espacios, smbolos o letras acentuadas. El nombre debe comenzar siempre con una letra y puede contener cualquier letra o nmero arg1, arg2, argn: son los argumentos o datos de entrada de la funcin tipo1, tipo2, tipon: son los tipos de datos de los argumentos instrucciones son el conjunto de instrucciones que realiza la funcin valor es el dato que devuelve o retorna la funcin.

En el siguiente ejemplo podemos definir la funcin sumar que recibe como datos de entrada dos valores de tipo numrico y retorna como resultado un valor de tipo tambin numrico, que en esta caso ser como resultado de la suma. En el programa principal invocamos a la funcin sumar con las variables a y b como datos de entrada, el programa devuelve el resultado que es asignado a la variable que es posteriormente impreso en pantalla. #include <cstdlib> #include <iostream> using namespace std; /*Funcion sumar recibe: dos parametros devuelve: la suma de ambos */ int sumar(int a, int b){ int c; c = a + b; return c;

} int main(int argc, char *argv[]) { int a = 2; int b = 3; int c; c = sumar(a,b); cout<<"La suma de "<<a<<" + "<<b<<" es de: "<<c<<endl; system("PAUSE"); return EXIT_SUCCESS; } NOTA: Toda funcin debe tener una instruccin return en su interior para devolver el resultado calculado.

3.3

Procedimientos

La declaracin de procedimientos en C++ es muy similar a la declaracin de las funciones. Los ms puristas diran que en C++ no existen los procedimientos como tales, ya que se declaran como funciones pero que no devuelven nada (void). Entonces, en el cuerpo de un procedimiento no devolveremos nada (no se escribe la instruccin return). Veamos un ejemplo: #include <cstdlib> #include <iostream> using namespace std; /* Procedimiento que muestra la tabla de multiplicar * Recibe: el numero de la tabla a imprimir * No duevelve ningun valor */ void tabla_mult(int num){ int x; for (x=1;x<=10;x++){ cout<<x<<" X "<<num<<" = "<<x*num<<endl; } } int main(int argc, char *argv[]) { int n;

cout<<"Introduzca el numero para la tabla multiplicar:"; cin>>n; tabla_mult(n); system("PAUSE"); return EXIT_SUCCESS; } Como puedes comprobar la declaracin del procedimiento es exactamente igual que la declaracin de una funcin. La nica diferencia est en que el procedimiento devuelve un valor de tipo void, es decir, vaco/nada.

3.4

Paso de parmetros por referencia

Como los procedimientos no devuelven ningn tipo de valor en la llamada, la nica forma de devolver valores es incluir la posibilidad de modificar el valor de sus parmetros. Vamos a ver un ejemplo de cmo hacer eso. El siguiente programa muestra cmo pasar 2 parmetros por referencia, llamando a una funcin que intercambia los valores de los 2 parmetros dados. #include <cstdlib> #include <iostream> using namespace std; /*Procedimientoq que intercambia valores de a y b * recibe: los dos valor para intercambiar * no devuelve ningun valor */ void intercambiar(int &a, int &b){ int aux; aux = a; a = b; b = aux; } int main(int argc, char *argv[]) { int a = 2, b = 3; cout<<"Estos son los valores iniciales: a = "<<a<<", b = "<<b<<endl; intercambiar(a,b); cout<<"Estos son los valores intercambiados: a = "<<a<<", b = "<<b<<endl; system("PAUSE"); return EXIT_SUCCESS; } Para indicar que los dos parmetros se pasan por referencia se coloca el smbolo & delante del nombre de cada parmetro.

void intercambiar(int &a, int &b) La utilizacin de dichos parmetros dentro del procedimiento es exactamente igual que el uso de cualquier otra variable. NOTA: La utilizacin del smbolo & para indicar el paso de parmetros por variable es propio de C++, pero por su facilidad es el mtodo que usaremos para pasar parmetros por referencia. En C el paso de parmetros por referencia es totalmente distinto.

TEMA 4. VECTORES Y MATRICES

Hasta ahora hemos trabajado con datos elementales (enteros, reales, caracteres; int, float, char) donde podamos almacenar 1 slo dato del tipo especificado. En muchas ocasiones es necesario trabajar con gran cantidad de datos de un mismo tipo. Por ejemplo imagina que tienes que hacer un programa donde el usuario es un profesor que quiere almacenar las notas de sus alumnos para posteriormente hacer estadsticas y clculos como nota mxima, mnima, la media, etc. Podramos hacerlo declarando una variable de tipo float para cada nota pero eso puede llegar a ser intratable si la cantidad de notas a almacenar fuera muy grande. Adems el programa sera muy engorroso y difcil de entender. Con los vectores y las matrices conseguimos, bajo un nico nombre, es decir, con una nica variable, almacenar tantos valores de un mismo tipo como queramos (segn el tamao que definamos en su declaracin). En el ejemplo anterior, tendramos un vector de float con longitud, por ejemplo 100, donde podramos almacenar hasta 100 valores reales.

4.1

Vectores

Los vectores, tambin llamados tablas unidimensionales, son tipos de datos compuestos o estructurados caracterizados por: Todos los elementos del vector son del mismo tipo Todos los elementos del vector son referenciados con el mismo nombre y la diferencia entre ellos es el ndice de la posicin que ocupan dentro del vector Todos sus elementos son almacenados en posiciones de memoria contiguas.

El formato general para la declaracin de una variable de tipo vector es la siguiente: Tipo_de_datos nombre_del_vector [tamao_del_vector] Donde: Tipo_de_datos indica el tipo de datos almacenados en la variable vector que se est declarando (int, float, char o cualquier otro tipo definido). Nombre_del_vector indica el nombre de la variable vector que se est declarando. Con este nombre refenciaremos a cada elemento del vector. Tamao es un entero, o una constante de tipo entero, que indica cuntas posiciones tiene ese vector, es decir, cul es el nmero mximo de elementos del tipo Tipo_de_datos que se pueden guardar en la variable Nombre_del_vector que estamos declarando. El tamao no puede ser una variable.

Por ejemplo:

float notas[100]; Sera la declaracin de la variable notas donde podramos almacenar hasta 100 nmeros reales. Grficamente podramos representarlo as: notas

Para acceder a cada casilla del vector utilizamos un nmero entero llamado subndice, que indica la posicin del elemento dentro del vector. En C, los elementos empiezan a numerarse en el 0. As el primer elemento del vector notas ser notas sub 0, el segundo notas sub 1, etc., y el ltimo notas sub 99. Fjate que el ltimo elemento es el que ocupa la posicin tamao_del_vector menos 1.

notas 0 1 2 3 La sitaxis para acceder a estos elementos en C es la siguiente: notas[0] (primer elemento) notas[1] (segundo elemento) . notas[99] (ltimo elemento) 99

Operaciones que podemos hacer con un vector a) Consultar o leer el valor de un elemento del vector Si queremos poner en la variable nota_alu5, la nota del alumno que tenemos en la posicin 5 del vector anterior, haramos la siguiente asignacin: float notas[100], nota_alu5; /*Declaracin de variables */ ... nota_alu5 = notas[5];

b) Asignar o escribir un valor en un elemento del vector Si queremos poner un 8 al alumno que est en la posicin 5 haramos la siguiente asignacin:

notas[5] = 8; En estos dos casos, el acceso al elemento del vector que queremos leer o en el que queremos escribir es directo, porque solamente leemos o modificamos un elemento, el 5 en ambos ejemplos. Si queremos recorrer todo el vector, ya sea para leer como para escribir, tendremos que utilizar un bucle.

c) Recorrido de un vector El bucle ms utilizado para recorrer un vector es el for, porque a priori sabemos cuntas vueltas dar el bucle (tantas como elementos del vector a visitar). Mira el siguiente ejemplo:

#define MAX 20 int main() { float notas[MAX]; int i; for (i=0; i<MAX; i++) { } return 1; } Este programa pide las notas de los alumnos y las almacena en el vector notas. cout<<Dame la nota de la posicin :<<i; cout>>notas[i];

4.2

Matrices

Las matrices, tambin llamados tablas bidimensionales, son tipos de datos compuestos o estructurados caracterizados por: Todos los elementos de la matriz son del mismo tipo Todos los elementos de la matriz son referenciados con el mismo nombre y la diferencia entre ellos son los ndices de la posicin que ocupan dentro de la matriz

El formato general para la declaracin de una variable de tipo matriz es la siguiente: Tipo_de_datos nombre_de_la_matriz [nmero_filas] [nmero_columnas]

Donde: Tipo_de_datos indica el tipo de datos almacenados en la variable matriz que se est declarando (int, float, char o cualquier otro tipo definido). Nombre_de_la_matriz indica el nombre de la variable matriz que se est declarando. Con este nombre refenciaremos a cada elemento de la matriz. Nmero_filas es un entero, o una constante de tipo entero, que indica cuntas filas tiene esa matriz Nmero_columnas es un entero, o una constante de tipo entero, que indica cuntas columnas tiene esa matriz El nmero de filas y de columnas no puede ser una variable.

Por ejemplo: #define MAX_ASIG 6 #define MAX_ALUM 40 ... float notas[MAX_ASIG][MAX_ALUM]; /*Definicin de las constantes */

Sera la declaracin de la variable notas donde almacenaramos todas las notas de los alumnos de cada asignatura. MAX_ASIG y MAX_ALUM seran dos constantes con valores enteros declaradas anteriormente.

Grficamente podramos representarlo as: notas columna

fila

En este ejemplo la fila indica la asignatura y la columna el alumno. Para acceder a cada elemento de la matriz utilizamos dos nmeros enteros llamados subndices, que indica la fila y la columna donde se encuentra el elemento dentro de la matriz. En C/C++, los elementos empiezan a numerarse en el 0. As el primer elemento de la matriz notas ser notas[0][0] y el ltimo notas [MAX_ASIG -1][MAX_ALUM 1]. Si te fijas notars que es exactamente igual que los vectores, pero con 2 dimensiones (la fila y la columna) en lugar de 1.

Operaciones que podemos hacer con una matriz a) Consultar o leer el valor de un elemento de la matriz Si queremos poner en la variable nota_alu5, la nota del alumno que tenemos en la posicin 5 dentro de la asignatura 0, haramos la siguiente asignacin:

float nota_alu5, notas[MAX_ASIG][NAX_ALUM]; /*Declaracin de variables*/ ... nota_alu5 = notas[0][5]; b) Asignar o escribir un valor en un elemento de la matriz Si queremos poner un 8 en la asignatura 0 al alumno que est en la posicin 5 haramos la siguiente asignacin: notas[0][5] = 8;

En estos dos casos, el acceso al elemento de la matriz que queremos leer o en el que queremos escribir es directo, porque solamente leemos o modificamos un elemento, el fila 0, columna 5 en estos ejemplos. Si queremos recorrer toda la matriz, ya sea para leer como para escribir, tendremos que utilizar un bucle. c) Recorrido de una matriz Al igual que para recorrer un vector, para recorrer una matriz, el bucle ms utilizado para recorrer es el for, porque a priori sabemos cuntas vueltas dar el bucle (tantas como elementos de la matriz a visitar). Podemos recorrer la matriz por filas o por columnas. La manera de hacerlo depender del ejercicio.

En el siguiente ejemplo se piden las notas por teclado haciendo un recorrido por filas, pidiendo consecutivamente las notas de todos los alumnos de cada asignatura: #define MAX_ASIG 6 #define MAX_ALUM 40 int main() { float notas [MAX_ASIG][MAX_ALUM]; int i,j; for (i=0; i<MAX_ASIG; i++) /*Para cada asignatura (para cada fila)*/ {cout<<Dame las notas de la asignatura<<i; for(j=0; j<MAX_ALUM; j++) /* Para cada alumno de cada asignatura (para cada columna de cada fila) */ { cout<<Nota del alumno:<<j; cout>>notas[i][j]; } } return 1; }

4.3

Estructuras

Una estructura es un grupo de variables las cuales pueden ser de diferentes tipos sostenidas o mantenidas juntas en una sola unidad. La unidad es la estructura. En C/C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura: struct nombre_estructura{ tipo1 campo1; tipo2 campo2; tipo3 campo3; . .

. TipoN campoN; }; Un punto y coma finaliza la definicin de una estructura puesto que sta es realmente una sentencia C/C++. En un programa, podemos asociar una variable con una estructura utilizando una sentencia similar a la siguiente: nombre_estructura nombre_variable; Para acceder a los miembros de las estructuras se usa el punto u operador miembro (.). La sintaxis es: nombre_variable.miembroNombre

Veamos su funcionamiento con un ejemplo: #include <cstdlib> #include <iostream> using namespace std; struct persona{ string nombre; string apellido; string direccion; string telefono; int edad; }; int main(int argc, char *argv[]) { persona p1; p1.nombre = "Roberto"; p1.apellido = "Ramos"; p1.direccion = "Calvo #44"; p1.telefono = "6433434"; p1.edad = 21; cout<<"Nombre:"<<p1.nombre<<endl; cout<<"Apellido:"<<p1.apellido<<endl; cout<<"Direccion:"<<p1.direccion<<endl; cout<<"Telefono:"<<p1.telefono<<endl;

cout<<"Edad:"<<p1.edad<<endl; system("PAUSE"); return EXIT_SUCCESS; } En el ejemplo declaramos una estructura llamada persona con los campos nombre, apellido, direccin, telfono y edad. En la funcin principal, definimos la variable de tipo estructura y asignamos los valores a sus campos correspondientes y finalizamos mostrando en pantalla los valores de cada campo.

TEMA 5. PUNTEROS Y MEMORIAS DINAMICAS

5.1 Introduccin

Por definicin un puntero es una variable que puede almacenar la direccin en memoria de otra variable. Segn mi definicin, un puntero es una entidad, que puede ser variable o constante, que siempre contiene una direccin de memoria (valida, invlida o nula), en la cual puede estar alojada una entidad de nuestro programa o no. El valor de todas las variables que manejamos en nuestros programas se almacenan en memoria y tienen una direccin. Un puntero es una variable especial que apunta a la direccin de memoria de una variable. El puntero tiene a su vez su propia direccin. Todas estas direcciones tienen un formato hexadecimal. Los punteros son herramientas muy poderosas con muchas utilidades y enormes ventajas como veremos ms adelante. A grandes rasgos, un puntero me permite desplazarme en la memoria, apuntar, redireccionar a ciertas variables, funciones, mtodos, objetos sin necesidad de mover grandes bloques de datos, lo cual nos ahorra muchsimo el consumo de memoria en los programas.

La declaracin de una variable tipo puntero debe ser de la forma:

TipoVariableApuntada *NombreVariablePuntero;

Una variable de tipo puntero debe ser de igual tipo que la variable cuya direccin en memoria contiene, o dicho de otra forma, la variable a la que apunta.

Un puntero no tiene asociacin directa con el dato actual, pero si una asociacin indirecta. Por ese motivo se usa el trmino direccin cuando se hace referencia a una asociacin indirecta.

Un puntero se debe declarar de acuerdo al tipo de dato al que apunta. Ejem: 1 int *var; //Un puntero llamado var que podra apuntar a cualquier variable de tipo entero. 2 char *u;//puntero de tipo char 3 Persona *per;//puntero de tipo persona Para determinar, asignar la direccin de una variable en c++, se usa el operador & y para obtener el contenido de un puntero utilizamos el operador * Ejem: 1 int a;//entero 2 int *b;//puntero a entero 3 a = 20;//a tiene 20 4 b=&a;//asigno la direccin de a al puntero b 5 6 cout << b << endl; // imprimir la direccin de memoria de a; 7 cout << *b;// imprimir 20, es decir el contenido de a

5.2

Aritmtica de punteros

Utilizando los operadores de adicin y sustraccin podemos movernos a partir de la direccin relativa a la que apunta un puntero. p++; cout << *p; P--; cout<<*p; Pueden visualizar que estoy incrementando el puntero p en 1. Esto quiere decir que el puntero se desplazara 4 bytes en memoria (en este caso por ser entero) y entonces apuntara a otra direccion. Por eso es que el nuevo contenido de p es basura o bueno el contenido de lo que tiene esa nueva direccion a la que apunta. Supongamos que definir un entero y puntero de tipo char:

1 char c; 2 char *d; 3 4 d= &c;//asigno la direccion de c a d 5 c='u';//asigno el valor u a mi variable c 6 c--;//desplazo una posicion a c 7 cout << *d;// No Imprimira u porque fijense que desplaz c en sentido negativo 1 byte (los char ocupan a 1 byte). Es decir, que si d estaba apuntado a una direccion como por ejemplo 0x22ff99, despues del c estara apuntando a algo como 0x22ff98 Para tomar en cuenta cosas que no puedo hacer con punteros: 01 int a=15; 02 int *p; 03 04 double *q; 05 void *r; 06 p = a; //No puedo hacer esto porque estoy asignando una variable a un puntero y un puntero es una direccion. p = &50; // 50 es un valor constante en este caso y no una variable,por lo tanto no tiene 08 direccion 07 09 p = &(a+1); //una expresion no tiene direccion 10 p = 30;//igual que el primer error, 30 es un entero. 11 &a = p;//no puedo cambiar la direccion de una variable 12 p = q;//p es puntero de tipo entero y q de tipo double Un puntero de tipo void, es un puntero al cual le podemos asignar cualquier tipo de puntero. Por lo tanto si podriamos hacer esto: r = p;

5.3

Comparacin de punteros

Para la comparacin de punteros se utilizan los operadores bsicos de comparacin que usbamos con variables bases, tales como int. Por lo que para saber por ejemplo si un puntero apunta a la misma direccin a la que apunta otro, utilizaramos: p1 == p2, para saber si son distintos utilizaramos el operador !=, para saber si p1 apunta a una direccin de memoria mas baja que p2 colocaramos p1 < p2, y as con los dems operadores de comparacin.

VECTORES Y PUNTEROS

Cuando declaramos un vector int v[10]; el nombre del vector es un puntero al primer elemento del vector, es decir a v[0]. Entonces como un vector es un puntero al primer elemento del mismo, tambin podramos hacer aritmtica de punteros con el vector. 1 (v+1) ;//apuntara a v[1]; 2 *(v+5);//me refiero al contenido de v[5] 3 4 //Y tambin a los punteros les puedo poner ndices: 5 6 int *p; //puntero de tipo entero 7 p = &v[0];//p apunta a la direccion del vector v[0] o tambien a v. p = v 8 p[8] = 80; //le asigno el valor 80 al puntero en la posicion 8, es decir a v[8]

5.4

Vectores Dinmicos

Lo que vimos en el inicio de este post, son vectores estticos, puesto que tienen una cantidad fija de memoria asignada y tamao definido que no podemos modificarlo. Sin embargo, un vector podra tener una cantidad variable de datos, a este se le llama un vector dinmico. Para usar vectores dinmicos necesitamos gestionar memoria dinmica. Si bien es cierto que esto trae enormes ventajas, el hacer un mal uso de la memoria dinmica nos podra traer problemas desastrozos. Por eso es importante que cuando creemos vectores dinmicos tambin liberemos la memoria utilizada. Obviamente eliminaremos la memoria utilizada cuando ya no necesitamos ms usar, en este caso, un determinado vector. El operador new sirve para reservar memoria dinmica. El operador delete se usa para liberar la memoria dinmica reservada con new. Para liberar memoria de un array dinmico usamos delete[] . El espacio de memoria que hemos reservado con new tendr vida hasta que finalize la ejecucin del programa o cuando liberemos ese espacio con delete. Siempre es recomendable liberar memoria para posteriormente no tener problemas con excesivo consumo de memoria. Un simple ejemplo: 01 #include <iostream> 02 using namespace std; 03 04 int main() 05 { 06 int *pv;

07 08 09 10 11 12 13 14 15 16 17 18

int dim; cout << "Ingresa el tamanyo del vector" << endl; cin >>dim; pv = new int[dim]; for(int i=0;i<dim;i++){ pv[i] = i * i; cout << pv[i] << " "; } delete[] pv;

19 return 0; 20 }

TEMA 6. PROGRAMACION ORIENTADA A OBJETOS.

6.1

Que es la programacin orientada a objetos?

Hasta ahora estamos estado "cuadriculando" todo para obtener algoritmos: tratbamos de convertir cualquier cosa en funciones y variables que pudieramos emplear en nuestros programas. Pero no todo lo que nos rodea es tan fcil de cuadricular. Supongamos por ejemplo que tenemos que describir una puerta desde nuestro programa. En la zona de declaracin de variables detallaramos datos como su tamao o su color. Pero no basta con eso. De hecho, eso no es lo ms importante: lo que hace que una puerta sea una puerta es el hecho de que se pueda abrir y se pueda cerrar. Por tanto, si queremos simular o controlar una puerta desde nuestro programa, deberamos crear tambin las funciones AbrirPuerta y CerrarPuerta en alguna otra parte de nuestro fuente. No est mal, pero es antinatural: una puerta es un conjunto: no podemos separar su color de su tamao, o de la forma en que debemos abrirla o cerrarla. Sus caractersticas son tanto las fsicas (lo que hasta ahora llambamos variables) como sus comportamientos en distintas circunstancias (lo que para nosotros eran las funciones). Todo ello va siempre unido, formando un OBJETO. Por otra parte, si tenemos que explicar a alguien lo que es el portn de un garaje, y ese alguien no lo ha visto nunca, pero conoce cmo es la puerta de su casa, le podemos decir "se parece a una puerta de una casa, pero es ms grande para que quepan los coches, est hecha de metal en vez de madera...". Las dos cosas son puertas: se trata de dos objetos que pertenecen a la misma CLASE.

Finalmente, conviene recordar que "abrir" no se refiere slo a una puerta. Tambin podemos hablar de abrir una ventana o un libro, por ejemplo. Pues con esta discusin hemos comentado casi sin saberlo las tres caractersticas ms importantes de la Programacin Orientada a Objetos (POO):

ENCAPSULACION: No podemos separar los comportamientos de las caractersticas de un objeto. Los comportamientos del objeto sern funciones, que en OOP llamaremos METODOS. Las caractersticas del objeto sern variables, como las que hemos usado siempre, que en OOP llamaremos ATRIBUTOS. La apariencia de un objeto en C++, como veremos un poco ms adelante, recordar a un registro o "struct", que contendr funciones adems de datos. HERENCIA: Unos objetos pueden "heredar" mtodos y atributos de otros. Esto hace ms fcil definir objetos nuevos a partir de otros que ya tenamos anteriormente (como ocurra con el portn y la puerta) y facilitar la reutilizacin de los programas, pudiendo aprovechar buena parte de los anteriores... si estn bien diseados. POLIMORFISMO: Un mismo nombre de un mtodo puede hacer referencia a comportamientos relativamente distintos (como abrir una puerta o abrir un libro). En C++ el polimorfismo llega incluso al nivel de los operadores: podremos "redefinir" el operador + para que sume matrices, ficheros o cualquier tipo de objeto que nos interese.

(Nota: en C++ es frecuente llamar tambin "variables de instancia" o "variables miembro" a los atributos, y "funciones miembro" a los mtodos). Comentado esto, vamos a empezar a ver ejemplos en C++ para tratar de fijar estos primeros conceptos y de ver la sintaxis de este lenguaje. A partir de unos primeros ejemplos sencillos, iremos profundizando paulatinamente.

6.2

Definicin de clase

Una clase, es simplemente una abstraccin que hacemos de nuestra experiencia sensible. El ser humano tiende a agrupar seres o cosas -objetos- con caractersticas similares en grupos -clases-. As, aun cuando existen por ejemplo multitud de vasos diferentes, podemos reconocer un vaso en cuanto lo vemos, incluso aun cuando ese modelo concreto de vaso no lo hayamos visto nunca. El concepto de vaso es una abstraccin de nuestra experiencia sensible. Quizs el ejemplo ms claro para exponer esto lo tengamos en las taxonomas; los bilogos han dividido a todo ser (vivo o inerte) sobre la tierra en distintas clases. Tomemos como ejemplo una pequea porcin del inmenso rbol taxonmico:

Ellos, llaman a cada una de estas parcelas reino, tipo, clase, especie, orden, familia, gnero, etc.; sin embargo, nosotros a todas las llamaremos del mismo modo: clase. As, hablaremos de la clase animal, clase vegetal y clase mineral, o de la clase flidos y de las clases leo (len) y tigris (tigre). Cada clase posee unas cualidades que la diferencian de las otras. As, por ejemplo, los vegetales se diferencian de los minerales -entre otras muchas cosas- en que los primeros son seres vivos y los minerales no. De los animales se diferencian en que las plantas son capaces de sintetizar clorofila a partir de la luz solar y los animales no. Situmonos en la clase felinos (felis), aqu tenemos varias subclases (gneros en palabras de los bilogos): len, tigre, pantera, gato, etc. cada una de estas subclases, tienen caractersticas comunes (por ello los identificamos a todos ellos como felinos) y caractersticas diferenciadoras (por ello distinguimos a un len de una pantera), sin embargo, ni el len ni la pantera en abstracto existen, existen leones y panteras particulares, pero hemos realizado una abstraccin de esos rasgos comunes a todos los elementos de una clase, para llegar al concepto de len, o de pantera, o de felino. La clase len se diferencia de la clase pantera en el color de la piel, y comparte ciertos atributos con el resto de los felinos -uas retrctiles por ejemplo- que lo diferencian del resto de los animales. Pero la clase len, tambin hereda de las clases superiores ciertas cualidades: columna vertebral (de la clase vertebrados) y es alimentado en su infancia por leche materna (de la clase mamferos). Vemos cmo las clases superiores son ms generales que las inferiores y cmo, al ir bajando por este rbol, vamos definiendo cada vez ms (dotando de ms cualidades) a las nuevas clases. Hay cualidades que ciertas clases comparten con otras, pero no son exactamente iguales en las dos clases. Por ejemplo, la clase hombre, tambin deriva de la clase vertebrado, por lo que ambos

poseen columna vertebral, sin embrago, mientras que en la clase hombre se halla en posicin vertical, en la clase len la columna vertebral est en posicin horizontal. En OOP existe otro concepto muy importante asociado al de clase, el de "clase abstracta". Una clase abstracta es aquella que construimos para derivar de ella otras clases, pero de la que no se puede instanciar. Por ejemplo, la clase mamfero, no existe como tal en la naturaleza, no existe ningn ser que sea tan solo mamfero (no hay ninguna instanciacin directa de esa clase), existen humanos, gatos, conejos, etc. Todos ellos son mamferos, pero no existe un animal que sea solo mamfero. Del mismo modo, la clase que se halla al inicio de la jerarqua de clases, normalmente es creada slo para que contenga aquellos datos y mtodos comunes a todas las clases que de ella derivan: Son clases abstractas. En rboles complejos de jerarquas de clases, suele haber ms de una clase abstracta. Este es un concepto muy importante: el de "clase abstracta". Como hemos dicho, una clase abstracta es aquella que construimos para derivar de ella otras clases, pero de la que no se puede instanciar. Por ejemplo, la clase mamfero, no existe como tal en la naturaleza, no existe ningn ser que sea tan solo mamfero (no hay ninguna instanciacin directa de esa clase), existen humanos, gatos, conejos, etc. Todos ellos son mamferos, pero no existe un animal que sea solo mamfero. Por ltimo, adelantemos algo sobre el concepto de objeto. El len, como hemos apuntado antes, no existe, igual que no existe el hombre; existen leones en los circos, en los zoolgicos y, segn tenemos entendido, an queda alguno en la sabana africana. Tambin existen hombres, como usted, que est leyendo este libro (hombre en un sentido neutro, ya sea de la subclase mujer o varn), o cada uno de los que nos encontramos a diario en todas partes. Todos estos hombres comparten las caractersticas de la clase hombre, pero son diferentes entre s, en estatura, pigmentacin de la piel, color de ojos, complexin, etc. A cada uno de los hombres particulares los llamamos "objetos de la clase hombre". Decimos que son objetos de tipo hombre o que pertenecen a la clase hombre. Ms tcnicamente, Jos Luis Aranguren o Leonardo da Vinci son instanciaciones de la clase hombre; instanciar un objeto de una clase es crear un nuevo elemento de esa clase, cada nio que nace es una nueva instanciacin a la clase hombre.

6.3

Definicin de objeto

En POO, un objeto es un conjunto de datos y mtodos, donde los datos son lo que antes hemos llamado caractersticas o atributos, los mtodos son los comportamientos que pueden realizar. Lo importante de un sistema OOP es que ambos, datos y mtodos estn tan intrnsecamente ligados, que forman una misma unidad conceptual y operacional. En POO, no se pueden desligar los datos de los mtodos de un objeto. As es como ocurre en el mundo real. Vamos ahora a dar una serie de ejemplos en los que nos iremos acercando paulatinamente a los objetos informticos. Los ltimos ejemplos son para aquellos que ya conocen Java y/o C++; sin embargo, estos ejemplos que exigen conocimientos informticos, no son imprescindibles para entender plenamente el concepto de clase y el de objeto.

Observe que aunque los datos y los mtodos se han enumerado verticalmente, no existe ninguna correspondencia entre un dato y el mtodo que aparece a su derecha, es una simple enunciacin. Ejemplo 1 Tomemos la clase len de la que hablamos antes y veamos cuales seran algunos de sus datos y de sus mtodos.

Ejemplo 2 Nuestros objetos (los informticos), como hemos comentado antes, se parecen mucho a los del mundo real, al igual que estos, poseen propiedades (datos) y comportamientos (mtodos). Tomemos para nuestro ejemplo un cassette. Veamos cmo lo definiramos al estilo de POO.

Ejemplo 3 Pongamos otro ejemplo algo ms prximo a los objetos que se suelen tratar en informtica: un recuadro en la pantalla. El recuadro pertenecera a una clase a la llamaremos marco. Veamos sus datos y sus mtodos.

6.4

Herencia

Esta es la cualidad ms importante de un sistema POO, la que nos dar mayor potencia y productividad, permitindonos ahorrar horas y horas de codificacin y de depuracin de errores. Es por ello que me niego a considerar que un lenguaje es OOP si no incluye herencia, como es el caso de Visual Basic (al menos hasta la versin 5, que es la ltima que conozco). Como todos entendemos lo que es la herencia biolgica, continuaremos con nuestro ejemplo taxonmico del que hablbamos en el epgrafe anterior. La clase len, como comentbamos antes, hereda cualidades -mtodos, en lenguaje POO- de todas las clases predecesoras -padres, en POO- y posee mtodos propios, diferentes a los del resto de las clases. Es decir, las clases van especializndose segn se avanza en el rbol taxonmico. Cada vez que creamos una clase heredada de otra (la padre) aadimos mtodos a la clase padre o modificamos alguno de los mtodos de la clase padre. Veamos qu hereda la clase len de sus clases padre:

La clase len hereda todos los mtodos de las clases padre y aade mtodos nuevos que forman su clase distinguindola del resto de las clases: por ejemplo el color de su piel. Observemos ahora algo crucial que ya apuntbamos antes: dos subclases distintas, que derivan de una misma clase

padre comn, pueden heredar los mtodos de la clase padre tal y como estos han sido definidos en ella, o pueden modificar todos o algunos de estos mtodos para adaptarlos a sus necesidades. En el ejemplo que exponamos antes, en la clase len la alimentacin es carnvora, mientras que en la clase hombre, se ha modificado ste dato, siendo su alimentacin omnvora. Pongamos ahora un ejemplo algo ms informtico: supongamos que usted ha construido una clase que le permite leer nmeros enteros desde teclado con un formato determinado, calcular su IVA y almacenarlos en un fichero. Si desea poder hacer lo mismo con nmeros reales (para que admitan decimales), solo deber crear una nueva subclase para que herede de la clase padre todos sus mtodos y redefinir solo el mtodo de lectura de teclado. Esta nueva clase sabe almacenar y mostrar los nmeros con formato porque lo sabe su clase padre. Las cualidades comunes que comparten distintas clases, pueden y deben agruparse para formar una clase padre -tambin llamada superclase-. Por ejemplo, usted podra derivar las clases presupuesto, albarn y factura de la superclase pedidos, ya que estas clases comparten caractersticas comunes. De este modo, la clase padre poseera los mtodos comunes a todas ellas y slo tendramos que aadir aquellos mtodos propios de cada una de las subclases, pudiendo reutilizar el cdigo escrito en la superclase desde cada una de las clases derivadas. As, si enseamos a la clase padre a imprimirse, cada uno de los objetos de las clases inferiores sabrn automticamente y sin escribir ni una solo lnea ms de cdigo imprimirse. La herencia como puede intuir, es la cualidad ms importante de la POO, ya que le permite reutilizar todo el cdigo escrito para las superclases re-escribiendo solo aquellas diferencias que existan entre stas y las subclases. Veamos ahora algunos aspectos ms tcnicos de la herencia: A la clase heredada se le llama, subclase o clase hija, y a la clase de la que se hereda superclase o clase padre. Al heredar, la clase heredada toma directamente el comportamiento de su superclase, pero puesto que sta puede derivar de otra, y esta de otra, etc., una clase toma indirectamente el comportamiento de todas las clases de la rama del rbol de la jerarqua de clases a la que pertenece. Se heredan los datos y los mtodos, por lo tanto, ambos pueden ser redefinidos en las clases hijas, aunque lo ms comn es redefinir mtodos y no datos. Muchas veces las clases especialmente aquellas que se encuentran prximas a la raz en el rbol de la jerarqua de clases son abstractas, es decir, slo existen para proporcionar una base para la creacin de clases ms especficas, y por lo tanto no puede instanciarse de ellas; son las clases virtuales. Una subclase hereda de su superclase slo aquellos miembros visibles desde la clase hija y por lo tanto solo puede redefinir estos. Una subclase tiene forzosamente que redefinir aquellos mtodos que han sido definidos como abstractos en la clase padre o padres. Normalmente, como hemos comentado, se redefinen los mtodos, aun cuando a veces se hace necesario redefinir datos de las clases superiores. Al redefinir un mtodo queremos o bien sustituir el funcionamiento del mtodo de la clase padre o bien ampliarlo.

En el primer caso (sustituirlo) no hay ningn problema, ya que a la clase hija la dotamos con un mtodo de igual nombre que el mtodo que queremos redefinir en la clase padre y lo implementamos segn las necesidades de la clase hija. De este modo cada vez que se invoque este mtodo de la clase hija se ejecutar su cdigo, y no el cdigo escrito para el mtodo homnimo de la clase padre. Pero si lo que queremos es ampliar el funcionamiento de un mtodo existente en la clase padre (lo que suele ser lo ms habitual), entonces primero tiene que ejecutarse el mtodo de la cla se padre, y despus el de la clase hija. Pero como los dos mtodos tienen el mismo nombre, se hace necesario habilitar alguna forma de distinguir cuando nos estamos refiriendo a un mtodo de la clase hija y cuando al del mismo nombre de la clase padre. Esto se hace mediante el uso de dos palabras reservadas, las cuales pueden variar dependiendo del lenguaje que se utilice, pero que normalmente son: this (en algunos lenguajes se utiliza la palabra reservada Self) y super:

this
Con esta palabra, podemos referirnos a los miembros de la clase. En esencia, una clase en C++ es una estructura en el estilo de C con algunas ventajas sencillas pero muy potentes.

6.5

Polimorfismo

Por polimorfismo entendemos aquella cualidad que poseen los objetos para responder de distinto modo ante el mismo mensaje. Pongamos por ejemplo las clases hombre, vaca y perro, si a todos les damos la orden -enviamos el mensaje- Come, cada uno de ellos sabe cmo hacerlo y realizar este comportamiento a su modo. Veamos otro ejemplo algo ms ilustrativo. Tomemos las clases barco, avin y coche, todas ellas derivadas de la clase padre vehculo; si les enviamos el mensaje Desplzate, cada una de ellas sabe cmo hacerlo. Realmente, y para ser exactos, los mensaje no se envan a las clases, sino a todos o algunos de los objetos instanciados de las clases. As, por ejemplo, podemos decirle a los objetos Juan Sebastin el Cano y Kontiqui, de la clase barco que se desplacen, con los que el resto de los objetos de esa clase permanecern inmviles. Del mismo modo, si tenemos en pantalla cinco recuadros (marcos) y tres textos, podemos decirle a tres de los recuadros y a dos de los textos que cambien de color y no decrselo a los dems objetos. Todos estos sabrn cmo hacerlo porque hemos redefinido para cada uno de ellos su mtodo Pintarse que bien podra estar en la clase padre Visual (conjunto de objetos que pueden visualizarse en pantalla). En programacin tradicional, debemos crear un nombre distinto para la accin de pintarse, si se trata de un texto o de un marco; en OOP el mismo nombre nos sirve para todas las clases creadas si as lo queremos, lo que suele ser habitual. El mismo nombre suele usarse para realizar acciones similares en clases diferentes.

Si enviamos el mensaje Imprmete a objetos de distintas clases, cada uno se imprimir como le corresponda, ya que todos saben cmo hacerlo. El polimorfismo nos facilita el trabajo, ya que gracias a l, el nmero de nombres de mtodos que tenemos que recordar disminuye extensiblemente. La mayor ventaja la obtendremos en mtodos con igual nombre aplicados a las clases que se encuentran prximas a la raz del rbol de clases, ya que estos mtodos afectarn a todas las clases que de ellas se deriven.

6.6

Sobrecarga

La sobrecarga puede ser considerada como un tipo especial de polimorfismo que casi todos los lenguajes de POO incluyen. Varios mtodos (incluidos los "constructores", de los que se hablar ms adelante) pueden tener el mismo nombre siempre y cuando el tipo de parmetros que recibe o el nmero de ellos sea diferente. De este modo, por ejemplo la clase File puede tener tantos mtodo Write() como tipos de datos queramos escribir (no se preocupe si no entiende la nomenclatura, cntrese en la idea): File::Write( int i ); Escribe un integer File::Write( long l ); Escribe un long File::Write( float f ); Escribe un flota File::Write( string s ); Escribe una cadena File::Write( string s, boolean b ); Escribe una cadena pasndola a maysculas

6.7

Declaracin de clases en C++

Para declarar una clase, todo lo que se necesita es escribir una definicin de estructura y sustituir la palabra reservada struct por class. Por ejemplo, una clase empleado con campos como el nombre, el departamento, la posicin, el una funcin que nos imprima la informacin de este quedara as: class Empleado { char* m_nombre; char* m_departamento; char* m_posicion; long m_salario; void Imprimir( Empleado infoEmpleado); } Cuando usted declara una clase en C++, no se reserva memoria para la clase hasta que usted crea un objeto de la clase. Crear un objeto de una clase se llama instanciar un objeto. Un objeto creado de una clase de denomina instancia de una clase. Por ejemplo, yo puedo tener una instancia de

empleado con el valor en m_nombre=Jose, m_departamento=Sistemas, m_posicion=programador y m_salario=3000000 por ejemplo.

6.7.1. Especificadores de acceso

C++ utiliza especificadores de acceso para permitir controlar a una clase el acceso a las variables de datos de esa clase. Los especificadores de acceso permiten acceder a algunos miembros de la clase y restringir el acceso a otros. Hay tres especificadores de acceso en C++: public, private y protected. Cuando usted declara pblico (public) un miembro de una clase, usted permite el acceso a tal miembro desde dentro y fuera de la clase. Los miembros de datos que son declarados protegidos ( protected ) son nicamente accesibles por funciones miembro de la clase, pero no se pueden acceder a ellos desde otras clases. Cuando un miembro de una clase es declarado privado ( private ) es inccesible no slo desde otras clases y otras partes del programa, sino tambin desde sus clases derivadas. Las clases derivadas se explicaran posteriormente. Miremos el siguiente programa de ejemplo. Se compone de tres partes: la primera una declaracin de una clase llamada Empleado: class Empleado { private: char* m_nombre; char* m_departamento; char* m_posicion; long m_salario; public: void ImprimirInfo(); void SetNombre( char* nombre ) { m_nombre = nombre } void SetDepartamento( char * departamento) { m_departamento = departamento } void SetPosicion ( char* posicion ) { m_posicion = posicion } void SetSalario ( long salario ) { m_salario = salario } const char* GetNombre( ){ return m_nombre } const char* GetDepartamento( ){ return m_departamento } const char* GetPosicion( ){ return m_posicion } const char* GetSalario( ){ return m_salario } };

Las funciones SetNombre, SetDepartamento, setPosicion, setSalario, GetNombre, GetDepartamento, GetPosicion y GetSalario se denominan funciones intercaladas, que son funciones que se declaran en una sola lnea.

Las variables de miembro son declaradas privadas para que funciones de miembro de otras

funciones no tengan acceso a ellas sino a travez de la correspondiente funcion Get o Set. Las funciones de miembro si son declaradas pblicas de tal modo que se pueda acceder a ellas desde otras funciones.

La definicin de la funcin PrintInfo puede quedar as: void Empleado::ImprimirInfo( ) { cout << "Nombre: " << m_nombre << '\n'; cout << "Departamento: " << m_departamento << '\n'; cout << "Puesto: " << m_posicion << '\n'; cout << "Salario: " << m_salario << '\n'; } Los dos puntos ( :: ) se denomina operador de resolucin de ambito. Nos indica que la funcin que estamos definiendo que en este caso es ImprimirInfo, pertenece a la clase Empleado. La tercera parte es la funcin main. Veamos como podra ser: void main() { //creacion de un objeto de la clase Empleado Empleado empleado12; //asignacion de valores a las variables miembro empleado12.SetNombre("Jose"); empleado12.SetDepartamento("Sistemas"); empleado12.SetPosicion("Programador"); empleado12.SetSalario(3000000); //impresion de los datos empleado12.ImprimirInfo(); }

Entonces, primero en:

Empleado empleado12; Se instancia un objeto de la clase Empleado con nombre empleado12. Entonces empleado12 tiene la estructura de la clase Empleado.

Luego, en las lneas siguientes a la instanciacin del objeto, se le asignan los valores iniciales a sus variables:

//asignacion de valores a las variables miembro empleado12.SetNombre("Jose"); empleado12.SetDepartamento("Sistemas"); empleado12.SetPosicion("Programador"); empleado12.SetSalario(3000000); Finalmente se llama ImprimirInfo para imprimir el contenido de las variables: //impresion de los datos empleado12.ImprimirInfo(); que lo que har es imprimir el valor de las variables en la pantalla.

Permitir el acceso a las variables solo a travs de funciones, que en la mayora de los casos se llaman SetXxx y GetXxx, se llama encapsulacin de datos. Las funciones que necesitan valores de otra clase, llaman a las funciones que les dan acceso y obtienen estos datos sin conocimiento de detalles especficos de como se manipulan los datos.

6.7.2

Operador de resolucin de ambito

El operador de mbito permte acceder de otra manera funciones de miembro y variables de miembro de una clase. Cuando aparece el operador de resolucin de mbito entre el nombre de la clase y el nombre de la funcin en un programa significa que la funcin especificada es un miembro de la clase especificada: Empleado::ImprimirInfo(); El operador de resolucin de ambito se suele utilizar para llamar funciones que se encuentran fuera del ambito de la funcin de llamada. Entonces, para llamar la funcin ImprimirInfo() de la clase Empleado se fuera de su ambito se debe utilizar este operador. La principal diferencia entre este operador y los operadores punto y flecha es que el operador de resolucin de ambito se utiliza para acceder a miembros de clases, y el operador punto y flecha para acceder a miembros de objetos especficos. Veamos el siguiente cdigo: ::MessageBox("Prueba del operador de resolucion"); Si el operador de resolucin de ambito aparece sin un nombre de clase delante, significa que la funcin que esta llamando ( MessageBox ) no es miembro de ninguna clase.

6.7.3

El apuntador this

Este apuntador lo tiene todo objeto en C++, apuntando a s mismo. Se puede utilizar este apuntador en cualquier lado para acceder a todos los miembros del objeto al cual est apuntando este apuntador this. Veamos el siguiente cdigo: #include <iostream.h> class Miclase { public: Miclase() {} //constructor por defecto ~Miclase() {} //destructor void yoMismo() { return this } }; int main() { void* pClase; Miclase unObjeto; pClase = unObjeto.yoMismo(); cout<< "El puntero pClase es " << pClase <<'\n.'; return 0; } En este ejemplo la clase yoMismo() devuelve un apuntador al objeto que lo posee de la clase Miclase. El main() crea un objeto de la clase Miclase y luego llama a yoMismo(). Lo almacena en pClase y luego ensea el contenido, que en este caso es el valor de la referencia. Entonces este apuntador nos permitira realizar muchas cosas sobre los propios objetos con esta referencia.