Apunte de lenguaje de programacion

7/23/2019 Apunte de lenguaje de programacion

http://slidepdf.com/reader/full/apunte-de-lenguaje-de-programacion 1/96

- 1 -

TALLER DE INFORMÁTICA

APUNTES

LENGUAJE C- Año 2010 -

UNIVERSIDAD NACIONAL DE MISIONES - FACULTAD DE INGENIERÍAOBERÁ – MISIONES – ARGENTINA

INDICE

PRÓLOGO. ................................................................................................................... - 1 - CAPITULO 1. INTRODUCCIÓN................................................................................ - 2 - ¿Por qué usar C?............................................................................................................ - 2 -

CAPITULO 2. LENGUAJE C. ..................................................................................... - 4 - 2.1. Operaciones básicas de programación.................................................................... - 4 - 2.1.1. Creación del fichero fuente. ................................................................................ - 4 - 2.1.2. Creación del fichero objeto. ................................................................................ - 4 - 2.1.3. Creación del fichero ejecutable. .......................................................................... - 4 - 2.1.3.1. Uso de librerías................................................................................................. - 4 - 2.1.3.2. Ficheros ejecutables y enlazadores................................................................... - 5 - 2.2. Manejo de Errores. ................................................................................................. - 5 - 2.2.1. Errores de sintaxis. .............................................................................................. - 5 - 2.2.2. Warnings o Avisos. ............................................................................................. - 5 - 2.2.3. Errores de enlazado. ............................................................................................ - 6 -

2.2.4. Errores de ejecución. ........................................................................................... - 6 - 2.2.5. Errores de diseño. ................................................................................................ - 6 - CAPITULO 3. ESTRUCTURA DE UN PROGRAMA. .............................................. - 7 - 3.1. Directivas del preprocesador. ................................................................................. - 7 - 3.2. Declaración de variables globales. ......................................................................... - 8 - 3.3. Prototipos de funciones. ......................................................................................... - 8 - 3.4. Declaración de clases. ............................................................................................ - 8 - 3.5. Función main(). ...................................................................................................... - 8 - 3.6. Definición de funciones.......................................................................................... - 8 - 3.7. Definición de clases................................................................................................ - 8 - CAPITULO 4. DATOS, VARIABLES Y CONSTANTES.......................................... - 9 -

4.1 Datos........................................................................................................................ - 9 - 4.2. Variables................................................................................................................. - 9 - 4.2.1. Identificadores. .................................................................................................. - 10 - 4.2.2. Declaración de variables.................................................................................... - 10 - 4.2.2.1. Declaración de una variable de tipo entero (integer)...................................... - 11 - 4.2.2.2. Declaración de una variable de tipo punto flotante (float)............................. - 11 - 4.2.2.3. Declaración de una variable de tipo punto flotante doble precisión (double).- 11 -4.2.2.4. Declaración de una variable sin tipo (void).................................................... - 11 -



- 2 -

4.2.2.5. Declaración de una variable de tipo enumerado (enum). ............................... - 11 -4.2.2.6. Declaración de una variable de tipo boleana (boolean).................................. - 12 -4.2.3. Inicialización de variables ................................................................................. - 12 -4.2.4. Ejercicios sobre Variables ................................................................................. - 12 -4.3. Constantes............................................................................................................. - 13 -

4.3.1. Normas para la notación. ................................................................................... - 13 -4.3.1.1. Constantes "int". ............................................................................................. - 13 -4.3.1.2. Constantes "long". .......................................................................................... - 14 -4.3.1.3. Constantes "long long". .................................................................................. - 15 -4.3.1.4. Constantes "unsigned". ................................................................................... - 15 -4.3.1.5. Constantes "unsigned long"............................................................................ - 15 -4.3.1.6. Constantes "unsigned long long".................................................................... - 15 -4.3.1.7. Constantes "float". .......................................................................................... - 16 -4.3.1.8. Constantes "double". ...................................................................................... - 16 -4.3.1.9. Constantes "long double". .............................................................................. - 16 -4.3.1.10. Constantes "char". ........................................................................................ - 16 -

4.3.2. Recomendaciones en el uso de la notación. ...................................................... - 16 -4.3.2.1. Constantes enteras. ......................................................................................... - 16 -4.3.2.2. Constantes punto flotante. .............................................................................. - 16 -4.3.3 Constantes carácter. Comentario adicional. ....................................................... - 17 -4.3.3.1. Código ASCII. ................................................................................................ - 17 -4.3.3.2. Carácter nulo. ................................................................................................. - 18 -4.3.3.3. Carácter EOF. ................................................................................................. - 18 -4.3.4. Ejercicios ........................................................................................................... - 19 -CAPITULO 5. OPERADORES. ................................................................................. - 20 -5.1. Operadores aritméticos. ........................................................................................ - 20 -5.1.1. Operadores aritméticos unitarios. ...................................................................... - 20 -5.1.1.1. Operadores '+' y '-‘ ...................................................................................... - 20 -5.1.1.2. Operadores '++' y '--'....................................................................................... - 20 -5.1.2. Operadores aritméticos binarios. ....................................................................... - 21 -5.2. Operadores relacionales........................................................................................ - 22 -5.3. Operadores lógicos. .............................................................................................. - 22 -5.3.1. Operador && o AND. ....................................................................................... - 22 -5.3.2. Operador || u OR............................................................................................... - 23 -5.3.3. Operador ! o NOT. ............................................................................................ - 23 -5.4. Operadores de asignación..................................................................................... - 23 -5.5. Operador "sizeof". ................................................................................................ - 24 -5.6. Operador condicional (?). ..................................................................................... - 24 -5.7. Operador coma (,)................................................................................................. - 25 -CAPITULO 6. EXPRESIONES.................................................................................. - 26 -6.1. Expresiones aritméticas. ....................................................................................... - 26 -6.1.1. Reglas de Precedencia. ...................................................................................... - 27 -6.2. Expresiones lógicas. ............................................................................................. - 27 -6.2.1. Expresiones comparativas. ................................................................................ - 28 -6.2.1.1. Aplicación en datos tipo carácter.................................................................... - 28 -6.2.1.2. Aplicación en datos tipo lógico. ..................................................................... - 28 -6.2.1.3. Aplicación en datos tipo punto flotante. ......................................................... - 28 -



- 3 -

6.2.2. Expresiones lógicas. .......................................................................................... - 28 -6.3. Ejercicios con operadores y expresiones .............................................................. - 29 -CAPITULO 7. INSTRUCCIONES............................................................................. - 31 -7.1. Bloques. ................................................................................................................ - 31 -7.2. Expresiones........................................................................................................... - 32 -

7.2.1. Llamadas a función............................................................................................ - 32 -7.2.2. Asignación. ........................................................................................................ - 32 -7.2.3. Nula. .................................................................................................................. - 32 -7.3. Bucles. .................................................................................................................. - 32 -7.3.1. Bucle "while"..................................................................................................... - 33 -7.3.2. Bucle "do while"................................................................................................ - 33 -7.3.3. Bucle "for". ........................................................................................................ - 34 -7.4. Etiquetas. .............................................................................................................. - 34 -7.4.1. Etiquetas de identificación................................................................................. - 34 -7.4.2. Etiquetas "case" y "default"............................................................................... - 34 -7.5. Sentencias de Selección........................................................................................ - 35 -

7.5.1. Sentencia "if...else"............................................................................................ - 35 -7.5.2. Sentencia "switch". ............................................................................................ - 35 -7.6. Sentencias de salto................................................................................................ - 36 -7.6.1. Sentencia de ruptura "break". ............................................................................ - 36 -7.6.2. Sentencia “continue". ........................................................................................ - 37 -7.6.3. Sentencia de salto "goto". .................................................................................. - 37 -7.6.4. Sentencia de retorno "return". ........................................................................... - 37 -7.6.5. Sobre las sentencias de salto y la programación estructurada. .......................... - 38 -7.7. Comentarios.......................................................................................................... - 38 -7.8. Ejercicios con sentencias. ..................................................................................... - 39 -CAPITULO 8. FUNCIONES. ..................................................................................... - 40 -8.1. Declaración de función. El Prototipo. .................................................................. - 40 -8.1.1. Funciones extern y static. .................................................................................. - 41 -8.2. Definición de función. .......................................................................................... - 41 -8.2.1. Tipo de almacenamiento.................................................................................... - 41 -8.2.2. Tipo de valor de retorno. ................................................................................... - 41 -8.2.3. Modificadores opcionales.................................................................................. - 41 -8.2.4. Nombre de la función. ....................................................................................... - 42 -8.2.5. Lista de parámetros............................................................................................ - 42 -8.2.6. Cuerpo de función. ............................................................................................ - 42 -8.3. Función main(). .................................................................................................... - 42 -8.4. Ámbito de variables. ......................................................................................... - 43 -8.4.1. Variables locales................................................................................................ - 43 -8.4.2. Variables globales. ............................................................................................ - 43 -8.5. Ejercicios. ............................................................................................................. - 44 -CAPITULO 9. ARREGLOS. ...................................................................................... - 47 -9.1. Cadena de caracteres. ........................................................................................... - 47 -9.2. Arreglos. ............................................................................................................... - 48 -9.2.1. Inicialización de un arreglo. .............................................................................. - 49 -9.2.2. Operadores utilizados con arreglos.................................................................... - 49 -9.3. Algoritmos de ordenación: método de la burbuja. ............................................... - 50 -



- 4 -

9.4. Ejercicios: cadenas de caracteres.......................................................................... - 51 -9.5. Ejercicios: arreglos. .............................................................................................. - 51 -CAPITULO 10. PUNTEROS...................................................................................... - 54 -10.1. Declaración de punteros ..................................................................................... - 55 -10.2. Obtener punteros a variables .............................................................................. - 56 -

10.3. Diferencia entre punteros y variables ................................................................. - 57 -10.4. Correspondencia entre arrays y punteros............................................................ - 58 -10.5. Operaciones con punteros................................................................................... - 58 -10.5.1. Asignación ....................................................................................................... - 59 -10.5.2. Operaciones aritméticas................................................................................... - 59 -10.5.3. Comparación entre punteros............................................................................ - 59 -10.6. Punteros genéricos.............................................................................................. - 60 -10.7. Punteros a estructuras ......................................................................................... - 61 -10.8. Ejemplos de uso de punteros .............................................................................. - 61 -10.8.1. Ejemplo 1......................................................................................................... - 61 -10.8.2. Ejemplo 2......................................................................................................... - 62 -

10.9. Variables dinámicas............................................................................................ - 63 -10.10. Ejercicios .......................................................................................................... - 64 -CAPITULO 11. ESTRUCTURAS.............................................................................. - 66 -11.1. Estructuras. ......................................................................................................... - 66 -11.2. Funciones en el interior de estructuras ............................................................... - 67 -11.3. Inicialización de estructuras ............................................................................... - 69 -11.4. Asignación de estructuras................................................................................... - 69 -11.5. Arrays de estructuras .......................................................................................... - 70 -11.6. Estructuras anidadas ........................................................................................... - 71 -11.7. Operador "sizeof" con estructuras ...................................................................... - 72 -11.8. Campos de bits ................................................................................................... - 73 -11.9. Punteros a estructuras ......................................................................................... - 75 -11.9.1. Ejemplo Gestion dinámica de Memoria y Lista Enlazada simple................... - 76 -11.9.2. Ejemplo Gestión dinámica de Memoria y Lista Enlazada Doble.................... - 77 -11.10. Ejercicios .......................................................................................................... - 78 -CAPITULO 12. MÁS OPERADORES. ..................................................................... - 82 -12.1. Operadores de Referencia (&) e Indirección (*) ................................................ - 82 -12.2. Operadores . y -> ................................................................................................ - 82 -12.3. Operador de preprocesador................................................................................. - 82 -12.4. Operadores de manejo de memoria "new" y "delete" ........................................ - 82 -12.4.1. Operador new .................................................................................................. - 83 -12.4.1.1 Ejemplo Gestion dinámica de Memoria y Lista Enlazada Doble.................. - 83 -12.4.2-Operador delete ................................................................................................ - 85 -CAPITULO 13. PASAJE DE VALORES A FUNCIONES. ...................................... - 86 -13.1. Parámetros por valor y parámetros por referencia.............................................. - 86 -13.1.1. Referencias a variables .................................................................................... - 87 -13.2. Paso de parámetros por referencia...................................................................... - 87 -13.3. Punteros como parámetros de funciones ............................................................ - 89 -13.4. Funciones que devuelven referencias................................................................. - 90 -13.5. Arrays como parámetros de funciones ............................................................... - 91 -



TALLER DE INFORMÁTICA Prólogo

- 1 -

PRÓLOGO.El objetivo de este apunte es proporcionar de una guía para aprender a programar bajo el EntornoGráfico del Sistema Operativo Linux en Lenguaje C.Para ello, luego de varios intentos y pruebas sobre las aplicaciones a utilizar en el ámbito delSoftware Libre, se optó por la Distribución de Linux Ubuntu y, como interface de IDE (IntegratedDevelopment Environment), el Anjuta. Este apunte está destinado a los alumnos de los cursos deTaller de Informática y Computación de la Facultad de Ingeniería de Oberá.Como aclararación se expone que el apunte fue realizado mediante la compilación / edición demateriales extraídos fundamentalmente de Internet. En algunos casos con modificaciones parcialesy, en otros, modificaciones totales. Otro aporte utilizado, sobre todo en la organización de lostemas, fue obtenido de Libros; finalmente, se utilizaron los ejemplos de guías y apuntes de lasCátedras de años anteriores. En conclusión, este apunte es el resultado del trabajo de muchaspersonas, organizado de la manera más apropiada para el dictado de las asignaturas mencionadasy poder conseguir los objetivos propuestos en las mismas.

Los ejemplos de código de este apunte fueron probados sobre:

• gcc versión 4.0.3 (Ubuntu 4.0.3-1ubuntu5) • Ubuntu 6.06 LTS - la versión Dapper Drake - publicada en junio de 2006. • Anjuta 1.2.4a (http://anjuta.org/ )

El libro se divide en partes, la Parte 1 incluye los capítulos que se desarrollan en la Materia Taller deInformática. La Parte 2 y 3 son los temas que conjuntamente con la Parte 1 deben ser vistos en laMateria Computación.En los Apéndices fueron dispuestos materiales que se considera pueden ser importantes comoconsulta o complemento.

Imágenes utilizadas a lo largo del texto



TALLER DE INFORMÁTICA CAPITULO 1. Introducción

- 2 -

CAPITULO 1. INTRODUCCIÓN.EL lenguaje C fue creado por Dennis Ritchie en los laboratorios de la Bell Telephone en 1972. Elmismo fue pensado para desarrollar un Sistema Operativo llamado UNIX. Este lenguaje es elsucesor del lenguaje llamado B (de allí el nombre C).

Debido a la flexibilidad y poder de programación, se extendió rápidamente y empezaron a surgirdistintas versiones. Como consecuencia de esto nace un comité llamado ANSI (American NationalEstándar Institute) el cuál define lo que se conoce como Standard C o como Estándar ANSI C.

¿Por qué usar C? Es poderoso y flexible: dadas las características del lenguaje, permite el desarrollo de

proyectos como sistemas operativos, procesadores de texto, hojas de cálculo, etc.

Es un lenguaje común: como está muy difundido su uso, existe una amplia variedad decompiladores y accesorios útiles para el programador.

Es transportable: se puede correr en cualquier tipo de computadora, esta ventaja se ve

aumentada con el Estándar C.

Posee pocas palabras clave: la base sobre la cual está construida la funcionalidad dellenguaje tiene pocas palabras claves.

Es modular: el código puede y debe ser escrito en módulos llamado funciones que puedenser utilizadas y re-utilizadas por otras aplicaciones o programas.

El lenguaje C++ es una versión mejorada del C, lo que significa que tiene todo lo que tieneel Estándar C más agregados para la Programación Orientada a Objetos.

¿Que diferencia hay entre C y C++? C++ es súper conjunto de C, es decir que C es unconjunto de C o C está contenido por C++.

El C++ incorpora nuevas características sin comprometer ninguna de las bondades del C,entre las cosas que se agregó son el concepto de clases, herencia, funciones virtuales dellenguaje Simula67 y sobrecarga de operadores del Algol68 (características que veremos endetalle en el curso).

¿Quien creó y cuando el C++?El C++ fue desarrollado por Bjarne Strousrup, en los laboratorio de Bell a principios de los 80, estoes 10 años después que el Lenguaje C.

¿Son compatibles los programas de C con C++?Uno de los grandes aciertos de C++, fue mantener la compatibilidad con C, de este modo cualquier

programa hecho en C puede ser considerado también como un programa de C++.¿Hay un Estándar para el C++?Sí. En forma resumida, el ANSI define un conjunto de reglas; cualquier compilador de C o de C++debe cumplir esas reglas, si no, no puede considerarse un compilador de C o C++. Estas reglasdefinen las características de un compilador en cuanto a palabras reservadas del lenguaje,comportamiento de los elementos que lo componen, funciones externas que se incluyen, etc. Unprograma escrito en ANSI C o en ANSI C++, podrá compilarse con cualquier compilador que



TALLER DE INFORMÁTICA CAPITULO 1. Introducción

- 3 -

cumpla la norma ANSI. Se puede considerar como una homologación o etiqueta de calidad de uncompilador.

¿Hay características no estándares en C++?Si, todos los compiladores incluyen, además del ANSI, ciertas características no ANSI, por ejemplolibrerías para gráficos. Pero mientras no usemos ninguna de esas características, sabremos que

nuestros programas son transportables, esdecir, que podrán ejecutarse en cualquier ordenador y con cualquier sistema operativo. Por eso eldesarrollo de un programa bajo, por ejemplo Dev C++ de Bloodshed, podría no compilarse bajo Anjuta.



TALLER DE INFORMÁTICA CAPITULO 2. Lenguaje C

- 4 -

CAPITULO 2. LENGUAJE C.

Para poder crear un programa en lenguaje C debemos realizar una serie de pasos que nospermitirán pasar de nuestro programa escrito en código fuente a nuestro archivo ejecutable.El lenguaje C es compilado, esto significa que un programa compilador lee el código fuentecompleto escrito por el programador, lo convierte en código objeto también conocido como códigobinario o código máquina. Una vez compilado, el linker enlazará las librerías dentro de su códigoobjeto y así obtendrá, finalmente el programa ejecutable . Veamos en detalle cada uno de estosconceptos.

2.1. Operaciones básicas de programación.

2.1.1. Creación del fichero fuente.

Los programas en C y C++ se escriben con la ayuda de un editor de textos (pico ó vi) del mismomodo que cualquier texto corriente.Los ficheros que contienen programas en C o C++ en forma de texto se conocen como ficherofuente , y el texto del programa que contiene se conoce como programa fuente .

El usuario siempre escribirá programas fuentes y los guardaremos en ficheros fuentes.Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para que sercomprendidos por los seres humanos, pero incomprensibles para los ordenadores.

2.1.2. Creación del fichero objeto.

Para obtener un programa ejecutable hay que seguir algunos pasos.El primer paso es compilar o traducir el programa fuente a su código objeto equivalente. Este es eltrabajo que hacen los compiladores de C y C++.Consiste en obtener un fichero equivalente a nuestro programa fuente comprensible para elordenador, este fichero se conoce como fichero objeto ,y su contenido como código objeto .Los compiladores son programas que leen un fichero de texto que contiene el programa fuente y

generan un fichero que contiene el código objeto. El código objeto no tiene ningún significado paralos seres humanos, al menos no directamente. Además es diferente para cada ordenador y paracada sistema operativo.Por lo tanto, existen diferentes compiladores para diferentes sistemas operativos y para cada tipode ordenador.Estas tareas las realizaremos, como mencionamos con anterioridad, con el IDE Anjuta, pero sepodrían realizar en modo de consola , utilizando un compilador por ejemplo g++.

2.1.3. Creación del fichero ejecutable.

2.1.3.1. Uso de librerías. Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados librerías .

Las librerías contienen código objeto de programas que permiten hacer cosas comunes como, porejemplo, leer desde el teclado, escribir en pantalla, manejar números, realizar funcionesmatemáticas, etc.Las librerías están clasificadas por el tipo de trabajos que hacen, hay librerías de entrada y salida,matemáticas, de manejo de memoria, de manejo de textos, etc.Hay un conjunto de librerías muy especiales, que se incluyen con todos los compiladores de C y deC++. Son las librerías ANSI o estándar. Pero también hay librerías no estándar, y dentro de éstashay librerías públicas y comerciales. En este curso sólo usaremos librerías ANSI.




- 5 -

2.1.3.2. Ficheros ejecutables y enlazadores.

Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso.El fichero objeto, a pesar de ser comprensible para el ordenador, no puede ser ejecutado.

Hay varias razones para eso:

1. Nuestros programas usaran, en general, funciones que estarán incluidas en librerías externas, yasean ANSI o no. Es necesario combinar nuestro fichero objeto con esas librerías para obtener unejecutable.

2. A menudo, nuestros programas estarán compuestos por varios ficheros fuente y, de cada uno deellos, se obtendrá un fichero objeto. Es necesario unir, todos los ficheros objeto más las librerías,en un único fichero ejecutable.

3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria el programa y losdatos y para que organice la memoria de modo que se disponga de una pila de tamaño adecuado.La pila es una zona de memoria que usa el programa para intercambiar datos con otros programaso con otras partes del propio programa. Veremos esto con más detalle durante el curso.

Existe un programa que hace todas estas cosas, se trata del "link ", o enlazador .El enlazador toma todos los ficheros objeto que componen nuestro programa, los combina con losficheros de librería que sea necesario y crea un fichero ejecutable .Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.

2.2. Manejo de Errores.Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores de programaciónpueden clasificarse en varios tipos, dependiendo de la fase en que se presenten.

Pueden ser:

Errores de sintaxis. Warnings o avisos.

Errores de enlazado.

Errores de ejecución.

Errores de diseño.

2.2.1. Errores de sintaxis.

Los errores de sintaxis son errores en el programa fuente. Pueden deberse a palabras reservadas,palabras mal escritas, expresiones erróneas o incompletas, variables no definidas, etc.

Los errores de sintaxis se detectan en la fase de compilación. El compilador, además de generar elcódigo objeto, nos dará una lista de errores de sintaxis. De hecho nos dará sólo una cosa o la otra,ya que si hay errores no es posible generar un código objeto.

2.2.2. Warnings o Avisos.

Además de errores, el compilador puede dar también Avisos o Warnings.Los avisos son errores, pero no lo suficientemente graves como para impedir la generación delcódigo objeto. No obstante, es importante corregir estos avisos, ya que el compilador tiene quedecidir entre varias opciones, y sus decisiones no tienen por qué coincidir con lo que el




- 6 -

programador pretende. Las decisiones se basan en las directivas que los creadores del compiladordecidieron durante su creación.

2.2.3. Errores de enlazado.

El programa enlazador también puede encontrar errores que normalmente se refieren a funcionesque no están definidas en ninguno de los ficheros objetos ni en las librerías. Puede que hayamosolvidado incluir alguna librería, algún fichero objeto o que hayamos olvidado definir alguna funcióno variable, o lo hayamos hecho mal.

2.2.4. Errores de ejecución.

Aunque se haya obtenido un fichero ejecutable, es posible que se produzcan errores.En el caso de los Errores de ejecución normalmente no obtendremos mensajes de error, sino quesimplemente el programa terminará bruscamente. Estos errores son más difíciles de detectar ycorregir.Existen programas auxiliares para buscar estos errores, son los llamados depuradores o debuggers .Estos programas permiten detener la ejecución de nuestros programas, inspeccionar variables yejecutar nuestro programa paso a paso. Esto resulta útil para detectar excepciones, errores sutiles,y fallos que se presentan dependiendo de circunstancias distintas.

2.2.5. Errores de diseño.

Finalmente los errores más difíciles de corregir y prevenir.Si nos hemos equivocado al diseñar nuestro algoritmo, no habrá ningún programa que puedaayudar al programador a corregir los errores de diseño. Contra estos errores sólo cabe practicar,pensar. Puede ayudar a solucionar este tipo de errores la opción depurar que generalmente poseenlos compiladores del lenguaje C.

TALLER DE INFORMÁTICA CAPITULO 3. Estructura de un programa

- 7 -

CAPITULO 3. ESTRUCTURA DE UN PROGRAMA.Los programas de computadoras varían sustancialmente en cuanto al propósito, estilo ycomplejidad. Pero la mayoría debe: ingresar y almacenar datos, procesar los datos para almacenarlos resultados deseados y mostrar, almacenar o imprimir los resultados obtenidos.Cada dato utilizado durante la ejecución del programa deberá ser descrito para que el compilador loreconozca, sepa cómo almacenarlo y recuperarlo; se deberá reservar memoria para que puedaalmacenar la cantidad de datos necesarios.Una vez almacenados los datos, éstos deberán procesarse. El proceso varía según el propósito delprograma.Finalmente, los datos procesados deberán ponerse a disposición del usuario. Cuando se utiliza ellenguaje C para escribir un programa se debe tener en cuenta que:

Todos los programas poseen una función main() que indica el punto donde se inicia laejecución. La ejecución finaliza cuando se encuentra el final de main .

Debe declarar todas las variables antes de usarlas.

Las partes más importantes de un programa en C son:

Directivas del pre-procesador: #include y #define. Declaración de variables globales.

Prototipos de funciones.

Declaración de clases.

Función main.

Definición de funciones.

Definición de clases.

3.1. Directivas del preprocesador.Las líneas que comienzan con el símbolo # son indicaciones para el compilador o directivas del preprocesador.

Sintaxis:#include <archivo.h>

La directiva include le indica al compilador que lea y compile el contenido del archivo con extensión.h que contiene las descripciones de las funciones de librería utilizadas a lo largo del programa.

Por ejemplo:#include <stdio.h>

Le indica al compilador que compile el contenido del archivo stdio.h.

Sintaxis:#define nombre valor

La directiva define determina un reemplazo o sustitución. La directiva le indica al compilador quecada vez que en el programa aparezca nombre sea reemplazado por valor. Esta sentencia resultaútil cuando son programas largos y nombre se utiliza varias veces ya que, si cambia el valor denombre se debe modificar una sola vez al principio del programa.



TALLER DE INFORMÁTICA CAPITULO 3. Estructura de un programa

- 8 -

Por ejemplo:#define NUMERO 5.3

Le indica al compilador que cada vez que aparezca NÚMERO en el programa sea sustituido por 5.3.

3.2. Declaración de variables globales.Las expresiones que permiten realizar cálculos dentro de los programas están formadas porvariables, constantes y operadores.Las variables se deben declarar antes de ser utilizadas en el programa, ya que el compilador debeconocer qué tipo de dato es una variable antes de poder compilar cualquier sentencia que la use.El lugar donde se declara una variable afecta mucho la manera en que otras partes del programapueden utilizarla.Las reglas que determinan cómo se puede usar una variable basada en el lugar en que fuedeclarada se llaman reglas de alcance del lenguaje .Si la variable se declara en ésta zona del programa, fuera de todas las funciones, incluyendo lafunción main(), se denomina variable global y se puede utilizar en cualquier parte del programa.

3.3. Prototipos de funciones. Antes de utilizar una función en el programa, ésta se debe definir.En esta porción del programa se definen las funciones a utilizar indicando el nombre de la función,el número y tipos de argumentos que utilizará durante la ejecución. Finaliza cada sentencia conpunto y coma (;).Esta definición se realiza mediante los prototipos de funciones.

3.4. Declaración de clases.Lugar dentro de los programas donde se deben crear las nuevas clases, se les debe asignar unnombre utilizando las sentencias struc, union o class de C++.

3.5. Función main().Todos los programas escritos en C poseen una función llamada main() . Es la función que seejecuta en primer lugar cuando comienza a funcionar el programa. El programa posee una solafunción main().En la siguiente línea aparece una llave { que indica el grupo de instrucciones que definen lo quesucederá cuando se ejecute el programa.Cada grupo de sentencias finaliza con una llave }.

3.6. Definición de funciones.Esta zona contiene el código para cada función declarada. El encabezamiento de la definición seráexactamente igual a la declaración, excepto que no finaliza con punto y coma (;).

3.7. Definición de clases.En esta parte del programa se deben definir los objetos o instancias de la clase declarada en lazona 3.4.



TALLER DE INFORMÁTICA CAPITULO 4. Datos, variables y constantes

- 9 -

CAPITULO 4. DATOS, VARIABLES Y CONSTANTES.

4.1 Datos.Como se había mencionado en el capítulo 3, “Cada dato utilizado durante la ejecución del programa

deberá ser descrito para que el compilador lo reconozca, sepa cómo almacenarlo y recuperarlo; sedeberá reservar memoria para que pueda almacenar la cantidad de datos necesarios.”

La declaración de cada ítem de datos consiste en indicar qué tipo de dato es y darle un nombre quelo identifique.En C hay tipos básicos de datos: carácter (character), entero (integer), punto flotante (floatingpoint) y puntero (point); aunque, en cada versión del lenguaje, pueden aparecer más o menostipos de datos.Por ejemplo, en C sólo existen cinco tipos fundamentales y los tipos enumerados, C++ añade unséptimo tipo, el bool , y el resto de los tipos son derivados de ellos.Los números son los datos fundamentales utilizados por los programas de computadoras. Elcontenido de la memoria consiste en números binarios almacenados en grupos de 8 bits (1 byte) o

16 bits (2 bytes o 1 word). Aún cuando un programa de computadora trabaje con letras o gráficos,básicamente está involucrando una serie de números almacenados en memoria.Los diferentes tipos de datos dependen, en realidad, de la cantidad de bytes que ocupen enmemoria.

Para obtener información más detallada acerca de los tipos de datos, la cantidad de memoriareservada remitirse al APENDICE Tipos de datos

Cuando se desea definir ítems de datos que almacenen palabras (dos o más caracteres) nos

encontramos ante el tipo de dato “string” o cadena de caracteres.

Por ejemplo:`hola´´Juan Pérez´

Este tipo de datos merece un desarrollo especial por ello se verá en el capítulo 9 que estudia eltema de arreglos.

4.2. Variables.El ítem de dato llamado variable , se refiere a un espacio de memoria cuyo contenido se modificaráde acuerdo a las circunstancias durante la ejecución del programa.

Cada variable utilizada en el programa deberá ser declarada antes de ser utilizada.La declaración de una variable le indica al lenguaje que se pretende utilizar una variable particular yqué tipo de dato almacenará. La declaración se forma por un tipo de dato seguido de uno o másnombres de variables.La inicialización de una variable significa asignarle al espacio de memoria reservado un valorparticular. Resulta conveniente realizarlo porque cuando se declara una variable, el espacio dememoria reservado, podrá contener cualquier valor.




- 10 -

4.2.1. Identificadores.

Un identificador es el nombre que permite identificar un espacio de memoria mediante un nombreválido para el lenguaje.El lenguaje C es flexible pero posee ciertas reglas que debemos respetar cuando definimosidentificadores para las variables que utilizaremos en el programa.

Reglas para dar nombre a las variables:

Sólo se pueden usar letras (mayúsculas o minúsculas), números y ciertos caracteres noalfanuméricos, como el '_', pero nunca un punto, coma, guión, comillas o símbolosmatemáticos o interrogaciones.

El primer carácter no puede ser un número.

C y C++ distinguen entre mayúsculas y minúsculas, de modo que los identificadoresnúmero y Número son diferentes.

Los primeros 32 dígitos son significativos, esto significa que

La_cantidad_total_de_dinero_en_mi_cuenta y La_cantidad_total_de_dinero_en_mi_bancoserán consideradas como la misma variable.

4.2.2. Declaración de variables.

Una característica del C es la necesidad de la declaración de las variables que se usarán en elprograma. Aunque esto resulta chocante para los que se aproximan al C desde otros lenguajes deprogramación, es en realidad una característica muy importante y útil de C, ya que ayuda aconseguir códigos más compactos y eficaces, y contribuye a facilitar la depuración, la detección ycorrección de errores.

Sintaxis:[tipo] [lista_de_identificadores];

Tipo debe ser un tipo de datos válido y lista_de_identificadores puede ser uno o más identificadoresseparados por coma (,). La declaración de variables puede considerarse como una sentencia.Desde este punto de vista, la declaración terminará con un ";".

Por ejemplo:int numero;float promedio, final;char letra;

También es posible inicializar las variables dentro de la misma declaración.

Por ejemplo:int a = 1234;bool seguir = true, encontrado;char letra = ‘k’;

Se declarara las variables "a", "seguir", "encontrado" y “letra”; y además se inicia los valores de"a" en 1234, “seguir” en "true" y “letra” con ‘k’.

- 11 -

En C, contrariamente a lo que sucede con otros lenguajes de programación, las variables noinicializadas tienen un valor indeterminado, contienen lo que normalmente se denomina "basura",también en esto hay excepciones como veremos más adelante.

4.2.2.1. Declaración de una variable de tipo entero (integer).

[signed |unsigned] [short | long | long long ] int <identificador o nombre>[signed |unsigned] long long [ int ] <identificador o nombre>[signed |unsigned] long [ int ] <identificador o nombre >[signed |unsigned] short [ int ] <identificador o nombre >

4.2.2.2. Declaración de una variable de tipo punto flotante (float).

float <identificador o nombre >

4.2.2.3. Declaración de una variable de tipo punto flotante dobleprecisión (double).

[long] double <identificador o nombre >

4.2.2.4. Declaración de una variable sin tipo (void).void <identificador o nombre >

Este es una variable especial que indica la ausencia de tipo. Se usa en funciones que no devuelvenningún valor, también en funciones que no requieren parámetros, aunque este uso sólo esobligatorio en C, y opcional en C++, también se usará en la declaración de punteros genéricos.

4.2.2.5. Declaración de una variable de tipo enumerado (enum).

enum [<identificador_de_enum>] { <nombre> [= <valor>], ...} [lista_de_variables];

Este tipo nos permite definir conjuntos de constantes, normalmente de tipo int, llamados datos de

tipo enumerado .Las variables declaradas de este tipo sólo podrán tomar valores entre los definidos.El identificador de tipo es opcional, y nos permitirá declarar más variables del tipo enumerado enotras partes del programa. La lista de variables también es opcional. Sin embargo, al menos uno delos dos componentes opcionales debe aparecer en la definición del tipo enumerado. Varios identificadores pueden tomar el mismo valor, pero cada identificador sólo puede usarse enun tipo enumerado.

Por ejemplo:enum tipo_horas {una=1, dos, tres, cuatro, cinco, seis, siete, ocho, nueve, diez, once,doce, trece=1, catorce, quince, dieciseis, diecisiete, dieciocho, diecinueve, veinte,veintiuna, veintidós, veintitrés, veinticuatro =0};

En este caso, una y trece valen 1, dos y catorce valen 2, etc. Y veinticuatro vale 0. Como se ve enel ejemplo, una vez se asigna un valor a un elemento de la lista, los siguientes toman valorescorrelativos. Si no se asigna ningún valor, el primer elemento tomará el valor 0.

- 12 -

4.2.2.6. Declaración de una variable de tipo boleana (boolean).

bool <identificador o nombre>

Las variables de este tipo sólo pueden tomar dos valores "true" o "false". Sirven para evaluarexpresiones lógicas.

Este tipo de variables se puede usar para almacenar respuestas, por ejemplo: ¿Posees carnet deconducir? O para almacenar informaciones que sólo pueden tomar dos valores, por ejemplo: ¿quémano usas para escribir?En estos casos debemos acuñar una regla, en este ejemplo, podría ser:diestro->"true", zurdo->"false".

4.2.3. Inicialización de variablesEn C se pueden asignar valores a la mayoría de las variables a la vez que se las declara.La inicialización de una variable se realiza poniendo un signo igual y una constante después delidentificador.

Sintaxis:[tipo] [identificador = constante];

Por ejemplo:char a = ‘p’; int num = 0;

4.2.4. Ejercicios sobre Variables1)¿Cuáles de los siguientes son tipos válidos de variables? Marcar la opción correcta.

a) unsigned charSí No

b) long charSí No

c) unsigned floatSí No

d) double charSí No

e) signed longSí No

f) unsigned short

Sí Nog) signed long int

Sí No

h) long doubleSí No

- 13 -

i) enum dia {lunes, martes, miercoles, jueves, viernes, sabado, domingo};Sí No

j) enum color {verde, naranja, rojo}; enum fruta {manzana, fresa, naranja, platano};Sí No

k) long boolSí No

4.3. Constantes.Las constantes son muy similares a las variables, con la diferencia que éstas solo pueden tomar unvalor en el momento de la declaración, luego cualquier intento de modificación será tomado comoun error por parte del compilador.Las constantes se declaran del mismo modo que las variables, solamente se debe anteponer lasentencia “const ” antes del tipo de dato.

Por ejemplo:const int mayor = 25;

4.3.1. Normas para la notación. Veremos las reglas que rigen la escritura de las constantes en C según diversos sistemas denumeración y que uso tiene cada uno.¿Por qué es necesaria la notación?En todos los casos, especificar el tipo de la constante tiene como objetivo evitar que se realicenconversiones de tipo durante la ejecución del programa, obligando al compilador a hacerlas durantela fase de compilación.

Por ejemplo:float x = 0.0;if(x <= 1.0f) x += 0.01f;

Si en el ejemplo hubiéramos escrito "if(x <= 1)...", el compilador almacenaría el 1 como un entero,y durante la fase de ejecución se convertirá ese entero a float para poder compararlo con x, que esfloat. Al poner "1.0" estamos diciendo al compilador que almacene esa constante como un valor encoma flotante.Lo mismo se aplica a las constantes long , unsigned y char .

4.3.1.1. Constantes "int".

En C se usan tres tipos de numeración para la definición de constantes numéricas, el decimal, eloctal y el hexadecimal, según se use la numeración en base 10, 8 ó 16, respectivamente.

Por ejemplo:El número 127, se representará en:notación decimal como 127octal como 0177hexadecimal como 0x7f.

En notación octal se usan sólo los dígitos del '0' al '7'.En la notación hexadecimal se usan 16 símbolos, los dígitos del '0' al '9' tienen el mismo valor queen decimal, para los otros seis símbolos se usan las letras de la 'A' a la 'F', indistintamente en

- 14 -

mayúsculas o minúsculas. Sus valores son 10 para la 'A', 11 para la 'B', y sucesivamente, hasta 15para la 'F'.Según el ejemplo el número 0x7f, donde "0x" es el prefijo que indica que se trata de un número ennotación hexadecimal, sería el número 7F, es decir,7F=7*16+15=127. Del mismo modo que el número 127 en notación decimal sería,1*10²+2*10+7=127.

En octal se usa como prefijo el dígito 0. El número 0177 equivale a 0177=1*8²+7*8+7=127.

Hay que tener mucho cuidado con las constantes numéricas, en C y C++ no es el mismo número el0123 que el 123, aunque pueda parecer otra cosa. El primero es un número octal y el segundodecimal.

La ventaja de la numeración hexadecimal es que los valores enteros requieren dos dígitos por cadabyte para su representación. Así un byte puede tomar valores hexadecimales entre 0x00 y 0xff, dosbytes entre 0x0000 y 0xffff, etc. Además, la conversión a binario es casi directa, cada dígitohexadecimal se puede sustituir por cuatro bits, el '0x0' por '0000', el '0x1' por '0001', hasta el '0xf',que equivale a '1111'. En el ejemplo el número 127, o 0x7f, sería en binario '01111111'.Con la numeración octal es análogo, salvo que cada dígito agrupa tres bits. Así un byte se puede tomar valores octales entre 0000 y 0377, dos bytes entre 0000000 y0177777, etc. Además, la conversión a binario es casi directa, cada dígito octal se puede sustituirpor tres bits, el '0' por '000', el '1' por '001', hasta el '7', que equivale a '111'. En el ejemplo elnúmero 127, o 0177, sería en binario '01111111'.

De este modo, cuando trabajemos con operaciones de bits, nos resultará mucho más sencilloescribir valores constantes usando la notación hexadecimal u octal.Por ejemplo, resulta más fácil predecir el resultado de la siguiente operación:

A = 0xaa & 0x55;

Que: A = 170 & 85;

En ambos casos el resultado es 0, pero en el primero resulta más evidente, ya que 0xAA es enbinario 10101010 y 0x55 es 01010101, y la operación "AND" entre ambos números es 00000000,es decir 0. Ahora se propone al alumno intentarlo con los números 170 y 85.-

4.3.1.2. Constantes "long".

Para trabajar con valores constantes "long" debemos usar el sufijo "L". Esto resulta conveniente,sobre todo, al utilizar las constantes en expresiones condicionales y, por coherencia, también enexpresiones de asignación.

Por ejemplo:long x = 123L;if(x == 0L) cout << "Valor nulo" << endl;

Puede suceder que el compilador nos señale un error cuando usemos constantes long sin añadir elsufijo L.

- 15 -

Por ejemplo:if(x == 1343890883) cout << "Número long int" << endl;

Esta sentencia hará que el compilador emita un error ya que no puede usar un tamaño mayor sinuna indicación explícita.Hay casos en los que los tipos "long" e "int" tienen el mismo tamaño, en ese caso no se producirá

error, pero no podemos predecir que nuestro programa se compilará en un tipo concreto decompilador o plataforma.

4.3.1.3. Constantes "long long".

Para trabajar con valores constantes "long long" debemos usar el sufijo "LL", sobre todo cuandoesas constantes aparecen en expresiones condicionales o de asignación.

Por ejemplo:long long x = 16575476522787LL;if(x == 1LL) cout << "Valor nulo" << endl;

Como cuando se utilizan constantes long, a menudo recibiremos errores del compilador cuando

usemos constantes long long sin añadir el sufijo LL.Por ejemplo:

if(x == 16575476522787) cout << "Número long long" << endl;Esta sentencia hará que el compilador emita un error ya que no puede usar un tamaño mayor sinuna indicación explícita.

4.3.1.4. Constantes "unsigned".

Del mismo modo, cuando trabajamos con valores constantes "unsigned" debemos usar el sufijo "U"para las mismas situaciones que hemos indicado para las constantes "long".

Por ejemplo:

unsigned int x = 123U;if(x == 3124232U) cout << "Valor encontrado" << endl;

4.3.1.5. Constantes "unsigned long".

En una constante, es posible utilizar los modificadores "unsigned" y "long", en ese caso debemosusar el sufijo "UL" para las mismas situaciones que hemos indicado para las constantes "long" y"unsigned".

Por ejemplo:unsigned long x = 123456UL;if(x == 3124232UL) cout << "Valor encontrado" << endl;

4.3.1.6. Constantes "unsigned long long". También es posible combinar, en una constante, los modificadores "unsigned" y "long long ", en esecaso debemos usar el sufijo "ULL", para las mismas situaciones que hemos indicado para lasconstantes "long long" y "unsigned".

Por ejemplo:unsigned long long x = 123456534543ULL;if(x == 3124232ULL) cout << "Valor encontrado" << endl;

- 16 -

4.3.1.7. Constantes "float".

También existe una notación especial para las constantes en punto flotante.En este caso consiste en añadir ".0" a aquellas constantes que puedan interpretarse como enteras.Si se usa el sufijo "f" se tratará de constantes en precisión sencilla, es decir "float ".

Por ejemplo:float x = 0.0;if(x <= 1.0f) x += 0.01f;

4.3.1.8. Constantes "double".

Si no se usa el sufijo “f”, se tratará de constantes de precisión doble, es decir tipo "double" .

Por ejemplo:double x = 0.0;if(x <= 1.0) x += 0.01;

4.3.1.9. Constantes "long double".

Si se usa el sufijo "l" se tratará de constantes en precisión máxima, es decir "long double".

Por ejemplo:long double x = 0.0L;if(x <= 1.0L) x += 0.01L;

4.3.1.10. Constantes "char".

Las constantes de tipo "char" se representan entre comillas sencillas, por ejemplo 'a', '8', 'F'.

4.3.2. Recomendaciones en el uso de la notación.4.3.2.1. Constantes enteras.

En general podemos combinar los prefijos "0" y "0x" con los sufijos "L", "U", y "UL". Aunque esindiferente usar los sufijos en mayúsculas o minúsculas, es preferible usar mayúsculas, sobre todocon la "L", ya que la 'l' minúscula puede confundirse con un uno '1'.

4.3.2.2. Constantes punto flotante.

Se recomienda añadir el .0, cuando la constante se pueda confundir con un entero.

Usar la notación exponencial

También podemos usar notación exponencial, donde el formato exponencial consiste en unnúmero, llamado mantisa, que puede ser entero o con decimales, seguido de una letra 'e' o 'E' ypor último, otro número (entero) que es el exponente de una potencia de base 10.

Por ejemplo:double x = 10e4;double y = 4.12e2;double pi = 3.141592e0;




- 17 -

Los valores anteriores se representarían: x = 10 x 104 = 100000y = 4,12 x 102 = 412

pi = 3.141592 x 100 = 3.141592

Al igual que con los enteros, es indiferente usar los sufijos en mayúsculas o minúsculas, pero es

preferible usar mayúsculas, sobre todo con la "L", ya que la 'l' minúscula puede confundirse con ununo '1'.

4.3.3 Constantes carácter. Comentario adicional.Si has pensado que una constante char se representa con 'k', tal vez, después de un rato tepreguntes ¿cómo se representa la constante que consiste en una comilla sencilla?Existen ciertos caracteres, entre los que se encuentra la comilla sencilla, que no pueden serrepresentados con la norma general. Para eludir este problema existe cierto mecanismo, llamadosecuencias de escape . En el caso comentado, la comilla sencilla se define como '\', y la barradescendente se define como '\\'. Además de estos caracteres especiales existen otros.

4.3.3.1. Código ASCII.El código ASCII es el conjunto de caracteres que puede ser representado por el tipo "char", constade 128 o 256 caracteres.El código ASCII de 128 caracteres utiliza 7 bits, actualmente ha quedado prácticamente obsoleto yaque no admite caracteres como la 'ñ' o la 'á' pero, aún se usa en ciertos equipos antiguos donde eloctavo bit se usa como bit de paridad en las transmisiones serie.El código ASCII de 256 caracteres utiliza los 8 bits y, si recordamos, el tipo "char" tiene siempre unbyte (8 bits) y esto no es por casualidad.En este conjunto existen, además de los caracteres alfabéticos, en mayúsculas y minúsculas, losnuméricos, los signos de puntuación y los caracteres internacionales, ciertos caracteres noimprimibles, como el retorno de línea, el avance de línea, etc. Veremos estos caracteres y cómo se representan como secuencia de escape, en hexadecimal, el

nombre ANSI y el resultado o significado.

- 18 -

Los tres últimos son realmente comodines para la representación de cualquier carácter.El \nnn sirve para la representación en notación octal. Para la notación octal se usan tres dígitos.Hay que tener en cuenta que, análogamente a lo que sucede en la notación hexadecimal, en octalse agrupan los bits de tres en tres. Por lo tanto, para representar un carácter ASCII de 8 bits, senecesitarán tres dígitos. En octal sólo son válidos los símbolos del '0' al '7'.Según el ejemplo anterior, para representar el carácter 127 en octal usaremos la cadena '\177', y

en hexadecimal '\x7f'. También pueden asignarse números decimales a variables de tipo char.Por ejemplo:

char A; A = 'a'; A = 97; A = 0x61; A = '\x61'; A = '\141';

En este ejemplo todas las asignaciones son equivalentes y válidas.

#include <iostream>

using namespace std;int main(){char opc0='A'; //Ascii de A expresado como Caracterchar opc1=65 ; //Ascii de A expresado en Decimalchar opc2= 0101; //Ascii de A expresado en Octalchar opc3 = 0x41; //Ascii de A expresado en Hexadecimalcout << opc0 <<endl;cout << opc1 <<endl;cout << opc2 <<endl;cout << opc3 <<endl;return 0; }

La salida de este programa muestra por pantalla 4 veces la A.

4.3.3.2. Carácter nulo.

El carácter nulo se usa en C para indicar la terminación de las cadenas de caracteres, por lo tantoes muy útil y de uso frecuente.Para hacer referencia a él se usa frecuentemente su valor decimal, es decir char A = 0, aunque esmuy probable que lo encuentres en libros o en programas como '\000', es decir en notación octal.

4.3.3.3. Carácter EOF.

EOF viene del inglés "End Of File", este carácter se usa en muchos ficheros como marcador de finde fichero, sobre todo en ficheros de texto. Aunque dependiendo del sistema operativo este

carácter puede cambiar, por ejemplo en MS-DOS es el carácter "0x1A", el compilador siempre lotraduce y devuelve el carácter EOF cuando un fichero se termina.




- 19 -

4.3.4. Ejercicios1) si debe almacenar el dato, ¿qué tipo de constante debería utilizar en cada caso? Marcar la opcióncorrecta.

a) '\x37'

1. char2. long3. int4. float

b) 123UL1. unsigned2. int3. long4. unsigned long

c) 34.01. int2. double3. float4. long

d) 6L1. int2. long3. double4. char

e) 671. char

2. unsigned3. int4. float

f) 0x1391. char2. unsigned3. int4. float

g) 0x134763df23LL

1. long

2. unsigned3. int4. long long

Para la creación de identificadores en la escritura del código fuente se recomienda ver APENDICEESTILOS DE NOTACIÓN.

TALLER DE INFORMÁTICA CAPITULO 5. Operadores

- 20 -

CAPITULO 5. OPERADORES.

Los operadores son elementos que disparan ciertos cálculos cuando son aplicados a variables o aotros objetos en una expresión.Un operador es un símbolo que le dice al compilador que realice manipulaciones matemáticas o

lógicas específicas.El lenguaje C tiene las siguientes clases de operadores: aritméticos, relacionales, lógicos y sobrebits.Hay varios tipos de operadores, clasificados según el tipo de objetos sobre los que actúan.

Los tipos de operadores que veremos son:

Operadores Aritméticos.

Operadores Relacionales.

Operadores Lógicos.

Operadores de Asignación.

Operador sizeof.

Operador condicional.

Operador coma.

5.1. Operadores aritméticos.Los operadores aritméticos se utilizan para crear expresiones matemáticas.

5.1.1. Operadores aritméticos unitarios.Los operadores aritméticos unitarios que utiliza el C son: '+', '-','++', '--'

Sintaxis:+ <expresión>- <expresión><variable> ++ /* post-incremento */++ <variable> /* pre-incremento */<variable>-- /* post-decremento */-- <variable> /* pre-decremento */

5.1.1.1. Operadores '+' y '-‘ .

Los operadores aritméticos unitarios '+' y '-' asignan valores positivos o negativos a la expresión ala que se aplican.

5.1.1.2. Operadores '++' y '--'.

Los otros dos operadores unitarios '++' y '--' son un tanto especiales, ya que sólo pueden trabajarsobre variables, pues implican una asignación.El primero ('++') incrementa el valor del operando y el segundo ('--') lo decrementa, ambos en unaunidad.

- 21 -

Existen dos modalidades, dependiendo de que se use el operador en la forma de prefijo o de sufijo.En su forma de prefijo, el operador es aplicado antes de que se evalúe el resto de la expresión; enla forma de sufijo, se aplica después de que se evalúe el resto de la expresión.

Por ejemplo:en las siguientes expresiones "a" vale 100 y "b" vale 10:

c = a + ++b;

En este primer ejemplo primero se aplica el pre-incremento, y b valdrá 11 a continuación se evalúala expresión "a+b", que dará como resultado 111, y por último se asignará este valor a c, quevaldrá 111.

Por ejemplo:c = a + b++;

En este segundo ejemplo primero se avalúa la expresión "a+b", que dará como resultado 110, y seasignará este valor a c, que valdrá 110.Finalmente se aplica en post-incremento, y b valdrá 11.Los operadores unitarios sufijos (post-incremento y post-decremento) se evalúan después de que

se han evaluado el resto de las expresiones.En el primer ejemplo primero se evalúa ++b, después a+b y finalmente c=<resultado>.En el segundo ejemplo, primero se evalúa a+b, después c = <resultado> y finalmente b++.

Es muy importante no pensar o resolver las expresiones C como ecuaciones matemáticas, NO SONEXPRESIONES MATEMATICAS.No veas estas expresiones como ecuaciones, NO SON ECUACIONES.

5.1.2. Operadores aritméticos binarios.

Los operadores binarios que utiliza el lenguaje C son: ' +', ' - ', ' * ' , ' / ', ‘ % '

Sintaxis:<expresión> + <expresión> /*Sintaxis de operador suma */<expresión> - <expresión> /* Sintaxis de operador resta */<expresión> * <expresión> /* Sintaxis de operador multiplicación */<expresión> / <expresión> /* Sintaxis de operador división */<expresión> % <expresión> /* Sintaxis de operador resto */

Evidentemente se trata de las conocidas operaciones aritméticas de suma, resta, multiplicación ydivisión y los operadores se comportan como en cualquier lenguaje de computadoras.Debemos tener en cuenta, por ejemplo, que el operador división ( / ) aplicado a un entero truncará(perderá) cualquier resto.

Por ejemplo:10 / 3 será igual a 3 para la división entera.

El operador módulo '%' , devuelve el resto de la división entera del primer operando entre elsegundo. Por esta razón no puede ser aplicado a operando en coma flotante (ya que al sernúmeros de punto flotante no hay resto!!).

- 22 -

5.2. Operadores relacionales.Los operadores relacionales permiten determinar las relaciones que un valor o cantidad puedetener con otro. Aquí resulta clave la idea de verdadero o falso. En C cualquier valor distinto de cero es verdadero, ycero (0) es falso. Así, las expresiones que utilizan operadores relacionales devolverán como

resultado 0 si es falsa y 1 si es verdadera la expresión. A continuación mostramos los operadores relacionales y su sintaxis:

En las expresiones, "E1 <operador_relacional> E2, los operandos (E1, E2) tienen algunasrestricciones, pero de momento nos conformaremos con que sean de tipo aritmético. El resto de lasrestricciones las veremos cuando conozcamos los punteros y los objetos.

Es un error frecuente utilizar el “=” en lugar del “==”, observar que el “=” es para ASIGNAR; y el “==” es para COMPROBAR LA IGUALDAD.

5.3. Operadores lógicos.Los operadores lógicos conforman expresiones lógicas y se utilizan para determinar cómo sepresentan las relaciones entre las expresiones involucradas.

La siguiente tabla presenta los operadores lógicos y su sintaxis:

5.3.1. Operador && o AND.

El operador "&& " equivale al " AND" o " Y "; devuelve "true" sólo si las dos expresiones evaluadasson "true" o distintas de cero, en caso contrario devuelve "false" o cero. Si la primera expresiónevaluada es "false", la segunda no se evalúa.Generalizando, con expresiones AND con más de dos expresiones, la primera expresión falsainterrumpe el proceso e impide que se continúe la evaluación del resto de las expresiones. Esto eslo que se conoce como "cortocircuito", y es muy importante, como veremos posteriormente.El operador && se usa según la siguiente tabla de verdad, donde se representa “true” con 1 y “false” con 0.




- 23 -

5.3.2. Operador || u OR.

El operador "||" equivale al "OR " u "O inclusivo"; devuelve "true" si cualquiera de lasexpresiones evaluadas es "true" o distinta de cero, en caso contrario devuelve "false" o cero. Si laprimera expresión evaluada es "true", la segunda no se evalúa.El operador || se usa según la siguiente tabla de verdad, donde se representa l

5.3.3. Operador ! o NOT.

El operador "!" es equivalente al "NOT", o "NO", y devuelve "true" sólo si la expresión evaluada es"false" o cero; en caso contrario devuelve "false".La expresión "!E" es equivalente a (0 == E).El operador ! se usa según la siguiente tabla de verdad, donde se representa “true” con 0 y “false”con 1.

5.4. Operadores de asignación.La asignación consiste en un nombre de variable, seguido de un signo igual y el valor a serasignado.Por ejemplo: a = 14;

El operador asigna el valor de la izquierda (14) a la variable (a) que está a la derecha del operadorasignación (=).

Existen varios operadores de asignación, el más evidente y el más usado es el "=", pero no es elúnico.Los operadores de asignación y sus diferentes usos se describen a continuación:

- 24 -

5.5. Operador "sizeof".El operador “sizeof” es un operador del tiempo de compilación.Este operador tiene dos usos diferentes. Devuelve el tamaño de la variable o tipo que está comooperando. Si el operador funciona sobre un tipo de dato, éste deberá ir entre paréntesis.

Sintaxis:sizeof <expresión>sizeof (nombre_de_tipo)

En ambos casos, el resultado es una constante entera que da el tamaño en bytes del espacio dememoria usada por el operando, que es determinado por su tipo.El espacio reservado por cada tipo depende de la plataforma.En el primer caso, el tipo del operando es determinado sin evaluar la expresión, y por lo tanto sinefectos secundarios.

Por ejemplo:si el operando es de tipo "char", el resultado es 1.

A pesar de su apariencia, sizeof() NO es una función, sino un OPERADOR.

5.6. Operador condicional (?).

El operador "?:", se trata de un operador ternario (es decir tiene TRES operandos)

Sintaxis:<expresión lógica> ? <expresión> : <expresión>

En la expresión E1? E2:E3, primero se evalúa la expresión E1, si el valor es verdadero ("true"), seevaluará la expresión E2 y E3 será ignorada, si es falso ("false"), se evaluará E3 y E2 será ignorada.

Hay ciertas limitaciones en cuanto al tipo de los argumentos:E1 debe ser una expresión lógica.E2 y E3 deben ser de tipo aritmético.E2 y E3 deben ser de estructuras o uniones compatibles.E2 y E3 deben ser de tipo "void".

Por ejemplo:max = (a >=b) ? a : b;

A la variable max se le asigna el mayor valor.#define max (a,b) (((a) > (b)) ? (a) : (b))

De este ejemplo sólo nos interesa la parte de la derecha. La interpretación es: si "a" es mayor que"b", se debe evaluar "a", en caso contrario evaluar "b", en resumen, evalúa siempre el máximo!!




- 25 -

5.7. Operador coma (,).El operador coma se utiliza para encadenar diversas expresiones. Provoca una secuencia deoperaciones a realizar, se puede pensar como “hacer esto y luego esto”.Tiene una doble función: separa elementos de una lista de argumentos de una función. puede serusado como separador en expresiones "de coma".

Ambas funciones pueden ser mezcladas, pero hay que añadir paréntesis para resolver lasambigüedades y provocar errores, ya que el operador coma tiene precedencia más baja, porejemplo, que el operador de asignación.

Sintaxis:E1, E2, ... , En

En una expresión "de coma", cada operando es evaluado como una expresión, pero los resultadosobtenidos se tienen en cuenta en la próxima evaluación.

Por ejemplo: x = (y=3,y+1);

En primer lugar asigna el valor 3 a la variable y, y después asigna el valor 4 a la variable x.



TALLER DE INFORMÁTICA CAPITULO 6. Expresiones

- 26 -

CAPITULO 6. EXPRESIONES.

La combinación de variables, constantes definidas o números con uno o más operadores dan comoresultado un valor. Esta combinación recibe el nombre de expresión.Una expresión es , según el diccionario, un "conjunto de términos que representan una cantidad",

entre nosotros es cualquier conjunto de operadores y varios operando, que dan como resultadouna cantidad.Operando es cada una de las cantidades, constantes, variables o expresiones que intervienen enuna expresión.Existe una división, en los operadores, atendiendo al número de operando que afectan. Según estaclasificación pueden ser unitarios, binarios o ternarios, los primeros afectan a un solo operando, lossegundos a dos y los ternarios como era de esperar a tres.Las variables y constantes se pueden procesar utilizando operaciones y funciones adecuadas a sustipos.Cada expresión toma un valor que se determina tomando los valores de las variables y constantesimplicadas y la ejecución de las operaciones indicadas.Las expresiones se pueden clasificar, según los tipos de objetos que manipulan, en:

Aritméticas: cuyo resultado sería de tipo numérico. Lógicas: cuyo resultado sería de tipo lógico.

Carácter: cuyo resultado sería de tipo carácter.

6.1. Expresiones aritméticas.Una expresión aritmética es un conjunto de variables y/o constantes unidas o relacionadas porparéntesis y operadores aritméticos.Son análogas a las fórmulas matemáticas. Las variables y constantes son numéricas (enteras opunto flotante) y las operaciones son aritméticas.

Por ejemplo:sueldo = sueldo_base + 0.15 * monto_ventase = a*b*b / 3 + (a*a + b) / (b + c)

Cuando se utilizan expresiones aritméticas se debe tener en cuenta que:

Si en una operación ambos operando son enteros, entonces el resultado de la operación esun entero.

Si en una operación uno o ambos operando son reales, entonces el resultado de laoperación es un real.

El operador “/” produce un cociente entero si los dos operando son enteros. Esto significa

que se pierde la parte decimal si la división no es exacta. Esta es una consecuencia de lanota 1.

El operador “/” produce un cociente float si uno o los dos operando son float. Esta es unaconsecuencia de la nota 2.

Por ejemplo:7 / 2 es igual a 3 y no 3.5 como lo es matemáticamente. Esto debido a que 7 y 2 sonenteros y al dividir dos enteros se pierde la parte fraccionaria, no se redondea.




- 27 -

En cambio:7.0 / 2 es igual a 3.5 ya que si uno o los dos operando son reales, entonces el resultadoes real. En este caso 7.0 es real.

6.1.1. Reglas de Precedencia.

Las expresiones que tienen dos o más operando requieren reglas matemáticas que permitandeterminar el orden de las operaciones.Las Reglas de Prioridad o Precedencia son las reglas matemáticas que permiten determinar el ordende las operaciones.

Son:

Las operaciones que están encerradas entre paréntesis se evalúan primero. Si aparecenvarios paréntesis anidados, se evalúan primero los paréntesis interiores.

En caso de coincidir varios operadores de igual prioridad, el orden se determina deizquierda a derecha.

Las operaciones aritméticas dentro de una expresión suelen seguir el siguiente orden deprioridad:

Para más detalle sobre operadores y reglas de precedencia ver APENDICE. Precedencia de Operadores.

6.2. Expresiones lógicas.Una expresión lógica o booleana es un conjunto de variables y/o constantes unidas medianteoperadores lógicos y operadores relacionales.Las expresiones lógicas se forman combinando constantes lógicas, variables lógicas y otras

expresiones lógicas, utilizando operadores lógicos y relacionales; y su valor siempre es verdadero ofalso.Una expresión lógica solo puede tomar uno de dos valores: verdadero o falso.Las expresiones lógicas son ampliamente utilizadas en las estructuras selectivas y las estructurasrepetitivas.

- 28 -

6.2.1. Expresiones comparativas.

El formato general para las comparaciones es:

<Expresión1> operador de relación <Expresión2>

y el resultado será verdadero o falso.

Por Ejemplo:Si A = 4 y B = 3

A > B da como resultado Verdadero(A – 2) < (B – 4) da como resultado Falso.

Los operadores de relación se pueden aplicar a los tipos de datos estándar: entero, punto flotante,carácter ó lógico.

6.2.1.1. Aplicación en datos tipo carácter.

La aplicación en valores numéricos es evidente; pero cuando deba comparar datos de tipo carácter,se requiere de una secuencia de ordenación de los caracteres, similar al orden creciente odecreciente.La ordenación suele ser alfabética y se recurre al código normalizado ASCII, donde:

‘0’ < ‘1’ < ‘2’ < ‘3’ .... ‘A’ < ‘B’ < ‘C’ .... ‘a’ < ‘b’ < ‘c’ ....

6.2.1.2. Aplicación en datos tipo lógico.

Cuando se utilizan los operadores de relación con valores lógicos, Falso < Verdadero.

Por ejemplo:Si tenemos la expresión Falso < Verdadero, dará como resultadoVerdadero

6.2.1.3. Aplicación en datos tipo punto flotante.

Cuando se utilizan los operadores = ó <> en valores punto flotante, es importante recordar queestos valores no se pueden almacenar exactamente, debido a la precisión aritmética limitada de lascomputadoras.

Así, lo aconsejable es excluir a los valores punto flotante en este tipo de comparaciones.

6.2.2. Expresiones lógicas.

En las expresiones lógicas se pueden mezclar operadores de relación y lógicos.

Por Ejemplo:(1 < 5) and (5 < 10) da como resultado Verdadero.(5 < 10) or (‘A’ < ‘B’) da como resultado Verdadero.




- 29 -

Para más detalle sobre operadores y reglas de precedencia ver APENDICE. Precedencia deOperadores.

Al igual que en las expresiones aritméticas, los paréntesis se podrán utilizar y tendrán prioridadsobre cualquier operación.

Por Ejemplo:not 4 > 6 da como resultado ERROR, ya que el operador NOT no se aplica sobreel 4.not(4 > 6) da como resultado Verdadero

6.3. Ejercicios con operadores y expresiones1) Suponiendo los siguientes valores iniciales para las variables: x = 2; y = 6; z = 9; r = 100;s = 10; a = 15; b = 3; ¿Cuáles son los valores correctos en cada expresión? Marcar la opción

correcta.a) x += 10;

• 12• 10• 11

b) s *= b;• 9• 13• 30

c) r /= 0;• infinito• 1• error

d) y += x + 10;• 8• 12• 18

e) z -= a*b;• -36• -18•

362) Usar expresiones equivalentes para las siguientes, usando operadores mixtos.

a) x = 10 + x - y;• x += 10-y• x -= y+10• x += 10+y

- 30 -

b) r = 100*r;• r *= 100*r• r *= 100• r += 100

c) y = y/(10+x);•

y /= 10*x• y /= 10 + y/x• y /= 10+x

d) z = 3 * x + 6;• z += 6• z *= 3• no es posible

3) Evaluar las siguientes expresiones. Siendo:x = 10; y = 20; z = 30;

a) z = x - y, t = z - y;• z=-10, t=-30• t=10• z=30, t=-30

b) (x < 10) && (y > 15)• true• false

c) (x <= z) || (z <= y)• true• false

d) !(x+y < z)• true• false

e) (x+y != z) && (1/(z-x-y) != 1)• true• false• error



TALLER DE INFORMÁTICA CAPITULO 7. Instrucciones

- 31 -

CAPITULO 7. INSTRUCCIONES

El elemento que nos está faltando para poder comenzar a escribir nuestros propios programas sonlas sentencias o instrucciones.Un programa contiene las acciones o instrucciones que resolverán el problema. Las instrucciones

describen la secuencia de pasos con el que se quiere solucionar el problema planteado.Existen instrucciones de diversos tipos que nos permitirán enfrentarnos a todas las situacionesposibles en programación.

Los tipos de sentencias son:

Bloques

Expresiones• Llamadas a función• Asignación• Nula

Bucles• while• do while• for

Etiquetas• Etiquetas de identificación• case• default

Selección• if...else•

switchSaltos

• break• continue• goto• return

Veamos cada una de ellas.

7.1. Bloques.Una sentencia compuesta o un bloque es un conjunto de sentencias, que puede estar vacía,

encerrada entre llaves " {} ".Sintácticamente, un bloque se considera como una única sentencia.También se usa en variables compuestas, como veremos en el capítulo de variables II, y en ladefinición de cuerpo de funciones.Los bloques pueden estar anidados hasta cualquier profundidad.

- 32 -

7.2. Expresiones.Una expresión seguida de un punto y coma (;), forma una sentencia de expresión .La forma en que el compilador ejecuta una sentencia de este tipo es evaluando la expresión.Cualquier efecto derivado de esta evaluación se completará antes de ejecutar la siguientesentencia.

Sintaxis:<expresión>;

7.2.1. Llamadas a función.

La sentencia de llamada a función es la manera de ejecutar las funciones que se definen en otraspartes del programa o en el exterior de éste, ya sea una librería estándar o particular.La llamada a función se forma con el nombre de la función, una lista de parámetros entreparéntesis y un ";".

7.2.2. Asignación.

Una instrucción de asignación consiste en dar a una variable el valor de una expresión, el valor deotra variable o el valor de una constante.La sentencia de asignación se utiliza para almacenar valores a variables o constantes.Es una operación que sitúa un valor determinado en una posición de memoria.

Sintaxis:<variable> <operador de asignación> <expresión>;

La expresión de la derecha es evaluada y el valor obtenido es asignado a la variable o constante dela izquierda. El tipo de asignación dependerá del operador utilizado, estos operadores ya los vimosen el capítulo anterior.En la parte izquierda de la asignación se pone el nombre de la variable que se quiere modificar. Laparte derecha contiene una expresión que le dará el nuevo valor a la variable, y por lo tanto debe

tener el mismo tipo que la variable.

7.2.3. Nula.

La sentencia nula consiste en un único ";". Sirve para usarla en los casos en los que el compiladorespera que aparezca una sentencia, pero en realidad no pretendemos hacer nada. Veremosejemplos de esto cuando lleguemos a los bucles.

7.3. Bucles.Un bucle es la estructura de control que permite la repetición de una serie determinada desentencias. Es importante tener en cuenta cuántas veces se repite el bucle y cuál es el cuerpo delbucle.

El cuerpo del bucle lo constituyen la serie de sentencias que pueden ser de cualquier tipo(secuencial, de decisión o repetitivo) las cuales serán repetidas n veces, pudiendo ser n conocido odesconocido. Cuando n es desconocido, el número de veces que debe repetirse el cuerpo del bucleestará condicionado por una expresión lógica.Un bucle no es más que una serie de instrucciones que se repiten.

- 33 -

A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado y pensar cuando debeacabar ya que si no tuviéramos en cuenta esto podríamos entrar en un bucle sin fin, iríamos

repitiendo las mismas líneas teniendo que abortar la aplicación, para poder finalizar la ejecución delprograma.Por esto, es de suma importancia que pensemos, antes de hacer nada, en qué momento, cómo,dónde y por qué debe acabar el bucle.

7.3.1. Bucle "while".

Es la sentencia de bucle más sencilla, y sin embargo es tremendamente potente.

Sintaxis:while (<condición>) <sentencia/s>;

La sentencia o el grupo de sentencias es ejecutado repetidamente mientras la condición sea

verdadera, ("while" en inglés significa "mientras").Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente.Si la primera vez que se evalúa la condición resulta falsa, la/s sentencia/s no se ejecutarán ningunavez.

Por ejemplo:while (x < 100) x = x + 1;

Se incrementará el valor de x mientras x sea menor que 100.Este ejemplo puede escribirse, usando el C con propiedad y elegancia, de un modo más compacto:

while (x++ < 100);

Aquí vemos el uso de una sentencia nula, observa que el bucle simplemente se repite, y la

sentencia ejecutada es ";", es decir, nada.

7.3.2. Bucle "do while".

Esta sentencia va un paso más allá que el "while".

Sintaxis:do <sentencia/s> while(<condición>);

La/s sentencia/s es ejecutada repetidamente mientras la condición resulte verdadera.Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente. A diferencia del bucle "while", la evaluación se realiza después de ejecutar la sentencia, de modoque se ejecutará al menos una vez.

Por ejemplo:do

x = x + 1;while (x < 100);

Se incrementará el valor de x hasta que x valga 100.

- 34 -

7.3.3. Bucle "for".

Por último, el bucle "for", es el más elaborado.Sintaxis:

for ( [<inicialización>]; [<condición>] ; [<incremento>] )<sentencia/s>

La/s sentencia/s es ejecutada repetidamente hasta que la evaluación de la condición resulte falsa. Antes de la primera iteración se ejecutará la iniciación del bucle, que puede ser una expresión ouna declaración.En este apartado se iniciarán las variables usadas en el bucle. Estas variables pueden serdeclaradas en este punto, pero en ese caso tendrán validez sólo dentro del bucle "for".Después de cada iteración se ejecutará el incremento de las variables del bucle.Todas las expresiones son opcionales, si no se especifica la condición se asume que es verdadera.

Por ejemplo:for (int i = 0; i < 100; i = i + 1);

Como las expresiones son opcionales, podemos simular bucles "while":

for(;i < 100;) i = i +1;for(;i++ < 100;);

O bucles infinitos:for(;;);

7.4. Etiquetas.Los programas C y C++ se ejecutan secuencialmente, aunque esta secuencia puede serinterrumpida de varias maneras.Las etiquetas son la forma en que se indica al compilador en qué puntos será reanudada laejecución de un programa cuando haya una ruptura del orden secuencial.

7.4.1. Etiquetas de identificación.

Las etiquetas de identificación sirven como puntos de entrada para la sentencia de salto "goto".

Sintaxis:<identificador>: <sentencia>

Estas etiquetas tienen el ámbito restringido a la función dentro de la cual están definidas. Veremos su uso con más detalle al analizar la sentencia "goto".

7.4.2. Etiquetas "case" y "default".

Estas etiquetas se circunscriben al ámbito de la sentencia "switch", y se verá su uso cuandoestudiemos ese apartado.Sintaxis:

switch(<variable>){case <expresión_constante>: [<sentencias>][break;] . . .[default: [<sentencias>]]}

- 35 -

7.5. Sentencias de Selección.Las sentencias de selección permiten controlar el flujo del programa, seleccionando distintassentencias en función de diferentes valores.

7.5.1. Sentencia "if...else".

Implementa la ejecución condicional de una sentencia.

Sintaxis:if (<condición>) <sentencia1>;if (<condición>) <sentencia1>; else <sentencia2>;

Si la condición es "true" se ejecutará la sentencia1, si es "false" se ejecutará la sentencia2.El "else" es opcional, y no pueden insertarse sentencias entre la sentencia1 y el "else".Se pueden declarar variables dentro de la condición.

Por ejemplo:if ( int val = func(arg))...

En este caso, la variable "val" sólo estará accesible dentro del ámbito de la sentencia "if" y, siexiste, del "else".

7.5.2. Sentencia "switch".

Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con el "case" cuyaexpresión constante coincida con el valor de la variable del "switch". A partir de ese punto todas las sentencias serán ejecutadas hasta el final del "switch", es decirhasta llegar al "}". Esto es así porque las etiquetas sólo marcan los puntos de entrada después deuna ruptura de la secuencia de ejecución, pero no marcan las salidas.Esta característica nos permite ejecutar las mismas sentencias para varias etiquetas distintas, y sepuede eludir usando la sentencia de ruptura "break" al final de las sentencias incluidas en cada

"case".Si no se satisface ningún "case", el control parará a la siguiente sentencia después de la etiqueta"default". Esta etiqueta es opcional y si no aparece se abandonará el "switch".No te preocupes, con un ejemplo se aclarará.

Sintaxis:switch (<variable>){case <expresión_constante>: [<sentencias>] [break;]. . .[default : [<sentencia>]]}

Por ejemplo:switch(letra){case 'a':case 'e':case 'i':case 'o':case 'u':EsVocal = true;

- 36 -

break;default:EsVocal = false;}

En este ejemplo letra es una variable de tipo "char" y EsVocal de tipo "bool".

Si el valor de entrada en el "switch" corresponde a una vocal, EsVocal saldrá con un valorverdadero, en caso contrario, saldrá con un valor falso.El ejemplo ilustra el uso del "break", si letra es 'a', se cumple el primer "case", y la ejecucióncontinúa en la siguiente sentencia, ignorando el resto de los "case" hasta el "break".

Otro ejemplo:

Menor1 = Menor2 = Menor3 = Mayor3 = false;switch (numero){case 0:Menor1 = true;case 1:

Menor2 = true;case 2:Menor3 = true;break;default:Mayor3 = true;}

Veamos qué pasa en este ejemplo si número vale 1.Directamente se reanuda la ejecución en "case 1:", con lo cual Menor2 tomará el valor "true", lomismo pasará con Menor3.Después aparece el "break" y se abandona el "switch".

7.6. Sentencias de salto.Las sentencias de salto permiten romper la ejecución secuencial de un programa.

7.6.1. Sentencia de ruptura "break".

El uso de esta sentencia dentro de un bucle pasa el control a la primera sentencia después de lasentencia de bucle.Un ejemplo de aplicación es dentro de la sentencia "switch".

Sintaxis:break

Ejemplo:y = 0;

x = 0;while (x < 1000){if (y == 1000) break;y++;}

x = 1;

- 37 -

En este ejemplo el bucle no terminaría nunca si no fuera por la línea del "break", ya que x nocambia.Después del "break" el programa continuaría en la línea "x = 1".

7.6.2. Sentencia “continue".

El uso de la sentencia continue dentro de un bucle permite pasar el control al final de la sentenciade bucle, justo al punto donde se evalúa la condición para la permanencia en el bucle.

Sintaxis:continue

Ejemplo:y = 0;

x = 0;while (x < 1000){

x++;if (y >= 100) continue;

y++;}

En este ejemplo la línea "y++" sólo se ejecutaría mientras "y" sea menor que 100, en cualquierotro caso el control pasa a la línea "}", con lo que el bucle volvería a evaluarse.

7.6.3. Sentencia de salto "goto".

Con el uso de la sentencia goto el control del programa se transfiere directamente al puntoetiquetado con el identificador especificado.El "goto" es un mecanismo que está en guerra permanente, y sin cuartel, con la programaciónestructurada.El "goto" no se usa, se incluye aquí porque existe, pero siempre que se pueda debe ser eludido.

Existen otros mecanismos para hacer todo aquello que pueda realizarse con un "goto".

Sintaxis:goto <identificador>

Ejemplo: x = 0;Bucle:

x++;if (x < 1000) goto Bucle;

Este ejemplo emula el funcionamiento de un bucle "for" como el siguiente:for(x = 0; x < 1000; x++);

7.6.4. Sentencia de retorno "return".

La sentencia return sale de la función donde se encuentra y devuelve el control a la rutina que lallamó, opcionalmente con un valor de retorno.

Sintaxis:return [<expresión>]




- 38 -

Ejemplo:int Paridad(int x){if (x % 2) return 1;return 0;}

Este ejemplo ilustra la implementación de una función que calcula la paridad de un parámetro. Si elresto de dividir el parámetro entre 2 es distinto de cero, implica que el parámetro es impar, y lafunción retorna con valor 1. El resto de la función no se ejecuta. Si por el contrario el resto dedividir el parámetro entre 2 es cero, el parámetro será un número par y la función retornará convalor cero.

7.6.5. Sobre las sentencias de salto y la programación estructurada.

En general, es una buena norma huir de las sentencias de salto. Lo dicho para la sentencia "goto"es válido en general para todas las sentencias de salto, salvo el "return" y el "break", este últimotiene un poco más de tolerancia, sobre todo en las sentencias "switch", donde resultaimprescindible.

7.7. Comentarios.Los comentarios ayudan a seguir el funcionamiento del programa durante la depuración o en laactualización del programa, además de documentarlo.No se trata propiamente de un tipo de sentencias, pero me parece que es el lugar adecuado paraintroducir este concepto.En C pueden introducirse comentarios en cualquier parte del programa, Los comentarios en C sedelimitan entre /* y */, cualquier cosa que escribamos en su interior será ignorada por elcompilador, sólo está prohibido su uso en el interior de palabras reservadas o en el interior deidentificadores.

Por ejemplo:

main(/*Sin argumentos*/void) está permitidoma/*función*/in(void) es ilegal

La función de los comentarios es aclarar y documentar, no entorpecer el código.En C++ se ha incluido otro tipo de comentarios, que empiezan con //. Estos comentarios no tienenmarca de final, sino que terminan cuando termina la línea.

Por ejemplo:void main (void) // Esto es un comentario{}

Las llaves {} no forman parte del comentario.

- 39 -

7.8. Ejercicios con sentencias.1) Mostrar los sucesivos valores de la variable x en los siguientes bucles:

a) int x=0;

while(x < 5) x += 2;• 0,2,4,6• 0,2,4• 0,2,4,6,8

b) int x=10;do x++; while(x < 10);

• 10• 10,11• 11

c) bool salir = false;int x = 13;while(!salir) {x++;

salir = x%7; }

• 13,14• 13,14,15• 13

d) int x = 6;do {switch(x%3) {case 0: x=10; break;case 1: x=17; break;case 2: x=5; break; } } while(x != 5);

• 6,10,17• 6,10,17,5• 6,10,17,10,5

e) int x=0, y=0;do {if(x>4) { x %= 4; y++; }else x++; } while(y < 2);

• 0,1,2,3,4,5,1,2,3,4,5,1• 0,1,2,3,4,5,1,2,3,4,5• 0,1,2,3,4,5,1,2,3,4,5,1,2

f) int x=0, y=1;while(y != 3) {x++;if(x<3) continue;x=y; y++; }

• 0,1,2,3,1,2,3,2,3• 0,1,2,3,1,2,3,2• 0,1,2,3,1,2,3,2,3,2

TALLER DE INFORMÁTICA CAPITULO 8. Funciones

- 40 -

CAPITULO 8. FUNCIONES.

Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general tomanunos valores de entrada, llamados parámetros y proporcionan un valor de salida o valor de retorno ;aunque tanto unos como el otro pueden no existir.

Al igual que con las variables, las funciones pueden declararse y definirse.Una declaración es simplemente una presentación.Una definición contiene las instrucciones con las que realizará su trabajo la función.

8.1. Declaración de función. El Prototipo.La declaración de una función se realiza mediante una sentencia conocida con el nombre de prototipo .Un prototipo consiste en una definición de la función sin cuerpo y terminado con un ";".

Sintaxis:<tipo> func (<lista de declaración de parámetros>);

Por ejemplo:int Intervalo(int a, int b); /*Prototipo de la función Intervalo*/

El prototipo sirve para indicar al compilador los tipos de datos de retorno y los tipos de datos de losparámetros que recibe la función, de modo que compruebe si son del tipo correcto cada vez que seuse esta función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario.Los nombres de los parámetros son opcionales, y se incluyen como documentación y ayuda en lainterpretación y comprensión del programa.El ejemplo de prototipo anterior sería igualmente válido y se podría poner como:

int Intervalo (int,int); /*Prototipo de la función Intervalo */

El prototipo del ejemplo indica que en algún lugar del programa se definirá una función "Intervalo"que admite dos parámetros de tipo "int" y que devolverá un valor de tipo "int". No es necesarioescribir nombres para los parámetros, ya que el prototipo no los usa. En otro lugar del programahabrá una definición completa de la función.

Normalmente se aconseja:Copiar el prototipo de la función y pegar como una definición eliminando el “;” del final de línea deesta manera no se comenten errores.PERO si hacemos esto utilizando la última forma de indicar el prototipo de la función (es decir sin

dar nombres a las variables) no sirve, ya que en la definición de la función necesitamos dar unnombre a la variable para poder usarla.Las funciones se declaran como prototipos dentro del programa, o se incluyen estos prototiposdesde un fichero externo, (usando la directiva "#include")La definición de la función se hace más adelante; lo habitual es hacerlo después de la función"main".Los programas complejos se escriben normalmente usando varios ficheros fuente. Estos ficheros secompilan separadamente y se enlazan juntos. Esto es una gran ventaja durante el desarrollo y




- 41 -

depuración de grandes programas, ya que las modificaciones en un fichero fuente sólo nosobligarán a compilar ese fichero fuente, y no el resto, con el consiguiente ahorro de tiempo.La definición de las funciones puede hacerse dentro de los ficheros fuente o enlazarse desdelibrerías precompiladas. La diferencia entre una declaración y una definición es que la definiciónposee un cuerpo de función.

En C++ es obligatorio el uso funciones prototipo, y aunque en C no lo es, resulta altamenterecomendable.

8.1.1. Funciones extern y static.

Hay funciones que son "extern" por defecto. Esto quiere decir que son accesibles desde cualquierpunto del programa, aunque se encuentren en otros ficheros fuente del mismo programa.En contraposición las funciones declaradas "static" sólo son accesibles dentro del fichero fuentedonde se definen.

8.2. Definición de función.La definición de una función se compone de las siguientes secciones, aunque pueden complicarseen ciertos casos:

Tipo de almacenamiento

Tipo de valor de retorno

Modificadores opcionales

Nombre de la función

Lista de parámetros (entre paréntesis)

Cuerpo de la función

8.2.1. Tipo de almacenamiento.

Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser "extern" o"static". Si no se especifica es "extern".

8.2.2. Tipo de valor de retorno.

El tipo del valor de retorno puede ser "void" si no necesitamos valor de retorno.En C, si no se establece, por defecto será "int", aunque en general se considera de mal gusto omitirel tipo de valor de retorno.En C++ es obligatorio indicar el tipo del valor de retorno.

8.2.3. Modificadores opcionales.

Los modificadores tienen un uso muy específico, de momento no entraremos en este particular, loveremos en capítulos posteriores.

- 42 -

8.2.4. Nombre de la función.

Para el nombre de la función, resulta muy útil y recomendable, poner nombres que indiquen, lomás claramente posible, qué es lo que hace la función, y que permitan interpretar qué hace elprograma con sólo leerlo.Cuando se precisen varias palabras para conseguir este efecto existen varias reglas aplicables deuso común. Una consiste en separar cada palabra con un "_", la otra, que yo prefiero, consiste enescribir la primera letra de cada palabra en mayúscula y el resto en minúsculas.Por ejemplo, si hacemos una función que busque el número de teléfono de una persona en unabase de datos, podríamos llamarla "busca_telefono" o "BuscaTelefono".

8.2.5. Lista de parámetros.

Entre paréntesis se deben incluir las declaraciones de parámetros separados por coma (,).Los parámetros de una función son los valores de entrada (y en ocasiones también de salida).Para la función se comportan exactamente igual que variables, y de hecho cada parámetro sedeclara igual que una variable.Una lista de parámetros es un conjunto de declaraciones de parámetros separados con comas.Puede tratarse de una lista vacía.En C es preferible usar la forma "func(void)" para listas de parámetros vacías.En C++ este procedimiento se considera obsoleto, se usa simplemente "func()".

8.2.6. Cuerpo de función.

El cuerpo de función representa el código que será ejecutado cuando se llame a la función.El cuerpo de la función se encierra entre llaves "{}"

8.3. Función main().Una función muy especial es la función "main".Se trata de la función de entrada, y debe existir SIEMPRE. Será la función que tome el controlcuando se ejecute un programa en C.Existen reglas para el uso de los valores de retorno y de los parámetros de la función "main", perode momento la usaremos como "int main()" o "int main(void)", con un entero como valor deretorno y sin parámetros de entrada.En Linux la función main() DEBERÁ retornar un valor sino el compilador indicará un error.

Ejemplo de función:/* Esta función devuelve el mayor de dos números */# include <iostream>using namespace std;int Mayor (int a, int b); /* Prototipo de función Mayor */int main(){ int x,y; /*variables locales x e y*/ cout << endl << "Ingrese un entero: ";

cin >> x;cout << endl << "Ingrese otro entero: ";cin >> y;cout<< endl <<"El mayor valor es :" << Mayor(x,y)<< endl; /*Llamada*/ return 0; } int Mayor (int a, int b) /* Definición de función Mayor */{ if (a >=b) return a;else return b; }

- 43 -

8.4. Ámbito de variables.

Dependiendo de dónde se declaren las variables, podrán o no ser accesibles desde distintas partesdel programa.

8.4.1. Variables locales.

Las variables declaradas dentro de una función, y recuerda que "main" también es una función,sólo serán accesibles desde esa función. Esas variables son variables locales o de ámbito local deesa función.Las variables declaradas dentro de un bucle, serán accesibles sólo desde el propio bucle, serán deámbito local del bucle.

8.4.2. Variables globales.

Las variables declaradas fuera de las funciones, normalmente antes de definir las funciones, en lazona donde se declaran los prototipos, serán accesibles desde todas las funciones.Diremos que esas variables serán globales o de ámbito global.

Por ejemplo:int EnteroGlobal; // Declaración de una variable globalint Funcion1(int a); // Declaración de un prototipoint main(){int EnteroLocal; // Declaración de una variable local de main: EnteroLocal = Funcion1(10); // Acceso a una variable local:EnteroGlobal = Funcion1(EnteroLocal); // Acceso a una valiable global:return 0; }int Funcion1(int a){ char CaracterLocal; // Variable local de funcion1

// Desde aquí podemos acceder a EnteroGlobal, y también

//a CaracterLocal pero no a EnteroLocalif (EnteroGlobal != 0)return a //EnteroGlobal; elsereturn 0; }

De modo que en cuanto a los ámbitos locales tenemos varios niveles:<tipo> funcion(parámetros) // (1){<tipo> var; // (2)for(<tipo> var;...) // (3)...

return var;}

(1) los parámetros tienen ámbito local a la función.(2) las variables declaradas aquí, también.(3) las declaradas en bucles, son locales al bucle.

Es una buena costumbre inicializar las variables locales.Cuando se trate de variables estáticas se inicializan automáticamente a cero.

- 44 -

8.5. Ejercicios.1-) En el ejemplo, ¿qué ámbito tiene cada una de las variables? Marcar la opción correcta.

float s,i;int main(){

int x;x=10;for(int i=0; i<x; i++)Mostrar(i);i = 0.0;while(x>0) {i *= 10.3;x--; }return 0;

a) La variable de tipo float s tiene ámbito• global• local en main• local en bucle

b) La variable de tipo int i tiene ámbito• global• local en main• local en bucle

c) La variable de tipo float i tiene ámbito• global• local en main• local en bucle

d) La variable de tipo int x tiene ámbito• global• local en main• local en bucle

2-) ¿Cuáles de los siguientes prototipos son válidos?

a) Calcular(int, int, char r);Sí No

b) void Invertir(int, unsigned char)Sí No

c) void Aumentar(float valor);Sí No

d) float Negativo(float int);Sí No

e) int Menor(int, int, int);Sí No




- 45 -

f) char Menu(int opciones);Sí No

3-) Preguntas sobre la estructura de un programa. Marcar la opción correcta.

a) ¿Entre qué zonas harías las declaraciones de variables globales?•

Antes de la zona de las directivas del preprocesador.• Entre la zona de las directivas del preprocesador y las declaraciones de prototipos.• Después de la definición de la función "main".

b) ¿Qué aparecería normalmente justo después de la definición de la función "main"?• Las directivas del preprocesador.• Los prototipos de funciones.• Las definiciones de funciones.

4-) Identifique las siguientes partes de las funciones. Marcar la/s opción/es correcta/s.

• Encabezado o Definición de la Función.• Cuerpo de la Función ó Enunciados de la Función.• Prototipo de la Función.• Argumentos de la Función.• Tipos de Argumentos de la Función.• Tipo de Argumento retornado por la Función.

5-) Escribir el código fuente de un programa que contenga una función que reciba un entero ydevuelva P si es POSITIVO y N si es NEGATIVO.6-) Escribir el código fuente de un programa que desde main se llame a una función que recibedos argumentos enteros y devuelve un valor booleano, siendo TRUE si el mayor argumento esdivisible por el menor o FALSE si el mayor argumento no es divisible por el mayor.7-) Escribir el código fuente de un programa que desde main se llame a una función que recibecomo argumento dos números reales, y retorna el menor que es mostrado en main.8-) Escribir el código fuente de un programa que desde main se llame a una función pasando comoargumento un valor entero, esta función calcula los coeficientes de la serie de “Fibonacci” hasta elentero pasado; y retorna la suma de los términos que se muestra desde main.Ej: N=6 , la serie será = 0 – 1 – 1 – 2 – 3 – 5. La suma mostrada en main será S=12.9-) Escribir el código fuente de un programa que permita definir tres funciones, una que detecta siun carácter es una Vocal , otra que detecta si es Consonante y otra si es un Dígito, todas devuelvenel valor TRUE o FALSE y desde main se debe indicar si el tipo de char ingresado es : vocal,consonante ó dígito.Se puede suponer en principio para simplificar que los caracteres ingresados son TODO minúsculas.Sugerencia: Mirar la tabla de caracteres ASCII.10-) Escribir el código fuente de un programa que desde main se llame a una función la cual recibeun par de números y retorna el resto de la división del mayor dividido el menor.Sugerencia: usar el operador () ? : .

11-) Escribir el código fuente de un programa que desde main se llame a una función que recibecomo argumento un número entero, calcula y muestra desde la misma función los divisores de esenúmero retornando un valor TRUE, si el número no es primo y FALSE si es primo.12-) Se dice que un número entero es perfecto, si la suma de sus divisores incluyendo el 1 es iguala sí mismo.Ej: 6 = 3 + 2+ 1 , ver que 3,2,1 son divisores de 6.Escribir una función que reciba un entero, y retorne TRUE para el caso de que el número sea un “entero perfecto”.




- 46 -

13-) Escribir el código fuente de un programa que desde main se llame a una función menú queno recibe ningún argumento y que retorne la opción de menú elegida, ésta se mostrará desdemain. Los ítems del menú deberían ser por ej. 1,2,3,4 y 5 para salir, o A,B,.. y F para Finalizar.Controlar que sólo salga con la opción indicada.14-) Escribir el código fuente de un programa que desde main se llame a una función menú(similar al ejercicio 13), las opciones del menú serán:

1: Cargar un vector y luego presentar nuevamente el menú, (todas las funciones refieren al vector)2: Ordenar.3:Buscar el mayor.4:Calcular el promedio.5:Salir.Cada uno de estos puntos se debe realizar con una función. No usar variables globales. Usar pasajede valores a funciones por referencia para el caso de ordenar!!.15-) Escribir el código fuente de un programa que desde main llame a una función la cual itera (sinhacer nada) mientras se introduzca la letra “s” y se detiene cuando se introduce la letra “n”. Ver que s y n son MINUSCULAS!!.16-) Escribir el código fuente de un programa que desde main copie usado la función “strcpy” deun string.17-) Escriba una función que reciba la cantidad de elementos a acumular y retorne el valor

acumulado.Ej: recibe 4, y luego se ingresan, dentro de la función cuatro números, 1, 3, 3, 2 deberá retornar amain el total acumulado=9.18-) Escriba una función que reciba la cantidad de elementos a promediar y retorne el promedio.Ej: recibe 3, luego se ingresan, dentro de la función tres valores, 10, 5, 15 y deberá retornar amain el promedio=10.

TALLER DE INFORMÁTICA CAPITULO 9. Arreglos

- 47 -

CAPITULO 9. ARREGLOS.

Un arreglo es un conjunto de elementos del mismo tipo agrupados en una sola variable. Es unaestructura de datos en la que se almacena una colección de datos del mismo tipo

Los arreglos poseen ciertas características particulares:

• Cada posición de almacenamiento en un arreglo es llamada un elemento del arreglo.

• Para ingresar a un elemento en particular, utilizamos un índice.

• Tienen un único nombre de variable, que representa todos los elementos, los cuales sediferencian por un índice o subíndice.

• Existen arreglos unidimensionales, bidimensionales y tridimensionales.

• Físicamente, un arreglo es un conjunto de localidades de memoria contiguas donde ladirección más baja corresponde al primer elemento y la dirección más alta al último.

• En un arreglo de n elementos, éstos ocuparan desde 0 hasta la n-1.

• Por sí mismo, el nombre del arreglo apunta a la dirección del primer elemento del arreglo.

9.1. Cadena de caracteres. Antes de comenzar a desarrollar el tema de los arreglos o "arrays", veremos un caso especial deellos.Se trata de las cadenas de caracteres o "strings " (en inglés).Una cadena, en C, es un conjunto de caracteres, o valores de tipo "char", terminados con elcarácter nulo, es decir el valor numérico 0.

Internamente se almacenan en posiciones consecutivas de memoria.Este tipo de estructuras recibe un tratamiento especial, y es de gran utilidad y de uso continuo.Una cadena puede almacenar informaciones como nombres de personas, mensajes de error,números de teléfono, etc.

Sintaxis para definir una variable tipo cadena:

char <identificador> [<longitud máxima>];

En este caso los corchetes no indican un valor opcional, sino que son realmente corchetes, por esoestán en negrita.Durante el tratamiento de variables tipo cadena tener en cuenta que:

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posiciónpara almacenar el carácter nulo.

Por ejemplo:Si queremos almacenar la cadena "HOLA", tendremos que declarar la cadena como:

char Saludo[5]; // Cuatro caracteres para "HOLA" y uno para '\000'.

Es posible hacer referencia a cada uno de los caracteres individuales que componen la cadena,simplemente indicando la posición.

- 48 -

Por ejemplo:Saludo[2]; // Hace referencia al 3º carácter de la cadena, la 'L'.

Los índices tomarán valores empezando en el cero.

Por ejemplo:

Saludo[0]; //Hace referencia al 1º carácter de la cadena, la 'H'.La asignación directa sólo está permitida cuando se hace junto con la declaración.

Por ejemplo:char Saludo[5];Saludo = "HOLA"

Esta modalidad producirá un error en el compilador, ya que una cadena definida de este modo seconsidera una constante, como veremos en el capítulo de "arrays" o arreglos.

La manera correcta de asignar una cadena es:char Saludo[5];

Saludo[0] = 'H';Saludo[1] = 'O';Saludo[2] = 'L';Saludo[3] = 'A';Saludo[4] = '\000';

O bien:char Saludo[5] = "HOLA";

Si parece un sistema engorroso, no te preocupes, en próximos capítulos veremos funciones quefacilitarán la asignación de cadenas.Existen muchas funciones para el tratamiento de cadenas, como veremos, que permitencompararlas, copiarlas, calcular su longitud, imprimirlas, visualizarlas, guardarlas en disco, etc. Además, frecuentemente, nos encontraremos a nosotros mismos creando nuevas funciones quebásicamente hacen un tratamiento de cadenas.

9.2. Arreglos.Empezaremos con los tipos de datos estructurados, los arrays.Los arrays o arreglos permiten agrupar datos usando un mismo identificador.Todos los elementos de un array son del mismo tipo, y para acceder a cada elemento se usansubíndices.

Sintaxis:<tipo> <identificador>[<núm_elemen>][[<núm_elemen>]...];

Los valores para el número de elementos deben ser constantes, y se pueden usar tantasdimensiones como queramos, limitado sólo por la memoria disponible.

Cuando sólo se usa una dimensión se suele hablar de listas o vectores, cuando se usan dos, detablas o matrices. Ahora podemos ver que las cadenas de caracteres son un tipo especial de arrays. Se trata enrealidad de arrays de una dimensión de objetos de tipo char.Los subíndices son enteros, y pueden tomar valores desde 0 hasta <número de elementos>-1.




- 49 -

Esto es muy importante, y hay que tener mucho cuidado.Por ejemplo:

int Vector[10];

Creará un array con 10 elementos enteros; podremos acceder a los elementos Vector[0] a Vector[9].

Como subíndice podremos usar cualquier expresión entera.En general C++ no verifica el ámbito de los subíndices. Si declaramos un array de 10 elementos,no obtendremos errores al acceder al elemento 11.Sin embargo, si asignamos valores a elementos fuera del ámbito declarado, estaremos accediendoa zonas de memoria que pueden pertenecer a otras variables o incluso al código ejecutable denuestro programa, con consecuencias generalmente desastrosas.

Por ejemplo:int Tabla[10][10];char DimensionN[4][15][6][8][11];...DimensionN[3][11][0][4][6] = DimensionN[0][12][5][3][1];

Tabla[0][0] += Tabla[9][9];

Cada elemento de Tabla, desde Tabla[0][0] hasta Tabla[9][9] es un entero.Del mismo modo, cada elemento de Dimensión N es un carácter.

9.2.1. Inicialización de un arreglo.

Los arrays pueden ser inicializados junto con la declaración.

Por ejemplo:float R[10] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};float S[] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};int N[] = {1, 2, 3, 6};

int M[][3] = { 213, 32, 32, 32, 43, 32, 3, 43, 21};char Mensaje[] = "Error de lectura";char Saludo[] = {'H', 'o', 'l', 'a', 0};

En estos casos no es obligatorio especificar el tamaño para la primera dimensión, como ocurre enlos ejemplos de las líneas 2, 3, 4, 5 y 6.En estos casos la dimensión que queda indefinida se calcula a partir del número de elementos en lalista de valores iniciales.En el caso 2, el número de elementos es 10, ya que hay diez valores en la lista.En el caso 3, será 4.En el caso 4, será 3, ya que hay 9 valores, y la segunda dimensión es 3: 9/3=3. Y en el caso 5, el número de elementos es 17, 16 caracteres más el cero de fin de cadena.

9.2.2. Operadores utilizados con arreglos. Ya hemos visto que se puede usar el operador de asignación con arrays para asignar valoresiniciales.El otro operador que tiene sentido con los arrays es sizeof . Aplicado a un array, el operador sizeof devuelve el tamaño de todo el array en bytes.Podemos obtener el número de elementos dividiendo ese valor entre el tamaño de uno de loselementos.

- 50 -

Por ejemplo:

#include <iostream>using namespace std;int main(){

int array[231];cout << "Número de elementos: " << sizeof(array)/sizeof(int) << endl;cout << "Número de elementos: " << sizeof(array)/sizeof(array[0]) << endl;cin.get();return 0; }

Las dos formas son válidas, pero la segunda es, tal vez, más general.

9.3. Algoritmos de ordenación: método de la burbuja.Una operación que se hace muy a menudo con los arrays, sobre todo con los de una dimensión, esordenar sus elementos.

Dedicaremos más capítulos a algoritmos de ordenación, pero ahora veremos uno de los másusados, aunque no de los más eficaces, se trata del método de la burbuja.Consiste en recorrer la lista de valores a ordenar y compararlos dos a dos.Si los elementos están bien ordenados, pasamos al siguiente par, si no lo están los intercambiamos,y pasamos al siguiente, hasta llegar al final de la lista.El proceso completo se repite hasta que la lista está ordenada. Veamos el método utilizando un ejemplo:Ordenar la siguiente lista de menor a mayor:

15 | 3 | 8 | 6 | 18 | 1

Empezamos comparando 15 y 3. Como están mal ordenados los intercambiamos, la lista quedará:

3 | 15 | 8 | 6 |18 | 1

Tomamos el siguiente par de valores: 15 y 8, y volvemos a intercambiarlos, y seguimos elproceso...Cuando lleguemos al final la lista estará así:

3 | 8 | 6 |15| 1| 18

Empezamos la segunda pasada, pero ahora no es necesario recorrer toda la lista. Si observas verásque el último elemento está bien ordenado, siempre será el mayor, por lo tanto no será necesarioincluirlo en la segunda pasada.Después de la segunda pasada la lista quedará:

3 | 6 | 8 | 1| 15 |18

Ahora es el 15 el que ocupa su posición final, la penúltima, por lo tanto no será necesario que entreen las comparaciones para la siguiente pasada.Las sucesivas pasadas dejarán la lista así:

3ª) 3 | 6 | 1| 8 | 15 | 18 4ª) 3 |1 | 6 | 8 | 15 | 18




- 51 -

5ª) 1 | 3 | 6| 8 | 15 | 18

9.4. Ejercicios: cadenas de caracteres.Teniendo en cuenta la asignación que hemos hecho para la cadena Saludo, se muestran variasversiones de una función que calcule la longitud de una cadena, ¿cuáles de ellas funcionan y cuáles

no? Marcar la opción correcta.a)int LongitudCadena(char cad[]){int l = 0;while(cad[l]) l++;return l; }

Sí No

b)int LongitudCadena(char cad[])

{int l;for(l = 0; cad[l] != 0; l++);return l; }

Sí No

c)int LongitudCadena(char cad[]){int l = 0;do {l++;

} while(cad[l] != 0);return l; }

Sí No

9.5. Ejercicios: arreglos.1-) Hacer un programa que lea diez valores enteros en un array desde el teclado y calcule ymuestre: la suma, el valor promedio, el mayor y el menor.2-) Hacer un programa que lea diez valores enteros en un array y los muestre en pantalla.Después ordenar de menor a mayor y vuelva a mostrar. Finalmente ordenar de mayor a menor ylos muestre por tercera vez. Para ordenar la lista usar una función que implemente el método de la

burbuja y que tenga como parámetro de entrada el tipo de ordenación, de mayor a menor o demenor a mayor. Para el array usar una variable global.3-) Hacer un programa que contenga una función con el prototipo

bool Incrementa (char numero[10]); .La función debe incrementar el número pasado como parámetro en una cadena de caracteres de 9dígitos. Si la cadena no contiene un número, debe devolver “false”, en caso contrario debe devolver “true”, y la cadena debe contener el número incrementado. Si el número es "999999999", debedevolver "0". Cadenas con números de menos de 9 dígitos pueden contener ceros iniciales o no.Ej: la función debe ser capaz de incrementar tanto la cadena "3423", como "00002323".La función "main" llamará a la función Incrementar con diferentes cadenas.

- 52 -

4-) Hacer un programa que contenga una función con el prototipobool Palindromo(char palabra[40]); .

La función debe devolver true si la palabra es un palíndromo, y false si no lo es.Una palabra es un palíndromo si cuando se lee desde el final al principio es igual que leyendodesde el principio, por ejemplo: "Otto", o con varias palabras "Anita lava la tina", "Dábale arroz a lazorra el abad", “La ruta nos aportó otro paso natural”.

En estos casos debemos ignorar los acentos y los espacios, pero no es necesario que tu funciónhaga eso, bastará con probar cadenas como "anitalavalatina", o "dabalearrozalazorraelabad".La función no debe hacer distinciones entre mayúsculas y minúsculas.5-) Escribir el código fuente de un programa que permita la carga de un string definido de no masde 20 caracteres e indique cuántos caracteres se tipearon. Alternativa 1) suponer que no hay espacios en blanco, por ej. si se tipea asfhe<Enter>, deberíaindicar 5 caracteres. Alternativa 2) debería contar la cantidad caracteres ingresados incluidos los espacio en blanco, porej. Juan Jorge<Enter>, debería indicar 10 caracteres.Resolución Alternativa 2:

#include <iostream>using namespace std;

int main(){int i=1;char mensaje [21];cout << " Ingrese un texto de no mas de 20 caracteres" << endl;cin.getline (mensaje,21);while (mensaje[i]!=0)i++;cout <<endl <<"El arreglo tiene: " << i << " caracteres";return 0; }

6-) Escribir un código de programa que llame desde main a una función pasando por referencia elnombre de un array y desde esa función se mostrará por pantalla el array escrito de atrás paraadelante.Ej: se ingresa desde main Juan Pablo y desde la función se deberá mostrar: olbaP nauJ.

#include <iostream>using namespace std;int main(){int i=1;char mensaje [21]; cout << " Ingrese un texto de no mas de 20 caracteres" << endl;cin.getline (mensaje,21);while (mensaje[i]!=0)i++;

cout <<endl <<"El arreglo tiene: " << i << " caracteres"<< endl;while((i+1)!=0){cout << mensaje[i] ;--i;}cout << endl;return 0; }

7-) Escribir el código que permita la carga de un arreglo de dos dimensiones.8-) Escribir el código que permita cargar un vector y luego mostrar el mayor y menor elemento,SIN ordenar.




- 53 -

9-) Hacer un programa que cargue 25 valores enteros en un arreglo de 5 x 5, y luego muestreprimero la suma de cada fila y luego la suma de cada columna.10-) Escribir el código que permita cargar un vector y luego ordenar de mayor a menor.11-) Escribir el código que permita la carga de una arreglo de dos dimensiones de 3 x 3 y queluego ordene todas las filas de mayor a menor.12-) Escribir el código que permita cargar un arreglo de 3 x 3 y que busque el menor elemento de

cada columna y muestre su valor y posición (fila, columna).13-) Escribir el código que permita cargar un arreglo de 3 x 3, luego busque los elementos que serepiten, y los muestre.Ej: la salida sería: “Elementos repetidos: 3 , 5, 12” Alternativa: indicar la cantidad de veces que se repiten cada número.Ej: Elementos repetido 3 – 2 veces, 5 – 1 vez, 12 - 5 veces.14-) Escribir el código que permita cargar un arreglo de 10 elementos, primero se deberá ingresarla posición y luego el valor. Se deberá controlar que el índice o posición del arreglo no exceda alvalor máximo del arreglo. Alternativa: Verificar si el elemento ya ha sido cargado.15-) Escribir el código que permita la carga de los 5 primeros elementos de un arreglo de 10elementos y luego lo complete copiando el primero al ultimo lugar, el segundo al ante ultimo lugar.Luego deberá mostrar el arreglo cargado.

Ejemplo: se ingresa 1|3|5|2|4 el arreglo mostrado deberá quedar:1|3|5|2|4|4|2|5|3|116-) Escribir el código que permita cargar un arreglo de 3 x 3, pero que sólo permita cargar loselemento de la diagonal principal; el resto lo complete con ceros.17-) Escribir el código que permita cargar un arreglo de 3 x 3, pero que sólo permita cargar loselemento de la diagonal principal y el triángulo superior, luego deberá completar el triánguloinferior de manera de lograr una matriz simétrica.Si se ingresan: 1, 2, 3, 7, 5 ,4.Ej de matriz simétrica:

1 2 32 7 53 5 4

18-) Escribir el código que permita cargar un arreglo de 3 x 3, y que luego cargue un vectorcolumna con el promedio de cada fila.19-) Escribir el código que permita cargar dos arreglos de 3 x 3 de nombre MatA y MatB y, queluego, presente un menú, como el siguiente:

1) Suma las Matrices MatA+MatB.2) Resta las Matrices MatA-Matb.3) Cargar MatA.4) Cargar MatB.5) Salir.

TALLER DE INFORMÁTICA CAPITULO 10. Punteros

- 54 -

CAPITULO 10. PUNTEROS.Los punteros proporcionan la mayor parte de la potencia al C y C++, y marcan la principaldiferencia con otros lenguajes de programación.Una buena comprensión y un buen dominio de los punteros pondrán en tus manos una

herramienta de gran potencia. Un conocimiento mediocre o incompleto te impedirá desarrollarprogramas eficaces.Por eso le dedicaremos mucha atención y mucho espacio a los punteros. Es muy importantecomprender bien cómo funcionan y cómo se usan.Para entender qué es un puntero veremos primero cómo se almacenan los datos en un ordenador.La memoria de un ordenador está compuesta por unidades básicas llamadas bits. Cada bit sólopuede tomar dos valores, normalmente denominados alto y bajo, ó 1 y 0. Pero trabajar con bits noes práctico, y por eso se agrupan.Cada grupo de 8 bits forma un byte u octeto. En realidad el microprocesador, y por lo tanto nuestroprograma, sólo puede manejar directamente bytes o grupos de dos o cuatro bytes. Para acceder alos bits hay que acceder antes a los bytes. Y aquí llegamos al quid, cada byte tiene una dirección,llamada normalmente dirección de memoria.La unidad de información básica es la palabra, dependiendo del tipo de microprocesador una

palabra puede estar compuesta por dos, cuatro, ocho o dieciséis bytes. Hablaremos en estos casosde plataformas de 16, 32, 64 ó 128 bits. Se habla indistintamente de direcciones de memoria,aunque las palabras sean de distinta longitud. Cada dirección de memoria contiene siempre unbyte. Lo que sucederá cuando las palabras sean de 32 bits es que accederemos a posiciones dememoria que serán múltiplos de 4.Todo esto sucede en el interior de la máquina, y nos importa más bien poco.Podemos saber qué tipo de plataforma estamos usando averiguando el tamaño del tipo int, y paraello hay que usar el operador "sizeof()".

Por ejemplo:cout << "Plataforma de " << 8*sizeof(int) << " bits";

Ahora veremos cómo funcionan los punteros.Un puntero es un tipo especial de variable que contiene, ni más ni menos que, una dirección dememoria. Por supuesto, a partir de esa dirección de memoria puede haber cualquier tipo de objeto:un char, un int, un float, un array, una estructura, una función u otro puntero. Seremos nosotroslos responsables de decidir ese contenido.Intentemos ver con mayor claridad el funcionamiento de los punteros.Podemos considerar la memoria del ordenador como un gran array, de modo que podemos accedera cada celda de memoria a través de un índice.Podemos considerar que la primera posición del array es la 0 celda[0].Si usamos una variable para almacenar el índice, por ejemplo, índice=0, entonces celda[0] ==celda[índice]. Prescindiendo de la notación de los arrays, el índice se comporta exactamente igualque un puntero.El puntero índice podría tener por ejemplo, el valor 3, en ese caso, *índice tendría el valor 'valor3'.

Las celdas de memoria existirán independientemente del valor de índice, o incluso de la existenciade índice, por lo tanto, la existencia del puntero no implica nada más que eso, pero no que el valorde la dirección que contiene sea un valor válido de memoria.Dentro del array de celdas de memoria existirán zonas que contendrán programas y datos, tantodel usuario como del propio sistema operativo o de otros programas, el sistema operativo seencarga de gestionar esa memoria, prohibiendo o protegiendo determinadas zonas.El propio puntero, como variable que es, ocupará ciertas direcciones de memoria.

- 55 -

En principio, debemos asignar a un puntero, o bien la dirección de un objeto existente, o bien la deuno creado explícitamente durante la ejecución del programa. El sistema operativo suele controlarla memoria, y no tiene por costumbre permitir el acceso al resto de la memoria.

10.1. Declaración de punteros

Los punteros se declaran igual que el resto de las variables, pero precediendo el identificador con eloperador de indirección, (*), que leeremos como "puntero a".

Sintaxis:<tipo> *<identificador>;

Por ejemplo:int *entero;char *carácter;struct stPunto *punto;

Los punteros siempre apuntan a un objeto de un tipo determinado, en el ejemplo, "entero" siempreapuntará a un objeto de tipo "int".

La forma:<tipo>* <identificador>;

con el (*) junto al tipo, en lugar de junto al identificador de variable, también está permitida. Veamos algunos matices.

Por ejemplo:int *entero;equivale a:int* entero;

Debes tener muy claro que "entero" es una variable del tipo "puntero a int", que "*entero" NO esuna variable de tipo "int".Como pasa con todas las variables en C++, cuando se declaran sólo se reserva espacio paraalmacenarlas, pero no se asigna ningún valor inicial, el contenido de la variable permanecerá sincambios, de modo que el valor inicial del puntero será aleatorio e indeterminado. Debemos suponerque contiene una dirección no válida.Si "entero" apunta a una variable de tipo "int", "*entero" será el contenido de esa variable, pero noolvides que "*entero" es un operador aplicado a una variable de tipo "puntero a int", es decir"*entero" es una expresión, no una variable, que significa: ”el contenido a donde apunta elpuntero” ó “ contenido de la dirección a la que apunta”.




- 56 -

10.2. Obtener punteros a variablesPara averiguar la dirección de memoria de cualquier variable usaremos el operador de dirección(&), que leeremos como "dirección de". Por supuesto, los tipos tienen que ser "compatibles", nopodemos almacenar la dirección de una variable de tipo "char" en un puntero de tipo "int".

Por ejemplo:int A;int *pA;

pA = &A;

Según este ejemplo, pA es un puntero a int que apunta a la dirección donde se almacena el valordel entero A. Trataremos de graficar lo visto hasta ahora.

Veamos como sería solicitando espacio o memoria de un modo dinámico para almacenar un entero,es importante destacar que en este ejemplo SOLO SE USA EL PUNTERO, NO EXISTE NOMBRE

DE VARIABLE.




- 57 -

10.3. Diferencia entre punteros y variablesDeclarar un puntero no creará un objeto. Por ejemplo: int *entero; no crea un objeto de tipo "int"en memoria, sólo crea una variable que puede contener una dirección de memoria. Se puede decirque existe físicamente la variable "entero", y también que esta variable puede contener la direcciónde un objeto de tipo "int".

Por ejemplo:int A, B;int *entero;...B = 213; /* B vale 213 */entero = &A; /* entero apunta a la dirección de la variable A */*entero = 103; /* equivale a la línea A = 103; */B = *entero; /* equivale a B = A; */...

En este ejemplo vemos que "entero" puede apuntar a cualquier variable de tipo "int", y quepodemos hacer referencia al contenido de dichas variables usando el operador de indirección (*).Como todas las variables, los punteros también contienen "basura" cuando son declaradas. Es

costumbre dar valores iniciales nulos a los punteros que no apuntan a ningún sitio concreto:

entero = NULL;caracter = NULL;

NULL es una constante, que está definida como cero en varios ficheros de cabecera, como "cstdio"o "iostream", y normalmente vale 0.




- 58 -

10.4. Correspondencia entre arrays y punterosExiste una equivalencia casi total entre arrays y punteros. Cuando declaramos un array estamoshaciendo varias cosas a la vez:

Declaramos un puntero del mismo tipo que los elementos del array, y que apunta al primer

elemento del array. Reservamos memoria para todos los elementos del array. Los elementos de un array sealmacenan internamente en el ordenador en posiciones consecutivas de la memoria.

La principal diferencia entre un array y un puntero es que el nombre de un array es un punteroconstante, no podemos hacer que apunte a otra dirección de memoria. Además, el compiladorasocia una zona de memoria para los elementos del array, cosa que no hace para los elementosapuntados por un puntero auténtico.

Por ejemplo:i nt vector[10];int *puntero;

puntero = vector; /* Equivale a puntero = &vector[0]; */

/* esto se lee como "dirección del primer de vector"*/*puntero++; /* Equivale a vector[0]++; */

puntero++; /* puntero equivale a &vector[1] */

¿Qué hace cada una de estas instrucciones?La primera incrementa el contenido de la memoria apuntada por "puntero", que es vector[0].La segunda incrementa el puntero, esto significa que apuntará a la posición de memoria delsiguiente "int", pero no a la siguiente posición de memoria.El puntero no se incrementará en una unidad, como tal vez sería lógico esperar, sino en la longitudde un "int". Análogamente la operación: puntero = puntero + 7;No incrementará la dirección de memoria almacenada en "puntero" en siete posiciones, sino en

7*sizeof(int).Por ejemplo:

struct stComplejo {float real, imaginario;} Complejo[10];stComplejo *p;

p = Complejo; /* Equivale a p = &Complejo[0]; */ p++; /* p == &Complejo[1] */

En este caso, al incrementar p avanzaremos las posiciones de memoria necesarias para apuntar alsiguiente complejo del array "Complejo". Es decir avanzaremos sizeof(stComplejo) bytes.

10.5. Operaciones con punteros Aunque no son muchas las operaciones que se pueden hacer con los punteros, cada una tiene suspeculiaridades.

- 59 -

10.5.1. Asignación

Ya hemos visto cómo asignar a un puntero la dirección de una variable.También podemos asignar un puntero a otro, esto hará que los dos apunten a la misma posición:

Por ejemplo:int *q, *p;int a;q = &a; /* q apunta al contenido de a */

p = q; /* p apunta al mismo sitio, es decir, al contenido de a */

10.5.2. Operaciones aritméticas

También hemos visto como afectan a los punteros las operaciones de suma con enteros.Las restas con enteros operan de modo análogo.Pero, ¿qué significan las operaciones de suma y resta entre punteros?

Por ejemplo:int vector[10];int *p, *q;

p = vector; /* Equivale a p = &vector[0]; */q = &vector[4]; /* apuntamos al 5º elemento */cout << q-p << endl;

El resultado será 4, que es la "distancia" entre ambos punteros.Normalmente este tipo de operaciones sólo tendrá sentido entre punteros que apunten a elementosdel mismo array. La suma de punteros no está permitida.

10.5.3. Comparación entre punteros

Comparar punteros puede tener sentido en la misma situación en la que lo tiene restar punteros, esdecir, averiguar posiciones relativas entre punteros que apunten a elementos del mismo array.Existe otra comparación que se realiza muy frecuente con los punteros.Para averiguar si estamos usando un puntero es corriente hacer la comparación:

Sintaxisif(NULL != p)if(p)if(NULL == p)if(!p)

- 60 -

10.6. Punteros genéricosEs posible declarar punteros sin tipo concreto:

Sintaxis:

void *<identificador>;

Estos punteros pueden apuntar a objetos de cualquier tipo.Por supuesto, también se puede emplear el "casting" con punteros.

Sintaxis:(<tipo> *)<variable puntero>

Recordemos que el cambio o conversión de tipo de dato que se realiza de forma implícita en elprocesador cuando encuentra expresiones que contienen diferentes tipos de dato, pero podemoshacerlo de una forma en que programador puede forzar un cambio de tipo de forma explícita. Estecambio se llama cambio por promoción, o casting .

Por ejemplo:#include <iostream>using namespace std;int main() { char cadena[10] = "Hola";char *c;int *n; //puntero a un enterovoid *v;c = cadena; // c apunta a cadena n = (int *)cadena; // usa casting, n también apunta a cadena v = (void *)cadena; // v también cout << "carácter: " << *c << endl;cout << "entero: " << *n << endl;

cout << "float: " << *(float *)v << endl;cin.get();return 0; }

El resultado será:Carácter: HEntero: 1634496328float: 2.72591e+20

Vemos que tanto "cadena" como los punteros "n", "c" y "v" apuntan a la misma dirección, perocada puntero tratará la información que encuentre allí de modo diferente, para "c" es un carácter ypara "n" un entero. Para "v" no tiene tipo definido, pero podemos hacer "casting" con el tipo que

queramos, en este ejemplo con float.

El tipo de línea del tercer "cout" es lo que suele asustar a los no iniciados en C y C++, y se parecemucho a lo que se conoce como código ofuscado. Parece como si en C casi cualquier expresiónpudiese compilar.

- 61 -

10.7. Punteros a estructurasLos punteros también pueden apuntar a estructuras.En este caso, para referirse a cada elemento de la estructura se usa el operador (->), en lugar del(.).

Por ejemplo:#include <iostream>using namespace std;struct stEstructura {int a, b;} estructura, *e;int main(){estructura.a = 10;estructura.b = 32;e = &estructura;cout << "variable" << endl;cout << e->a << endl;

cout << e->b << endl;cout << "puntero" << endl;cout << estructura.a << endl;cout << estructura.b << endl;cin.get();return 0; }

10.8. Ejemplos de uso de punteros

10.8.1. Ejemplo 1

Primero un ejemplo que ilustra la diferencia entre un array y un puntero:

#include <iostream>using namespace std;int main() {char cadena1[] = "Cadena 1";char *cadena2 = "Cadena 2";cout << cadena1 << endl;cout << cadena2 << endl; //cadena1++; // Ilegal, cadena1 es constante cadena2++; // Legal, cadena2 es un puntero cout << cadena1 << endl;cout << cadena2 << endl;

cout << cadena1[1] << endl;cout << cadena2[0] << endl;cout << cadena1 + 2 << endl;cout << cadena2 + 1 << endl;cout << *(cadena1 + 2) << endl;cout << *(cadena2 + 1) << endl;cin.get();return 0; }

- 62 -

Aparentemente, y en la mayoría de los casos, cadena1 y cadena2 son equivalentes, sin embargohay operaciones que están prohibidas con los arrays, ya que son punteros constantes.

10.8.2. Ejemplo 2

#include <iostream>using namespace std;int main() {char Mes[][11] = { "Enero", "Febrero", "Marzo", "Abril","Mayo", "Junio", "Julio", "Agosto","Septiembre", "Octubre", "Noviembre", "Diciembre"};char *Mes2[] = { "Enero", "Febrero", "Marzo", "Abril","Mayo", "Junio", "Julio", "Agosto","Septiembre", "Octubre", "Noviembre", "Diciembre"};cout << "Tamaño de Mes: " << sizeof(Mes) << endl;cout << "Tamaño de Mes2: " << sizeof(Mes2) << endl;cout << "Tamaño de cadenas de Mes2: "<< &Mes2[11][10]-Mes2[0] << endl;

cout << "Tamaño de Mes2 + cadenas : "<< sizeof(Mes2)+&Mes2[11][10]-Mes2[0] << endl;cin.get();return 0; }

En este ejemplo declaramos un array "Mes" de dos dimensiones que almacena 12 cadenas de 11caracteres, 11 es el tamaño necesario para almacenar el mes más largo (en caracteres):"Septiembre".Después declaramos "Mes2" que es un array de punteros a char, para almacenar la mismainformación. La ventaja de este segundo método es que no necesitamos contar la longitud de lascadenas para calcular el espacio que necesitamos, cada puntero de Mes2 es una cadena de lalongitud adecuada para almacenar cada mes.

Parece que el segundo sistema es más económico en cuanto al uso de memoria, pero hay quetener en cuenta que además de las cadenas también se almacenan los doce punteros.El espacio necesario para almacenar los punteros lo dará la segunda línea de la salida. Y el espacionecesario para las cadenas lo dará la tercera línea.Si las diferencias de longitud entre las cadenas fueran mayores, el segundo sistema sería máseficiente en cuanto al uso de la memoria.

- 63 -

10.9. Variables dinámicasDonde mayor potencia desarrolla los punteros es cuando se unen al concepto de memoriadinámica.Cuando se ejecuta un programa, el sistema operativo reserva una zona de memoria para el código

o instrucciones del programa y otra para las variables que se usan durante la ejecución. A menudoestas zonas son la misma zona, es lomo la pila, que se usa, entre otras cosas, para intercambiardatos entre funciones. El resto, la memoria que no se usa por nin que se llama memoria local.También hay otras zonas de memoria, cogún programa es lo que se conoce como "heap" omontón. Cuando nuestro programa use memoria dinámica, normalmente usará memoria delmontón, y no se llama así porque sea de peor calidad, sino porque suele haber realmente unmontón de memoria de este tipo.C++ dispone de dos operadores para acceder a la memoria dinámica, son "new" y "delete" .En C estas acciones se realizan mediante funciones de la librería estándar "stdio.h" que son maloc(Memory Alocation) y free.

Hay una regla de oro cuando se usa memoria dinámica, toda la memoria que se reserve durante elprograma hay que liberarla antes de salir del programa. No seguir esta regla es una actitud muyirresponsable, y en la mayor parte de los casos tiene consecuencias desastrosas. No se fíen de loque diga el compilador, de que estas variables se liberan solas al terminar el programa, no siemprees verdad. Veremos con mayor profundidad los operadores "new" y "delete" en otros capítulos, porahora veremos un ejemplo.Por ejemplo:

#include <iostream>using namespace std;int main() {int *a;char *b;

float *c;struct stPunto {float x,y; } *d;a = new int;b = new char;c = new float;d = new stPunto;*a = 10;*b = 'a';*c = 10.32;d->x = 12; d->y = 15;

cout << "a = " << *a << endl;cout << "b = " << *b << endl;cout << "c = " << *c << endl;cout << "d = (" << d->x << ", " << d->y << ")" << endl;delete a;delete b;delete c;delete d;cin.get();return 0; }




- 64 -

Y mucho cuidado!! Si pierdes un puntero a una variable reservada dinámicamente, no podrásliberarla.

Por ejemplo:int main(){

int *a;a = new int; // variable dinámica *a = 10;a = new int; // nueva variable dinámica,

// se pierde el puntero a la anterior*a = 20;delete a; // sólo liberamos la última reservada return 0; }

En este ejemplo vemos cómo es imposible liberar la primera reserva de memoria dinámica. Si no lanecesitábamos habría que liberarla antes de reservarla otra vez, y si la necesitamos, hay queguardar su dirección, por ejemplo con otro puntero.

10.10. Ejercicios1-) Escribir un programa con una función que calcule la longitud de una cadena de caracteres.El nombre de la función será LongitudCadena , debe devolver un "int", y como parámetro deentrada debe tener un puntero a "char".En "main" probar con distintos tipos de cadenas: arrays y punteros.2-) Escribir un programa con una función que busque un carácter determinado en una cadena.El nombre de la función será BuscaCaracter , debe devolver un "int" con la posición en que fueencontrado el carácter, si no se encontró volverá con -1.Los parámetros de entrada serán una cadena caracteres.3-) ¿De qué tipo es cada una de las siguientes variables?

a) int* a,b;• a puntero, b puntero• a puntero, b entero• a entero, b puntero• a entero, b entero

b) int *a,b;• a puntero, b puntero• a puntero, b entero• a entero, b puntero• a entero, b entero

c) int *a,*b;• a puntero, b puntero• a puntero, b entero• a entero, b puntero• a entero, b entero




- 65 -

d) int* a,*b;• a puntero, b puntero• a puntero, b puntero doble• a entero, b puntero• a entero, b puntero doble

4-) Considerando las siguientes declaraciones y sentencias:• int array[]={1,2,3,4,5,6};• int *puntero;• puntero = array;• puntero++;• *puntero=*puntero+6;• puntero=puntero+3;• puntero=punteropuntero[2];• int x=punteroarray;

a) ¿Cuál es el valor de x? Marcar la opción correcta.• 1• 2• 3• 4

b) ¿Cual es el valor de array[1]? Marcar la opción correcta.• 2• 4• 6• 8

5-) ¿Cuánta memoria ocupa un Puntero?6-) ¿La cantidad de memoria que ocupa el puntero depende del tipo de variable a la que apunta?

TALLER DE INFORMÁTICA CAPITULO 11. Estructuras

- 66 -

CAPITULO 11. ESTRUCTURAS.

11.1. Estructuras.Las estructuras son el segundo tipo de datos estructurados que veremos.

Las estructuras nos permiten agrupar varios datos, aunque sean de distinto tipo, que mantenganalgún tipo de relación, permitiendo manipularlos todos juntos, con un mismo identificador, o porseparado.Las estructuras son llamadas también muy a menudo registros, o en inglés "records". Y sonestructuras análogas en muchos aspectos a los registros de bases de datos. Y siguiendo la mismaanalogía, cada variable de una estructura se denomina a menudo campo, o "field".

Sintaxis:struct [<identificador>] { [<tipo> <nombre_variable>[,<nombre_variable>,...]];. } [<variable_estructura>[,<variable_estructura>,...];

El nombre de la estructura es un nombre opcional para referirse a la estructura.Las variables de estructura son variables declaradas del tipo de la estructura, y su inclusión tambiénes opcional. Sin bien, al menos uno de estos elementos debe existir, aunque ambos seanopcionales.En el interior de una estructura, entre las llaves, se pueden definir todos los elementos queconsideremos necesarios, del mismo modo que se declaran las variables.Las estructuras pueden referenciarse completas, usando su nombre, como hacemos con lasvariables que ya conocemos, y también se puede acceder a los elementos en el interior de laestructura usando el operador de selección (.), un punto.También pueden declararse más variables del tipo de estructura en cualquier parte del programa,de la siguiente forma:

[struct] <identificador> <variable_estructura>

[,<variable_estructura>...];

En C++ la palabra "struct" es opcional en la declaración de variables. En C es obligatorio usarla.

Por ejemplo:struct Persona {char Nombre[65];char Direccion[65];int AnyoNacimiento;} Fulanito;

Este ejemplo declara a Fulanito como una variable de tipo Persona. Para acceder al nombre deFulanito, por ejemplo para visualizarlo, usaremos la forma:

cout << Fulanito.Nombre;

IMPORTANTE:Se buscará que las definiciones de la Estructuras sean GLOBALES, pero las instanciasLOCALES .




- 67 -

11.2. Funciones en el interior de estructurasC++, al contrario que C, permite incluir funciones en el interior de las estructuras. Normalmenteestas funciones tienen la misión de manipular los datos incluidos en la estructura. Aunque esta característica se usa casi exclusivamente con las clases, como veremos más adelante,también puede usarse en las estructuras.

Dos funciones muy particulares son las de inicialización, o constructor, y el destructor. Veremos conmás detalle estas funciones cuando asociemos las estructuras y los punteros. El constructor es unafunción sin tipo de retorno y con el mismo nombre que la estructura. El destructor tiene la mismaforma, salvo que el nombre va precedido el operador "~".

Por ejemplo:Para ilustrar el uso de constructores:

Forma 1:struct Punto {int x, y;Punto() {x = 0; y = 0;} // Constructor} Punto1, Punto2;

Forma 2:struct Punto {int x, y;Punto(); // Declaración del constructor} Punto1, Punto2;

// Definición del constructor, fuera de la estructuraPunto::Punto() {x = 0;y = 0;}

Si no usáramos un constructor, los valores de x e y para Punto1 y Punto2 estarían indeterminados,contendrían la "basura" que hubiese en la memoria asignada a estas estructuras durante laejecución. Con las estructuras éste será el caso más habitual.

Para aquellos que usen un teclado español, el símbolo "~" se obtiene pulsando las teclas delteclado numérico 1, 2, 6, mientras se mantiene pulsada la tecla ALT, ([ALT]+126).También mediante la combinación [Atl Gr]+[4] (la tecla [4] de la zona de las letras, no del tecladonumérico).

Uso de espacios de trabajoEn C los espacios de trabajo reciben el nombre de “namespace” . Por defecto utilizamos el estándar(std) pero podemos definir tantos como sean necesarios.Supongamos que en un curso tenemos dos alumnos que se llaman Juan Perez, cuando debamosllamarlos ¿quién responderá?

- 68 -

Bueno eso es incierto, algo parecido sucede en el lenguaje C, donde se pueden definir tipos devariables personales.Sí, eso mismo podemos darle el nombre que queramos. Pero ¿qué sucedería si queremos crear untipo de datos y tenemos la mala suerte que dentro de una librería que usamos ese tipo de dato yaexiste?Es difícil saber si el nombre para el tipo de variables que queremos usar ya fue usado, en este caso

el compilador tiraría un error y deberíamos cambiar el nombre, para evitar esto se definen espaciosen los que se deben tener en cuenta determinados nombres. Sería algo parecido al ejemplo deJuan Perez.Esto se soluciona ubicando explícitamente a cada alumno en una comisión distinta.Solo con fines didácticos veremos un código en cual no compilaría pero la idea es destacar lareferencia a distintos espacios de nombres.

Por ejemplo:using namespace Ns1{ int x; }using namespace Ns2{ int x; }int main()

{cout << endl <<" Ingrese el valor de x para el espacio de nombre Ns1: ";cin >> Ns1:: x;cout << endl <<" Ingrese el valor de x para el espacio de nombre Ns2: ";cin >> Ns2:: x; }

Mencionar aquí, sólo a título de información, que el constructor no tiene por qué ser único. Sepueden incluir varios constructores, pero veremos esto mucho mejor y con más detalle cuandoveamos las clases.Usando constructores nos aseguramos los valores iniciales para los elementos de la estructura. Veremos que esto puede ser una gran ventaja, sobre todo cuando combinemos estructuras con

punteros, en capítulos posteriores.También podemos incluir otras funciones, que se declaran y definen como las funciones que yaconocemos, salvo que tienen restringido su ámbito al interior de la estructura.

Por ejemplo:#include <iostream>using namespace std;struct stPareja {int A, B;int LeeA() { return A;} // Devuelve el valor de A int LeeB() { return B;} // Devuelve el valor de B void GuardaA(int n) { A = n;} // Asigna un nuevo valor a A void GuardaB(int n) { B = n;} // Asigna un nuevo valor a B

} Par;int main(){ Par.GuardaA(15);Par.GuardaB(63);cout << Par.LeeA() << endl;cout << Par.LeeB() << endl;cin.get();return 0; }




- 69 -

En este ejemplo podemos ver cómo se define una estructura con dos campos enteros, y dosfunciones para modificar y leer sus valores. El ejemplo es muy simple, pero las funciones deguardar valores se pueden elaborar para que no permitan determinados valores, o para que haganalgún tratamiento de los datos.Por supuesto se pueden definir otras funciones y también constructores más elaborados ysobrecarga de operadores. Y en general, las estructuras admiten cualquiera de las características

de las clases, siendo en muchos aspectos equivalentes. Veremos estas características cuando estudiemos las clases, y recordaremos cómo aplicarlas a lasestructuras.

11.3. Inicialización de estructurasDe un modo parecido al que se inicializan los arrays, se pueden inicializar estructuras, tan sólo hayque tener cuidado con las estructuras anidadas.

Por ejemplo:struct A {int i;int j;

int k;};

struct B {int x;struct C {char c;char d;} y;int z;};

A ejemploA = {10, 20, 30};

B ejemploB = {10, {'a', 'b'}, 20};

Cada nueva estructura anidada deberá inicializarse usando la pareja correspondiente de llaves "{}",tantas veces como sea necesario.

11.4. Asignación de estructurasLa asignación de estructuras está permitida, pero sólo entre variables del ismo tipo de estructura,salvo que se usen constructores, y funciona como a intuición dice que debe hacerlo.

Por ejemplo:struct Punto {

int x, y;Punto() {x = 0; y = 0;}} Punto1, Punto2;int main(){ Punto1.x = 10;Punto1.y = 12;Punto2 = Punto1; }

- 70 -

La línea:Punto2 = Punto1;equivale a:Punto2.x = Punto1.x;Punto2.y = Punto1.y;

11.5. Arrays de estructurasLa combinación de las estructuras con los arrays proporciona una potente herramienta para elalmacenamiento y manipulación de datos.

Por ejemplo:struct Persona {char Nombre[65];char Direccion[65];int AnyoNacimiento;} Plantilla[200];

Vemos en este ejemplo lo fácil que podemos declarar el array Plantilla que contiene los datos

relativos a doscientas personas.

Podemos acceder a los datos de cada uno de ellos:cout << Plantilla[43].Direccion;

O asignar los datos de un elemento de la plantilla a otro:

Plantilla[0] = Plantilla[99];

Veamos un ejemplo de un Array de instancias 2 dimensiones o dicho de otra manera una matriz deinstancias de una Estructura.

#include <iostream>

using namespace std;struct prueba {int x; char nombre[11];};int main(){int i,j,k=1; prueba datos[3][3]; //Instacia de Estructura de 2 dimensiones. for ( i=0; i < 3; i++)

{for (j=0; j < 3; j++)

{datos[i][j].x=k;cout<< endl << "Ingrese Nombre: " << endl;cin.getline(datos[i][j].nombre,10); //Permite ingresar hasta 10

k++; } }

for (i=0; i < 3; i++){ for (j=0; j < 3; j++){cout << datos[i][j].x <<" "<< datos[i][j].nombre <<endl;} }

return 0; }




- 71 -

11.6. Estructuras anidadasTambién está permitido anidar estructuras, con lo cual se pueden conseguir superestructuras muyelaboradas.

Por ejemplo:

struct stDireccion {char Calle[64];int Portal;int Piso;char Puerta[3];char CodigoPostal[6];char Poblacion[32];};struct stPersona {struct stNombre {char Nombre[32];char Apellidos[64];} NombreCompleto;

stDireccion Direccion;char Telefono[10];};

En general, no es una práctica corriente definir estructuras dentro de estructuras, ya que resultantener un ámbito local, y para acceder a ellas se necesita hacer referencia a la estructura másexterna.Por ejemplo para declarar una variable del tipo stNombre hay que utilizar el operador de acceso(::):

stPersona::stNombre NombreAuxiliar;

Sin embargo para declarar una variable de tipo stDireccion basta con declararla:

stDireccion DireccionAuxiliar;

- 72 -

11.7. Operador "sizeof" con estructurasCuando se aplica el operador sizeof a una estructura, el tamaño obtenido no siempre coincide conel tamaño de la suma de sus campos.

Por ejemplo:#include <iostream>using namespace std;

struct A {int x;char a;int y;char b;};

struct B {int x;

int y;char a;char b;};

int main(){cout << "Tamaño de int: " << sizeof(int) << endl;cout << "Tamaño de char: " << sizeof(char) << endl;cout << "Tamaño de estructura A: " << sizeof(A) << endl;cout << "Tamaño de estructura B: " << sizeof(B) << endl;cin.get();return 0;

}

El resultado, usando Anjuta , es el siguiente:

Tamaño de int: 4Tamaño de char: 1Tamaño de estructura A: 16Tamaño de estructura B: 12

Si hacemos las cuentas, en ambos casos el tamaño de la estructura debería ser el mismo, es decir,4+4+1+1=10 bytes. Sin embargo en el caso de la estructura A el tamaño es 16 y en el de laestructura B es 12, ¿por qué?

La explicación es algo denominado alineación de bytes (byte-aling). Para mejorar el rendimiento delprocesador no se accede a todas las posiciones de memoria. En el caso de microprocesadores de32 bits (4 bytes), es mejor si sólo se accede a posiciones de memoria múltiplos de 4, y elcompilador intenta alinear las variables con esas posiciones.En el caso de variables "int" es fácil, ya que ocupan 4 bytes, pero con las variables "char" no, yaque sólo ocupan 1.Cuando se accede a datos de menos de 4 bytes la alineación no es tan importante. El rendimientose ve afectado sobre todo cuando hay que leer datos de cuatro bytes que no estén alineados.

- 73 -

En el caso de la estructura A hemos intercalado campos "int" con "char", de modo que el campo"int" "y", se alinea a la siguiente posición múltiplo de 4, dejando 3 posiciones libres después delcampo "a". Lo mismo pasa con el campo "b".

En el caso de la estructura B hemos agrupado los campos de tipo "char" al final de la estructura, demodo que se aprovecha mejor el espacio, y sólo se desperdician los dos bytes sobrantes despuésde "b".

11.8. Campos de bitsExiste otro tipo de estructuras que consiste en empaquetar los campos de la estructura en elinterior de enteros, usando bloques o conjuntos de bits para cada campo.Por ejemplo, una variable char contiene ocho bits, de modo que dentro de ella podremosalmacenar ocho campos de un bit, o cuatro de dos bits, o dos de tres y uno de dos, etc. En unavariable int de 16 bits podremos almacenar 16 bits, etc.Debemos usar siempre valores de enteros sin signo, ya que el signo se almacena en un bit delentero, el de mayor peso, y puede falsear los datos almacenados en la estructura.

Sintaxis:struct [<nombre de la estructura>] {unsigned <tipo_entero> <identificador>:<núm_de_bits>; } [<lista_variables>];

Hay algunas limitaciones, por ejemplo, un campo de bits no puede ocupar dos variables distintas,todos sus bits tienen que estar en el mismo valor entero.Por ejemplo:

struct mapaBits {unsigned char bit0:1;unsigned char bit1:1;unsigned char bit2:1;unsigned char bit3:1;unsigned char bit4:1;unsigned char bit5:1;unsigned char bit6:1;

unsigned char bit7:1;};struct mapaBits2 {unsigned short int campo1:3;unsigned short int campo2:4;unsigned short int campo3:2;unsigned short int campo4:1;unsigned short int campo5:6;};




- 74 -

struct mapaBits3 {unsigned char campo1:5;unsigned char campo2:5;};

En el primer caso se divide un valor char sin signo en ocho campos de un bit cada uno:

En el segundo caso dividimos un valor entero sin signo de dieciséis bits en cinco campos dedistintas longitudes:

Los valores del campo5 estarán limitados entre 0 y 63, que son los números que se puedencodificar con seis bits. Del mismo modo, el campo4 sólo puede valer 0 ó 1, etc.

En este ejemplo vemos que como no es posible empaquetar el campo2 dentro del mismo char queel campo1, se añade un segundo valor char, y se dejan sin usar los bits sobrantes.También es posible combinar campos de bits con campos normales.

Por ejemplo:struct mapaBits2 {int numero;unsigned short int campo1:3;unsigned short int campo2:4;unsigned short int campo3:2;unsigned short int campo4:1;unsigned short int campo5:6;float n;};

Los campos de bits se tratan en general igual que cualquier otro de los campos de una estructura.Se les puede asignar valores (dentro del rango que admitan), pueden usarse en condicionales,imprimirse, etc.

- 75 -

#include <iostream>#include <cstdlib>using namespace std;struct mapaBits2 {unsigned short int campo1:3;unsigned short int campo2:4;

unsigned short int campo3:2;unsigned short int campo4:1;unsigned short int campo5:6;};int main(){mapaBits2 x;x.campo2 = 12;x.campo4 = 1;cout << x.campo2 << endl;cout << x.campo4 << endl;cin.get();return 0;

}

No es normal usar estas estructuras en programas, salvo cuando se relacionan con ciertosdispositivos físicos, por ejemplo, para configurar un puerto serie en MS-DOS se usa una estructuraempaquetada en un unsigned char, que indica los bits de datos, de parada, la paridad, etc, esdecir, todos los parámetros del puerto. En general, para programas que no requieran estasestructuras, es mejor usar estructuras normales, ya que son mucho más rápidas.Otro motivo que puede decidirnos por estas estructuras es el ahorro de espacio, ya sea en disco oen memoria. Si conocemos los límites de los campos que queremos almacenar, y podemosempaquetarlos en estructuras de mapas de bits podemos ahorrar mucho espacio.

11.9. Punteros a estructurasLos punteros también pueden apuntar a estructuras y también pueden existir miembros de laestructura que sean punteros.En este caso, para referirse a cada elemento de la estructura se usa el operador (->), en lugar del(.).Suponiendo que el nombre del puntero es punt y el miembro de una estructura es dia y punt estainicializado a una instancia de esa estructura se podría acceder al miembro:

punt->dia

Por ejemplo:struct stComplejo {

float real, imaginario;} Complejo[10];stComplejo *p; p = Complejo; /* Equivale a p = &Complejo[0]; */ p++; /* p == &Complejo[1] */

En este caso, al incrementar p avanzaremos las posiciones de memoria necesarias para apuntar ala siguiente instancia o conjuntos de variables del array de estructura llamado "Complejo" o si.Es decir avanzaremos sizeof(stComplejo) bytes.

- 76 -

Por ejemplo:#include <iostream>using namespace std;struct stEstructura {int a, b; }; //La Estructura es Global !!

int main() {stEstrucutra estructura, *e; //Instancias Local !!estructura.a = 10; / /accedo con el operador punto. estructura.b = 32;e = &estructura;cout << "variable" << endl;cout << e->a << endl; //accedo con el operado flecha -> cout << e->b << endl;cout << "puntero" << endl;cout << estructura.a << endl;cout << estructura.b << endl;cin.get();return 0;

}

11.9.1. Ejemplo Gestion dinámica de Memoria y Lista Enlazada simple

Existen varias aplicaciones derivadas de incorporar un puntero como miembro de una estructura.En particular mucho mas cuando el puntero apunta a una estructura del mismo tipo!! esto crea loque se conocen como listas Enlazadas Simples, Dobles , Circulares.. etc. Veamos como son/*Crear una lista simple de una cantidad de instancias a determinar en tiempo deejecución o en forma dinámica de una estructura del siguiente tipo:struct dato {int tel; int legajo; struct dato *pdato ;};*///Crear una lista simple de 5 instancias

#include <iostream>using namespace std;struct dato { int tel; int legajo; struct dato *pdato; };int main(){int i,cantidad_instancias;struct dato *punterodato ;cout<< " Ingrese un nro entero para definir la cantidad deinstancias"<< endl;cin >> cantidad_instancias; punterodato= new struct dato[cantidad_instancias];for (i=0; i< cantidad_instancias ; i++){cout << " Telefono: " << endl;cin >> (punterodato+i)>tel;cout << " Legajo : " << endl;cin >> (punterodato+i)>legajo;if (i==(cantidad_instancias1))( punterodato+i)> pdato=0;

- 77 -

else (punterodato+i)> pdato=(punterodato+i+1); } /*for (i=0; i< cantidad_instancias ; i++){cout << punterodato>

tel;cout << punterodato>legajo; punterodato++; }*/do{cout << punterodato << endl;cout << punterodato>tel<< endl;cout << punterodato>legajo <<endl;cout << punterodato>

pdato << endl;cout << endl << endl; punterodato++; } while (((punterodato1) > pdato)!=0);return 0; }

Este tipo de Lista se puede recorrer en un solo sentido desde el principio hacia el fin. Vemos otraque no tiene este inconveniente.

11.9.2. Ejemplo Gestión dinámica de Memoria y Lista Enlazada DobleCargar una estructura doblemente enlazada del siguiente tipo:

struct dato {int tel; int legajo; struct dato *pprox; struct dato *pant;};

#include <iostream>using namespace std; struct dato { int tel; int legajo; struct dato *pprox; struct dato *pant; };int main(){int i,cantidad_instancias;struct dato *punterodato ;cout<< " Ingrese un nro entero para definir la cantidad deinstancias"<< endl;cin >> cantidad_instancias; punterodato= new struct dato[cantidad_instancias];for (i=0; i< cantidad_instancias ; i++){cout << " Telefono: " << endl;cin >> (punterodato+i)>tel;cout << " Legajo : " << endl;

- 78 -

cin >> (punterodato+i)>legajo;if (i==0) (punterodato+i)> pant=0;else (punterodato+i)> pant=(punterodato+i1);

if (i==(cantidad_instancias1))( punterodato+i)> pprox=0;else (punterodato+i)> pprox=(punterodato+i+1); } do{cout << " Direccion de esta instacia : ";cout << punterodato << endl;cout << " Telefono : " << punterodato>tel<< endl;cout << " Legajo : ";cout << punterodato>legajo <<endl;

cout << " Direccion de la insta. anterior: ";cout << punterodato> pant<< endl;cout << " Direccion de la insta. proxima: ";cout << punterodato> pprox<< endl;cout << endl << endl; punterodato++; } while (((punterodato1)> pprox)!=0);return 0; }

Este tipo de Lista se puede recorrer en ambos sentidos.

11.10. EjerciciosCarga y muestra de Estructura de una sola Instancia1-) Realizar un Programa en C que cargue una Estructura llamada Alumno de una sola instancia denombre “Electronica” del siguiente tipo: Nombre (char de 10 elementos), edad (entero), fecha denacimiento(arreglo de 3 enteros).Luego de cargar esta estructura desde teclado deberá mostrarla.

Carga y muestra de Estructura de 5 instancias2-) Realizar un Programa en C que cargue una Estructura llamada Alumno de 5 instancias denombre “Electronica” del siguiente tipo: Nombre (char de 10 elementos), edad (entero), fecha de

nacimiento (arreglo de 3 enteros).Luego de cargar esta estructura desde teclado deberá mostrarla.

Carga y muestra de Estructura de 5 instancias usando puntero3-) Realizar un Programa en C que cargue una Estructura llamada Alumno de 5 instancias denombre “Electronica” del siguiente tipo: Nombre (char de 10 elementos), edad (entero), fecha denacimiento(arreglo de 3 enteros).Luego de cargar esta estructura desde teclado deberá mostrarla. La carga y la muestra deberánrealizarse usando punteros.




- 79 -

Carga y muestra de Estructura de una sola instancia usando puntero a la estructura y funciones.4-) Realizar un Programa en C que cargue una Estructura llamada Alumno de una sola instancia denombre “Electronica” del siguiente tipo: Nombre (char de 10 elementos), edad (entero), fecha denacimiento(arreglo de 3 enteros). La carga de la Instancia se deberá hacer en una función llamadacarga que recibe como argumento un puntero a la Estructura. La muestra de la Instancia se deberáhacer en una función llamada muestra que recibe como argumento un puntero a la Estructura.

Carga y muestra de Estructura de 5 instancias usando puntero a la estructura y funciones.5-) idem anterior pero para 5 instancias.

6-) Escribir un programa que almacene en un array los nombres y números de teléfono de 10personas. El programa debe leer los datos introducidos por el usuario y guardarlos en memoria.Después debe ser capaz de buscar el nombre correspondiente a un número de teléfono y elteléfono correspondiente a una persona. Ambas opciones deben se accesibles a través de un menú,así como la opción de salir del programa. El menú debe tener esta forma, más o menos:

a) Buscar por nombreb) Buscar por número de teléfonoc) SalirPulsa una opción:

Nota: No olvides que para comparar cadenas se debe usar una función, no el operador ==.

7-) Para almacenar fechas podemos crear una estructura con tres campos: ano, mes y día. Losdías pueden tomar valores entre 1 y 31, los meses de 1 a 12 y los años, dependiendo de laaplicación, pueden requerir distintos rangos de valores. Para este ejemplo consideraremossuficientes 128 años, entre 1960 y 2087. En ese caso el año se obtiene sumando 1960 al valor deaño. El año 2003 se almacena como 43.Usando estructuras, y ajustando los tipos de los campos, necesitamos un char para día, un charpara mes y otro para año.Diseñar una estructura análoga, llamada "fecha", pero usando campos de bits. Usar sólo un enterocorto sin signo (unsigned short), es decir, un entero de 16 bits. Los nombres de los campos serán:dia, mes y anno.8-) Basándose en la estructura de bits del ejercicio anterior, escribir una función para mostrarfechas: void Mostrar(fecha);. El formato debe ser:"dd de mmmmmm de aaaa", donde dd es el día, mmmmmm el mes con letras, y aaaa el año. Usarun array para almacenar los nombres de los meses.9-) Basándose en la estructura de bits del ejercicio anterior, escribir una función bool ValidarFecha(fecha);, que verifique si la fecha entregada como parámetro es válida. El mes tieneque estar en el rango de 1 a 12, dependiendo del mes y del año, el día debe estar entre 1 y 28, 29,30 ó 31.El año siempre será válido, ya que debe estar en el rango de 0 a 127.Para validar los días usaremos un array int DiasMes[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};. Para el caso de que el mes sea febrero, crearemos otra función para calcular si un año es ono bisiesto: bool Bisiesto(int) ; Los años bisiestos son los divisibles entre 4, al menos en el rango de1960 a 2087 se cumple.

Nota: los años bisiestos son cada cuatro años, pero no cada 100, aunque sí cada 400. Por ejemplo,el año 2000, es múltiplo de 4, por lo tanto debería haber sido bisiesto, pero también es múltiplo de100, por lo tanto no debería serlo; aunque, como también es múltiplo de 400, finalmente lo fue.10-) Seguimos con el tema de las fechas. Ahora escribir dos funciones más.La primera debe responder a este prototipo: int CompararFechas(fecha, fecha);. Debe comparar lasdos fechas suministradas y devolver 1 si la primera es mayor, -1 si la segunda es mayor y 0 si soniguales. La otra función responderá a este prototipo: int Diferencia(fecha, suministradas.




- 80 -

11-) Supongamos la declaración de la siguiente estructura:struct ejemplo1 {unsigned char c1:7;unsigned char c2:6;unsigned char c3:3;unsigned char c4:4;

} ;: a) ¿Cuántos bytes ocupa esta estructura? Marcar la opción correcta.• 1• 2• 3• 4

b) ¿Y si en lugar de un "unsigned char" usamos un "unsigned short" de 16 bits?• 1• 2• 3• 4

c) ¿Y si en lugar de un "unsigned short" usamos un "unsigned int" de 32 bits?• 1• 2• 3• 4

12-) Tenemos la siguiente estructura:struct A {struct B {int x,y;float r; } campoB;float s;struct {int z;float t; } campoC; } E;

Si tenemos la variable "E", indicar la forma correcta de acceder a las siguientes variables:a) x

• A.B.x• E.campoB.x• E.x• E.b.x

b) s• A.s• E.s• E.a.s

c) t• A.t• E.t• A.campoC.t• E.campoC.t




- 81 -

13-) Considerando la siguiente declaración:struct A {struct {int x;int y; } campoB;

} *estructuraA;

a) ¿Cómo se referenciaría el campo x de la estructura A?• Estructura A.x• estructura A.campoB.x• estructura A.campoB->x• estructura A->campoB.x

TALLER DE INFORMÁTICA CAPITULO 12. Más operadores

- 82 -

CAPITULO 12. MÁS OPERADORES. Veremos ahora más detalladamente algunos operadores que ya hemos mencionado, y algunosnuevos.

12.1. Operadores de Referencia (&) e Indirección (*)El operador de referencia (&) nos devuelve la dirección de memoria del operando.

Sintaxis:&<expresión simple>

El operador de indirección (*) considera a su operando como una dirección y devuelve sucontenido.

Sintaxis:*<puntero>

Por ejemplo:int A, *pA; pA=&A;Para este caso pA es un puntero, pero en el caso de que tengamos:int a, b;b=&a;

Vemos que “b” NO ES UN PUNTERO, en este caso se dice que b es un “alias” de o variablereferenciada, es decir es la misma variable con dos nombre distinto.

12.2. Operadores . y ->El operador de selección (.) permite acceder a variables o campos dentro de una estructura.

Sintaxis:<variable_estructura>.<nombre_de_variable>

El operador de selección de variables o campos se utiliza para estructuras referenciadas conpunteros. (->)

Sintaxis:<puntero_a_estructura>-><nombre_de_variable>

12.3. Operador de preprocesadorEl operador "#" sirve para dar órdenes o directivas al compilador. Por el momento este tema no

forma parte del Programa de la Materia.

12.4. Operadores de manejo de memoria "new" y "delete" Veremos su uso en el capítulo de punteros II y en mayor profundidad en el capítulo de clases y enoperadores sobrecargados.

- 83 -

12.4.1. Operador new

El operador new sirve para reservar memoria dinámica.

Sintaxis:[::]new [<emplazamiento>] <tipo> [(<inicialización>)][::]new [<emplazamiento>] (<tipo>) [(<inicialización>)][::]new [<emplazamiento>] <tipo> [ <número_elementos> ][::]new [<emplazamiento>] (<tipo>) [ <número_elementos> ]

El operador opcional :: está relacionado con la sobrecarga de operadores, de momento no lousaremos. Lo mismo se aplica a emplazamiento.La inicialización, si aparece, se usará para asignar valores iniciales a la memoria reservada con new,pero no puede ser usada con arrays.Las formas tercera y cuarta se usan para reservar memoria para arrays dinámicos. La memoriareservada con new será válida hasta que se libere con delete o hasta el fin del programa, aunquees aconsejable liberar siempre la memoria reservada con new usando delete. Se considera unapráctica muy sospechosa no hacerlo.

Si la reserva de memoria no tuvo éxito, new devuelve un puntero nulo, NULL.

12.4.1.1 Ejemplo Gestion dinámica de Memoria y Lista Enlazada Doble

Cargar una estructura doblemente enlazada del siguiente tipo:struct dato {int tel; int legajo; struct dato *pprox; struct dato *pant;}

recorrerla por teclado de manera que con P o p se pase a la proxima instancia y con A o a se pasea la instancia anterior , con f o F se sale.

#include <iostream>using namespace std;void menu();void recorre ( struct dato *p);

struct dato {int tel; int legajo; struct dato *pprox; struct dato *pant;};int main(){int i,cantidad_instancias;struct dato *punterodato ;cout<< " Ingrese un nro entero para definir la cantidad deinstancias"<< endl; cin >> cantidad_instancias; // Solicito al sistema el espacio en memoria punterodato= new struct dato[cantidad_instancias];for (i=0; i< cantidad_instancias ; i++){cout << " Telefono: " << endl;

cin >> (punterodato+i)>tel;cout << " Legajo : " << endl;cin >> (punterodato+i)>legajo;if(i==0) (punterodato+i)> pant=0;else (punterodato+i)> pant=(punterodato+i1);

- 84 -

if(i==(cantidad_instancias1))( punterodato+i)> pprox=0;else (punterodato+i)> pprox=(punterodato+i+1); }

menu();recorre (punterodato);return 0; }void menu(){cout << " Para recorrer las instacias presione "<< endl;cout << " presione P > proxima A>anterior F >Finaliza"; }void recorre(struct dato *p)

{ char opc;do{cin>> opc;switch (opc){case 'a':case 'A':p=p> pant;cout << " Direccion de esta instacia : ";cout <tel<< endl;cout << " Legajo : ";cout <legajo <<endl;cout << " Direccion de la insta. anterior: ";cout < pant<< endl;cout << " Direccion de la insta. proxima: ";cout < pprox<< endl;cout << endl << endl;break;case 'p':case 'P':p=p> pprox;cout << " Direccion de esta instacia : ";cout <tel<< endl;

cout << " Legajo : ";cout <legajo <<endl;cout << " Direccion de la insta. anterior: ";cout < pant<< endl;cout << " Direccion de la insta. proxima: ";cout < pprox<< endl;cout << endl << endl;break;case 'f':

- 85 -

case 'F':cout << "Chau!";break;defalut: cout << " Opcion no valida";break; }}while ( opc!='f' || opc!= 'F');}

12.4.2-Operador deleteEl operador delete se usa para liberar la memoria dinámica reservada con new.Sintaxis:

[::]delete [<expresión>][::]delete [<expresión>]

La expresión será normalmente un puntero, el operador delete[] se usa para liberar memoria dearrays dinámicas. Es importante liberar siempre usando delete la memoria reservada con new.Existe el peligro de pérdida de memoria si se ignora esta regla. Cuando se usa el operador deletecon un puntero nulo, no se realiza ninguna acción. Esto permite usar el operador delete conpunteros sin necesidad de preguntar si es nulo antes.

Los operadores new y delete son propios de C++. En C se usan las funciones malloc y free parareservar y liberar memoria dinámica y liberar un puntero nulo con free suele tener consecuenciasdesastrosas.

Por ejemplo:int main() {char *c;int *i = NULL;float **f;int n;

c = new char[123]; // Cadena de 122 más el nulo: f = new float *[10]; (1) / / Array de 10 punteros a flot a.

// Cada elemento del array es un array de 10 floatfor(n = 0; n < 10; n++) f[n] = new float[10]; (2) // f es un array de 10*10 f[0][0] = 10.32;f[9][9] = 21.39;c[0] = 'a';c[1] = 0;for(n = 0; n < 10; n++) delete[] f[n]; // liberar memoria dinámicadelete[] f;delete[] c;delete i;return 0; }

f es un puntero que apunta a un puntero que a su vez apunta a un float. Un puntero puedeapuntar a cualquier tipo de variable, incluidos los propios punteros. Este ejemplo nos permite creararrays dinámicos de dos dimensiones. La línea (1) crea un array de 10 punteros a float. La (2) crea10 arrays de floats. El comportamiento final de f es el mismo que si lo hubiéramos declarado como:float f[10][10];

TALLER DE INFORMÁTICA CAPITULO 13. Pasaje de valores a funciones

- 86 -

CAPITULO 13. PASAJE DE VALORES A FUNCIONES.

13.1. Parámetros por valor y parámetros por referencia.Dediquemos algo más de tiempo a las funciones.

Hasta ahora siempre hemos declarado los parámetros de nuestras funciones del mismo modo. Sinembargo, éste no es el único modo que existe para pasar parámetros. La forma en que hemosdeclarado y pasado los parámetros de las funciones hasta ahora es la que normalmente se conocecomo "por valor". Esto quiere decir que cuando el control pasa a la función, los valores de losparámetros en la llamada se copian a "variables" locales de la función, estas "variables" son dehecho los propios parámetros, pero ¿como hago si realmente queremos que los valores pasados semodifiquen?, la respuesta a esto es pasar los valores por referencia.

Por ejemplo:#include <iostream>using namespace std;int extremo_intervalo(int menor, int mayor);

int main() {int a, b; /*a y b locales de main */ cout << endl << "Ingrese el extremo de un intervalo: ";cin >> a;cout << endl << "Ingrese el extremo de un intervalo: ";cin >> b;cout << "a,b valen ->" << a << ", " << b << endl;cout << "llamo a la funcion control pasando a y b y retorna: ";if (extremo_intervalo(a, b)) cout << "Intercambiados !!";else cout << "NO Intercambiados !!";cout << endl; /* llamo a la función */ cout << "a,b siguen valiendo ->" << a << ", " << b << endl;return 0;

}/* Esta función controla que el extermo inferior del intervalo sea menor oigual que el extremo mayor */int extremo_intervalo(int menor, int mayor){int tmp;if( menor <= mayor)return 0; /* retornado 0 no intercambia */ else{tmp=menor;menor=mayor; /*intercambio los valores*/ mayor=tmp;}return 1; /* retorna 1 si intercambia */

}

Veamos como pasar valores a funciones pero que sí puedan modificarlos.

- 87 -

13.1.1. Referencias a variables

Las referencias sirven para definir "alias" o nombres alternativos para una misma variable.Para ello se usa el operador de referencia (&).

Por ejemplo:&a

Aquí estaríamos haciendo referencia a la direción de memoria de la variable a, esta es la mismadentro y fuera de cualquier función, aunque el nombre utilizado sea cualquiera.

Sintaxis:<tipo> &<alias> = <variable de referencia><tipo> &<alias>

La primera forma es la que se usa para declarar variables de referencia, la asignación es obligatoriaya que no pueden definirse referencias indeterminadas. La segunda forma es la que se usa paradefinir parámetros por referencia en funciones, en las que las asignaciones son implícitas.

Por ejemplo :#include <iostream>using namespace std;int main() {int a; /* defino una variable */int &r = a; /* aca vemos que la dirección de la variable r es igual a la

de la varaible a => son lo mismo!! pero con otro nombre */a = 10; /* le doy un valor a a */ cout << " a vale ="<< a << endl;cout << " el valor de de r es ="<< r << endl; /*muestro el valor de r */ cin.get();return 0;

}

En este ejemplo las variables a y r se refieren al mismo objeto, cualquier cambio en una de ellas seproduce en ambas. Para todos los efectos, son la misma variable.

13.2. Paso de parámetros por referenciaSi queremos que los cambios realizados en los parámetros dentro de la función se conserven alretornar de la llamada, deberemos pasarlos por referencia. Esto se hace declarando los parámetrosde la función como referencias a variables.

Por ejemplo:#include <iostream>using namespace std;int extremo_intervalo(int & menor, int & mayor); /* ver que existe & */int main() {int a, b; /*a y b locales de main */cout << endl << "Ingreso el extremo de un intervalo: ";cin >> a;cout << endl << "Ingreso el otro extremo de un intervalo: ";cin >> b;cout << "a,b valen ->" << a << ", " << b << endl;

- 88 -

cout << "llamo a la funcion extremo_intervalo pasando a, b y retorna: ";if (extremo_intervalo(a,b)) cout << "Intercambiados !!";else cout << "NO Intercambiados !!";cout << endl; /* llamo a la función */ cout << "a,b valen ->" << a << ", " << b << endl;return 0;

}/* esta función controla que el extermo inferior del intervalo sea menor o igualque el extremo mayor */int extremo_intervalo(int &menor, int &mayor) /*recibe la dirección de lasvariables */{int tmp;if( menor <= mayor) return 0; /* retornado 0 no intercambia */ else {tmp=menor;menor=mayor; /*intercambio los valores*/ mayor=tmp;}return 1; /* retorna 1 si intercambia */

}

En este caso, las variables "a" y "b" tendrán valores distintos después de llamar a la función.Cualquier cambio que realicemos en los parámetros dentro de la función, se hará también en lasvariables referenciadas.

No podemos hacer llamadas a funciones con referencia a parámetros constantes.

Por ejemplo:int extremo_intervalo(int & menor, int & mayor); /* prototipo */extremo_intervalo(10 ,20 ); /* ERROR !!! MAL !!! */

- 89 -

13.3. Punteros como parámetros de funcionesCuando pasamos un puntero como parámetro por valor de una función pasa lo mismo que con lasvariables.Dentro de la función trabajamos con una copia del puntero. Sin embargo, el objeto apuntado por el

puntero sí será el mismo, los cambios que hagamos en los objetos apuntados por el puntero seconservarán al abandonar la función, pero no será así con los cambios que hagamos al propiopuntero.

Por ejemplo:#include <iostream>using namespace std;void funcion(int *q);int main() {int a;int *p;a = 100; p = &a; // Llamamos a funcion con un puntero funcion(p);

cout << "Variable a: " << a << endl;cout << "Variable *p: " << *p << endl; // Llamada a funcion con la dirección

de "a" (constante) funcion(&a); /*Sería Equivalente poner funcion(p) */cout << "Variable a: " << a << endl;cout << "Variable *p: " << *p << endl;cin.get();return 0; }void funcion(int *q) {// Cambiamos el valor de la variable apuntada por el puntero*q += 50;q++; /* vemos que cambio el valor de q, pero no tiene efecto */

}

Dentro de la función se modifica el valor apuntado por el puntero, y los cambios permanecen alabandonar la función. Sin embargo, los cambios en el propio puntero son locales, y no seconservan al regresar. Con este tipo de parámetro para función pasamos el puntero por valor.¿Y cómo haríamos para pasar un puntero por referencia?:

void funcion(int* &q); /*notar que no está * si no & !!*/

El operador de referencia siempre se pone junto al nombre de la variable.

- 90 -

13.4. Funciones que devuelven referenciasComo mencionamos, para devolver referencias desde una función, basta con declarar el valor deretorno como una referencia.

Sintaxis:<tipo> &<identificador_función>(<lista_parámetros>); /* notar que no está * si no & !! */

Esto nos permite trabajar con los elementos que nos pasan no con una copia.

Por ejemplo://La función mayor recibe un puntero a un array y dos indices para// apuntar a una par de elementos del arreglo y retorna el mayor valor// mas uno.#include <iostream>using namespace std;int & mayor(int * , int , int); /* Prototipo de función */int main()

{int array [10] = {1, -3, 2, -1, 4, 5, 6, -7, 8, 9},a,b;cout << "Ingrese un indice del vector enter 0 y 9" << endl;cin >>a;cout << "Ingrese un otro indice del vectot enter 0 y 9" << endl;cin >>b;cout << "El mayor valor es : "<< mayor( array, a,b ) << endl;cin.get();return 0; }int & mayor(int *vector , int y, int x){return (++((vector[x]>=vector[y])?vector[x]:vector[y]));

}

Esta es una potente herramienta de la que disponemos, aunque ahora no se nos ocurra ningunaaplicación interesante.

- 91 -

13.5. Arrays como parámetros de funcionesCuando pasamos un array como parámetro en realidad estamos pasando un puntero al primerelemento del array, así que las modificaciones que hagamos en los elementos del array dentro dela función serán validos al retornar.

Por ejemplo:#include <iostream>using namespace std;#define TamanioArray 10#include <iostream>using namespace std;int BuscaMenor(int x[]); //prototipo de la funciónint main(){int arreglo[10];for (int i=0; i < 10; i++){

cout << endl << "Ingrese un numero : " << endl;cin >> arreglo[i];cout << "El menor valor es: " << BuscaMenor(arreglo)<< endl;

}return 0; }int BuscaMenor(int x[]) //definción de la función {int menor=x[0]; // asigno como el menor al 1er elemento del array for (int i=0; i < 10; i++)if(x[i]< menor) menor=x[i];return menor; }

En este caso el array es de una dimensión, sin embargo, si sólo pasamos el nombre del array demás de una dimensión no podremos acceder a los elementos del array mediante subíndices, ya quela función no tendrá información sobre el tamaño de cada dimensión.Para tener acceso a arrays de más de una dimensión dentro de la función se debe declarar elparámetro como un array.

#include <iostream>using namespace std;#define N 3#define M 3void funcion(int [][M]);

int main () {int Tabla[N][M]; // arreglo local Tabla;for (int i=0; i < N; i++)for (int j=0; j<M ; j++){cout << "Ingrese un valor : " ;cin >> Tabla[i][j]; }funcion(Tabla); //llamo a la funcionfor (int i=0; i < N; i++)for (int j=0; j<M ; j++)cout << Tabla[i][j] <<" ";

return 0; }//Esta funcion solo cambia el valor de un elemento del arreglo// pasado como referenciavoid funcion(int arreglolocal[][M]){

cout << "Ingrese un valor para cambiar el valor dearreglolocal[1][1]" << endl;cin >> arreglolocal [1][1] ; }

Las estructuras también pueden ser pasadas por valor y por referencia.Las reglas se les aplican igual que a los tipos fundamentales: las estructuras pasadas por valor noconservarán sus cambios al retornar de la función. Las estructuras pasadas por referenciaconservarán los cambios que se les hagan al retornar de la función. Por el momento no

profundizaremos en esto.

Apunte de lenguaje de programacion

Documents

Transcript of Apunte de lenguaje de programacion