Manual básico de Programación en C++

Transcripción

1 UNIVERSIDAD CENTRAL DE VENEZUELA FACULTAD DE CIENCIAS ESCUELA DE COMPUTACIÓN Materia: ESTRUCTURA DEL COMPUTADOR Manual básico de Programación en C++ Selección: DZ

2 Índice (RECOPILACION I) Diferencias entre C y C++ (1) Programación orientada a objeto POO ENCAPSULACIÓN, POLIMORFISMO, HERENCIA Representación de datos en lenguaje C/C++ (2) Primer programa en C++ Declaraciones en C++: (2) Como se declaran variables en C Como se declaran constantes en C Reglas de alcance de una variable (3) signen, unsigned, short, long Tipo de datos 1 (TDD) Calificadores de tipo signen, unsigned, short, long Operador de resolución de alcance unario (4) (POO) Homonimia de funciones (5) Comentarios en C/C++ Secuencias de escape en C++ Estructuras condicionales en C (6) Formas básicas IF-ELSE-ELSE IF Sentencia CONTINUE, Estructura SWITCH Como hacer Ciclos en C++ (8) Tipos de ciclos en C++ Flujo de entrada/salida de C++ (10) Declaración de archivo de cabecera y su relación con las Funciones a usar en código fuente Uso de las sentencias con printf y scanf en C++ Especificadores de formato Uso de los apuntadores en C 3 (11) Operadores de Indirección y Dirección & y * Instrucción estática->consola: (12) Ideal para DEV-C++ Cómo crear nuevos tipos de datos en C++ Directivas del Preprocesador Typedef, #include (13) Arreglos unidimensionales (Vectores) Llamadas a funciones con arreglos (15) Arreglos multidimensionales (Matrices) Registros (17) Registros y funciones (19)

3 Arreglos de registros (21) Definición de tipos (Typedef) Archivos (22) Apertura de archivos Modo texto Modo binario Cierre de registros Escritura y lectura de registros: Un carácter Un número entero Una cadena de caracteres Con formato (CDT) Registros (material adicional) (28) Otras funciones para archivos Detección de final de archivo Prototipos de función y verificación de tipo de dato (29) Operador de resolución de alcance unario Cómo llamar funciones: parámetros por valor y parámetros por referencia. (RECOPILACION II) Resumen sobre las librerías de C++ (31) Las clases estándar de C++ para entrada/salida Declaración, apertura y cierre de canales para archivo Modo Descripción Como crear clases en C/C++ (32) Control de acceso a miembros (CDA) (33) Archivos de cabecera Declaración de las funciones (34) Paso de parámetros a una función Funciones constructoras (35) Función destructora (36) Cuando son llamados los destructores y constructores? Asignación por omisión en copia a nivel de miembro en C Funciones en línea Verificación de tipos en C++ (37) Cómo poner en práctica un TDA con una clase? Un código fuente en C++ (40) Como leer registros Pase de parámetros por referencia Variable booleana en un condicional Nuevo tipo interesante de arreglo en c Impresión de arreglo Librerías 9 de C++ (41) Librería stdio.h printf, scanf,puts,gets,fopen,fclose,fprintf, fgets Librería tdlib.h atof, atoi, itoa, exit Librería conio.h

4 clrscr,clreol,gotoxy,textcolor,textbackground,wherex,wherey,getch,getche 9 Las funciones de las librerias de C++ dependen del compilador que se este usando lo recomendable es no usar funciones que otros compiladores no reconoceran si el programa es para otros. Por ejemplo el void detalle cumple la funcion de gotoxy() Librería string.h strlen, strcpy, strcat, strcmp Funciones interesantes fflush(stdin),sizeof,cprintf,kbhit,random,randomize,system Conversión de tipos en C++ (CDT) (44) Excepciones en C++ (46) Operaciones con Objetos en C++ (47) ASIGNACIÓN DE OBJETOS ARRAY DE OBJETOS (48) Unidimensional Bidimensional DECLARACIÓN, INICIALIZACIÓN PASO DE OBJETOS A FUNCIONES: (50) OBJETOS DEVUELTOS POR FUCIONES (51) PUNTEROS A OBJETOS (52) Funciones Constructoras y Destructoras (53) CONSTRUCTORES CON PARAMETROS (56) Sobrecarga de Funciones y Operadores Prioridad de operadores en C (ver simplificada) (62) Funciones inline y Automáticas 2 (63) Utilización de Estructuras como Clases 2 (64) this, new y delete 2 (66) Referencias 2 (70) Herencia 2 (71) Herencia múltiple 2 (73) Funciones Virtuales 2 (76) Funciones Amigas 2 (77) Tipo de dato referencia 2 (79) Apuntadores en C, Por qué son Importantes los Apuntadores?, Operadores de Indirección y Dirección, Advertencia sobre C, La Aritmética de Apuntadores, Apuntadores a Funciones, Arreglos en C, Por qué Usar los Arreglos?, La Declaración de un Arreglo, Breve resumen sobre los arrays, Arreglos y Apuntadores Apuntadores a Funciones (83) Punteros a estructuras (88) Punteros a objetos constantes Punteros a void (89)

5 Los operadores NEW Y DELETE (90) SOBRE ENUMERACIONES, ESTRUCTURAS Y UNIONES EN C++ ENUMERACIONES (91) ESTRUCTURAS DE ALMACENAMIENTO UNIONES (92) CADENAS EN C++ (93) MAS SOBRE FUNCIONES EN C++ Definición de funciones (94) Argumentos por omisión en funciones Más sobre funciones en línea (inline) (95) Sobrecarga de funciones (96) Mas sobre el modificador <const> (97) Paso de parámetros a funciones 1. Por valor 2. Por dirección 3. Por referencia Paso de arrays en C (98) Tamaño de un TDD (El operador: sizeof) (100) La sentencia nula en C Prioridad y asociatividad de operadores en C (ver completa) (101)

6 MÁS SOBRE ENTRADAS Y SALIDAS BÁSICAS EN C Salida Uso de flujos para salida de caracteres. (102) Entrada (103) Manipuladores de C Palabras reservadas de C (ver completa) (105) Laboratorio 4 #1 de C++ UCV (106) Laboratorio 4 #2 de C++ UCV (112) Sentencias de salto (120) Sentencias break, continue, goto SOBRE ALGUNOS OPERADORES (?,::,) (121) Los backward_warning.h o warning!! de C/C++ (122) (Una cuestión para ignorar y ejecutar el programa) Estructuras de almacenamiento (EDA) (123) Manejo de EDA y apuntadores Gestión dinánica de memoria (125) Constantes de tipo enumeración (128) Diferencias entre POO y POC (129) La librería para generar tiempo en C++ time.h Uso del system( cls ) Creación de un objeto en C++ (130) (Código fuente del void detalle versión final) Plantilla de menú en C++ (136) (Código fuente del programa, una forma muy básica P.O.O.) Recursividad en C++ (139) Los ciclos infinitos de C++ (140) Sentencias break, continue Instrucciones inmediatas (141) if, else, for,.. Paso de punteros a objetos (145) Por valor y por referencia. Línea de comandos (148) Ubicación del programa en la unidad C: Entrada vs Salida Archivos

7 (RECOPILACION III) Material teórico-practico adicional de programación en C++ 7 Variables vs Apuntadores (149) Objeto vs Clase (notas) Aprenda a programar con clases (150) Definición de una clase Prototipo de clases Objetos de clases Funciones miembro Tipos de funciones miembro Funciones en línea y fuera de línea La palabra reservada inline Archivos de cabecera y de clases Constructores (160) Constructor por defecto Constructores sobrecargados Constructor de copia Inicialización de miembros en constructores Destructores (165) Clases compuestas (166) Sobrecarga de funciones polimorfismo Errores de programación frecuentes en POO Plantillas de funciones (templates) Visibilidad de una función (171) Variables estáticas y automáticas (174) Compilación separada (176) Parámetro const de una función (180) Argumentos por omisión Detalles de programación básica I (184) Resumen de la programación con clases (191) Errores de programación frecuente en POO con clases (193) Mas sobre el goto, ciclos. Conclusiones (199) Programación Bibliografía consultada (200) Programación adicional (201, )

8 1 En muchas sintaxis el TDD se coloca simplemente como <tipo>, <valor_devuelto>. Una función en cualquier lenguaje de programación, también se puede llamar como un: tipo operador. 2 Estudiar Operaciones con Objetos, éstos capítulos corresponden más a la programación dinámica (abstracta) en C++, mientras que el Manual Básico de Programación en C++, (antes del apéndice) de programación en C++ va más ligada a programación estructurada. 3 En pseudoformal el * se suela cambiar por ^ por lo general y se coloca delante de la variable, Sintaxis: <nombre_apuntador>^. 4 Se agregaron estos laboratorios, tal cual se publicaron el la pagina de la Facultad de Ciencias UCV contienen muy buena información. 7 Para los siguientes tópicos se recomienda revisar los contenidos de el libro Algoritmos, estructuras de datos y objetos L. Joyanes Aguilar, paj 141 para saber mas acerca las librerías, funciones y variables de C++ se pretendió abarcar los aspectos mas relevantes de los capítulos 2,3,6, PARTE II de la obra. *Fuentes usadas: (Total 200 paginas exactas de información y + de ñapa!) Charter BT (Inserción de algunos signos especiales), Verdana (texto teoría) Courier New (código fuente) Time New Roman (palabras reservadas)

9 Diferencias entre C y C++ Aunque C++ es un súper conjunto de C, existen algunas diferencias entre los dos. En primer lugar, en C cuando una función no toma parámetros, su prototipo tiene la palabra void. Sin embargo en C++ void no es necesario (opcional). Prototipo en C: Prototipo en C++: char f1(void); char f1(); Otra diferencia entre C y C++ es que en un programa de C++ todas las funciones deben estar en forma de prototipo, en C los prototipos se recomiendan, pero son opcionales. También si una función de C++ es declarada para devolver un valor obligatoriamente la sentencia return debe devolver un valor, en C no es necesario que se devuelva. Otra diferencia es el lugar donde se declaran las variables locales. En C, deben ser declaradas solo al principio del bloque, mientras que en C++ las variables se pueden declarar en cualquier punto. Aunque es conveniente realizarlo siempre al comienzo de la función. La programación orientada a objetos (POO), permite descomponer un problema en subgrupos relacionados (método: divide y vencerás). Cada subgrupo pasa a ser un objeto auto contenido que contiene sus propias instrucciones y datos que le relacionan con ese objeto. Todos los lenguajes POO comparten tres características: Encapsulación, Polimorfismo y Herencia. ENCAPSULACIÓN: Es el mecanismo que agrupa el código y los datos que maneja. Los mantienen protegidos frente a cualquier interferencia y mal uso. Cuando el código y los datos están enlazados de esta manera se ha creado un objeto. Ese código y datos pueden ser privados para ese objeto o públicos para otras partes del programa. POLIMORFISMO: Es la cualidad que permite que un nombre se utilice para dos o más propósitos relacionados pero técnicamente diferentes. El propósito es poder usar un nombre para especificar una clase general de acciones. Por ejemplo en C tenemos tres funciones distintas para devolver el valor absoluto. Sin embargo en C++ incorpora Polimorfismo y a cada función se puede llamar abs(). El Polimorfismo se puede aplicar tanto a funciones como a operadores. HERENCIA: Proceso mediante el cual un objeto puede adquirir las propiedades de otro objeto. La información se hace manejable gracias a la clasificación jerárquica. OBJETO: Conjunto de variables y funciones pertenecientes a una clase encapsulados. A este encapsulamiento es al que se denomina objeto. Por tanto la clase es quien define las características y funcionamiento del objeto. Todo programa hecho en C puede correr en C++, pero no todos los programas hechos en C++ corren en C, para empezar abría que cambia su extensión de.cpp a.c (1)

10 Representación de datos en lenguaje C/C++ Estructura básica de un lenguaje en C++: (shell) (1) //Se hace la importación de librerías (2) #include <stdio.h> // pueden invocarse mas de una (3) (4) //Declaración de variables globales (5) int z=0; //variable (6) const float pi2 = 2* ; //constante (7) int main () (8) (9) int x=0,y=0; //variables locales a main (10) //bloque de instrucciones... (11) //creación de constructores opcionales (12) y=funcion (x,y); (13) /*instrucción estática->consola se usa con algunos (14) programas dev C++ por ejemplo*/ (15) return 0; //la función se puede comportar como una (cont.) (16) // acción también en C++ (17) int funcion (int &x,int y) (18) (19) int c=0; //variables local a función (20) c=y; //bloque de instrucciones (21) return c; (22) (23) //una línea vacía a veces es necesaria al final del código (24) /*a veces los cuerpos de funciones hay que declararlas arriba (25) va del cuerpo del main() para que el programa las reconozca (26) (DEV C++ ó C++) */ Declaraciones en C: Las declaraciones de variables o funciones pueden ser colocadas antes de cualquier enunciado ejecutable, siempre y cuando las declaraciones antecedan el uso de lo que se está declarando. Como se declaran variables en C: Se declaran siguiendo el patrón (sintaxis): <tipo> <nombre>; Como se declaran constantes en C: Existen dos tipos de constantes: -Constantes simbólicas: son las que permiten al programador ponerle un nombre a una constante y utilizarlo a todo lo largo del programa. Se declaran siguiendo el patrón (sintaxis): #define <identificador> <valor>; (2)

11 -Otra manera de declarar constantes en C es mediante la palabra reservada const. Este calificador permite especificar que un argumento pasado a una función no es modificable en dicha función o declarar variables constantes, en vez de declarar constantes simbólicas en el preprocesador con #define). const <tipodedato><identificador> =<valor>; Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia: El calificador const se usa en la lista de parámetro de una función para especificar que un argumento pasado a la función no es modificable en dicha función. También puede ser utilizado para declarar un apuntador constante. Creación un apuntador constante a tipo. <tipodedato> *const <identificador>=<valor>; (Variable) Apuntador a la constante tipo. const <tipodedato> *<identificador>=<valor>; Apuntador constante a tipo constante: const <tipodedato> *const <identificador> = <valor>; Reglas de alcance de una variable El alcance de un identificador o variable es la porción del programa en el cual dicho identificador puede ser referenciado. Cuando declaramos una variable local en un bloque, esta puede ser referenciada solamente en dicho bloque o en los bloques anidados dentro de dicho bloque. <tipo> <nombre1>=<valor>,<nombre2>=<valor>,<nombre3>=<valor>; Tipo de datos: Tipo Tamaño Rango de valores char 1 byte -128 a 127 int 2 bytes a float 4 bytes 3'4 E-38 a 3'4 E+38 double 8 bytes 1'7 E-308 a 1'7 E+308 (3)

12 Calificadores de tipo Los calificadores de tipo tienen la misión de modificar el rango de valores de un determinado tipo de variable. Estos calificadores son cuatro: Signen: Le indica a la variable que va a llevar signo. Es el utilizado por defecto. Tamaño Rango de valores signed char 1 byte -128 a 127 signed int 2 bytes a Unsigned: Le indica a la variable que no va a llevar signo (valor absoluto). Tamaño Rango de valores unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a Short: Rango de valores en formato corto (limitado). Es el utilizado por defecto. Tamaño Rango de valores short char 1 byte -128 a 127 short int 2 bytes a Long: Rango de valores en formato largo (ampliado). Tamaño Rango de valores long char 4 bytes a long int 10 bytes -3'36 E-4932 a 1'18 E+4932 Operador de resolución de alcance unario Es posible declarar variables locales y globales con un mismo nombre. C++ dispone del operador de resolución de alcance unario (::) para tener acceso a una variable global cuando está en alcance una variable local con el mismo nombre. No puede ser utilizado para tener acceso a una variable del mismo nombre en un bloque externo. Ejemplo: #include <iostream.h> float v; int main () int v=7; //se crea una variable entera ::v=10.5 //Utiliza la variable global v cout<< variable local v = <<v<< \n ; cout<< variable global v = <<::v<< \n ; return 0; (4)

13 Homonimia de funciones (Funciones con el mismo nombre) C++ permite que sean definidas varias funciones del mismo nombre (sobrecarga de funciones), siempre que estos nombres indiquen distintos conjuntos de parámetros. Esta capacidad se llama homonimia de funciones. La homonimia de la función se utiliza por lo común para crear varias funciones del mismo nombre, que ejecuten tareas similares, sobre tipos de datos distintos. Las funciones homónimas deben tener distintas listas de parámetros. La homonimia ayuda a eliminar el uso de las macros #define de C. /*Definimos dos funciones llamadas max(); una que regrese el mayor de dos enteros y otra que regrese el mayor de dos string.*/ #include <stdio.h> int max(int a,int b) if(a>d) return a; else return b; char *max(char *a, char *a) if(strcmp(a,b)>0) return a; else return b; int main() printf( max(19,69) = %d\n, max(19,69)); printf( max(abc,def) = %s\n, max( abc, def )); return 0; Comentarios en C/C++ No son tomados en cuenta por el compilador Comentario de una línea empiezan con // en adelante Comentario de texto empiezan con /* y terminan con*/ (5)

14 Secuencias de escape: Ciertos caracteres no representados gráficamente se pueden representar mediante lo que se conoce como secuencia de escape. A continuación vemos una tabla de las más significativas: \n salto de línea \b retroceso \t tabulación horizontal \v tabulación vertical \\ contrabarra \f salto de página \' apóstrofe \" comillas dobles \o fin de una cadena de caracteres Estructuras condicionales en C: Estructura IF...ELSE Sintaxis: if (<condición>) <sentencia>; // if sin llaves equivale a una sola sentencia //a ejecutar si se cumple la condición La sentencia solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia. Otro formato: Estructura IF...ELSEIF ELSE if (<condición_1>) <sentencia_1>; else if (<condición_2>) <sentencia_2>; else if (<condición_3>) <sentencia_3>; else <sentencia_n>; /* Comentario en C observe que también un if puede también no llevar llaves en cuyo caso estaría ejecutando una instrucción inmediata */ Sentencia CONTINUE Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del bucle. Existe otra sentencia, GOTO, que permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilización. Es una sentencia muy mal vista en la programación en C. (6)

15 Ejemplo: /* Uso de la sentencia CONTINUE */ #include <stdio.h> main() int numero=1; while(numero<=100) if (numero==25) numero++; continue; printf("%d\n",numero); numero++; Estructura SWITCH Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias. Su sintaxis es: switch (<variable>) case <contenido_variable1>: <sentencias_1>; break; case <contenido_variable2>: <sentencias_n-1>; break; default: <sentencias_n>; break; (7)

16 /* Uso de la sentencia condicional SWITCH. */ #include <stdio.h> /*ejemplo de como hacer un switch*/ main() int dia; printf("introduce el día: "); scanf("%d", &dia); switch(dia) case 1: printf("lunes"); break; case 2: printf("martes"); break; case 3: printf("miércoles"); break; case 4: printf("jueves"); break; case 5: printf("viernes"); break; case 6: printf("sábado"); break; case 7: printf("domingo"); break; default: printf( Día incorrecto ); break; Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista. Como hacer Ciclos en C: Estructura DO...WHILE Su sintaxis es: Do <sentencia1>; <sentencia2>; while (<condición>); (8)

17 Ejemplo: /* Uso de la sentencia DO...WHILE para hacer un menú*/ #include <stdio.h> main() char seleccion; do printf("1.- Comenzar\n"); printf("2.- Abrir\n"); printf("3.- Grabar\n"); printf("4.- Salir\n"); printf("escoge una opción: "); seleccion = getchar(); /*función que lee un caracter*/ switch(seleccion) case '1':printf("Opción 1"); break; case '2':printf("Opción 2"); break; case '3':printf("Opción 3"); while(seleccion!='4'); Estructura FOR Su sintaxis es: for (<inicialización>;<condición>;<incremento>) <sentencia1>; <sentencia2>; El flujo del bucle FOR transcurre de la siguiente forma: (9)

18 Estructura WHILE Su sintaxis es: while(<condicion>) <Sentencia1>; <Sentencia2>; Flujo de entrada/salida de C++ C++ ofrece una alternativa a las llamadas de función printf y scanf para manejar la entrada/salida de los tipos y cadenas de datos estándar. Así. En lugar de printf usamos el flujo de entrada de salida cout y el operador <<( colocar en ); y en lugar de scanf usamos el flujo de entrada estandar cin y el operador >>( obtener de ) operadores de inserción y extracción de flujo, a diferencia de printf y scanf, no requiere cadena de formato y de especificadores de conversión( especificadores de formato) para indicar los tipos de datos que son extraídos o introducidos. Para utilizar entradas/salidas de flujo, se debe incluir el archivo de cabecera iostream.h. Uso de las sentencias printf y scanf Sentencia printf ( ) La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla. El prototipo de la sentencia printf es el siguiente: printf(<control>,<arg1>,<arg2>...); Sentencia scanf ( ) La rutina scanf permite entrar datos en la memoria del ordenador a través del teclado. El prototipo de la sentencia scanf es el siguiente: scanf(<control>,<arg1>,<arg2>...); Suponiendo que arg1 fuera una variable mientras que arg2 fuera un especificador de formato se puede indicar al computador con que datos va a trabajar Tanto la función printf como la función scanf trabajan con especificadores de formato los cuales son: (10)

19 %c Un único carácter %d Un entero con signo, en base decimal %u Un entero sin signo, en base decimal %o Un entero en base octal %x Un entero en base hexadecimal %e Un número real en coma flotante, con exponente %f Un número real en coma flotante, sin exponente %s Una cadena de caracteres %p Un puntero o dirección de memoria El formato aunque no muy usado completo de los modificadores es el siguiente: % [signo] [longitud] [.precisión] [l/l] conversión Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha (por defecto). Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si la longitud es menor que el número de dígitos del valor, éste aparecerá ajustado a la izquierda. Precisión: indicamos el número máximo de decimales que tendrá el valor. l/l: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double. Uso de los apuntadores en C: (Se recomienda consultar el apendice).-un Apuntador es una variable que contiene una dirección de memoria, la cual corresponderá a un dato o a una variable que contiene el dato. Los apuntadores también deben de seguir las mismas reglas que se aplican a las demás variables, deben tener nombre únicos y deben de declararse antes de usarse Operadores de Indirección y Dirección. Hay 2 operadores que se usan cuando trabajan con direcciones en un programa C; el Operador de Indirección ( * ) y el de Dirección (&). Estos operadores son diferentes de los tratados anteriormente. El Operador de Dirección (&) regresa la dirección de una variable. Este operador está asociado con la variable a su derecha: &h; Esta línea regresa la dirección de la variable h. El Operador de Indirección (*) trabaja a la inversa del operador de Dirección. También esta asociado con la variable a su derecha, toma la dirección y regresa el dato que contiene esa dirección. Por ejemplo, la siguiente línea determina la dirección de la variable h y luego usa el operador de Indirección para accesar la variable y darle un valor de 42. Ejemplo: *(&h)=42; (11)

20 La declaración de un puntero de manera general es: Tipo *nombre de apuntador; Tipo : Especifica el tipo de objeto apuntado y puede ser cualquier tipo. Nombre de apuntador: Es el identificador del apuntador Instrucción estática->consola: (ie->c) En los programas de C algunas veces después de ejecutar el programa la consola se cierra muy rápido y no permite visualizar en un tiempo razonable el resultado del programa por consola, entonces es conveniente agregar al final de este una instrucción de modo que la consola dure un tiempo adecuado abierta esta es: system("pause"); return EXIT_SUCCESS; Esta se coloca justo antes de la última llave del main. Programa estándar hecho en C++ #include <stdlib.h> //libreria de C #include <iostream> #include <stdio.h> //libreria de C #include <cstdlid> /*variables globales, estructuras, funciones, clases, acciones*/ using namespace std; // (ie->c) main(int argc, char *argc) // main() en C/C++ da igual /*todo el bloque del programa*/ system("pause"); // (ie->c) return EXIT_SUCCESS; //puede no ser necesaria aveces(ie->c) /*se hace un enter después de la ultima llave para indicar un separador al compilador de C++, en la mayoría de los casos, si el programa se hace en lenguaje C++ el cuerpo de las funciones se declaran arriba del cuerpo del main() desde donde son llamadas*/ Cómo crear nuevos tipos de datos en C++ C++ proporciona la capacidad de crear nuevos tipos definidos por el usuario mediante el uso de la palabra reservada enum, la palabra reservada struct, la palabra reservada union y la palabra reservada class. Por ejemplo, las enumeraciones en C++ son declaradas mediante la palabra enum y se convierte en un tipo de dato nuevo. Luego, para declarar una variable del nuevo tipo de dato ya no es necesaria la palabra reservada enum, sino que se utiliza directamente el nombre del nuevo tipo de dato. Ejemplo: enum boolean FALSE, TRUE; struct Nombre char primer [10];char segundo[10];; (12)

21 Directivas del Preprocesador-> typedef La palabra reservada typedef proporciona un mecanismo para la creación de sinónimos o alias para tipos de datos anteriormente definidos. Al crear un nuevo nombre utilizando typedef no se crea un nuevo tipo; typedef simplemente crea un nuevo nombre de tipo que puede ser utilizado como un seudónimo para un nombre de tipo ya existente, lo cual ayuda a autodocumentar el programa. Ejemplo: typedef int IntArray10 [10]; La directiva del preprocesador-> #include La directiva del preprocesador #include permite que se incluya una copia del archivo especificado. Las dos formas de la directiva son: #include <filename> #include filename La diferencia entre estas formas estriba en la localización donde el preprocesador buscará el archivo a incluirse. Si el nombre del archivo está encerrado entre comillas, el preprocesador buscará el archivo en el mismo directorio que el archivo que se está compilando (este método se utiliza normalmente para incluir archivos de cabecera definidos por el programador). Si el nombre del archivo está encerrado entre corchetes angulares (< y >) la búsqueda se llevará a cabo en los directorios predesignados (por ejemplo cuando se incluyen los archivos de cabecera de la biblioteca estándar). Arreglos unidimensionales (Vectores) Un vector es un arreglo unidimensional, es decir, sólo utiliza un índice para referenciar a cada uno de los elementos. Su declaración será: <tipo> <nombre> [<tamaño>]; //tamaño es una variable por decir x El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de elementos del vector (se debe indicar entre corchetes [ ]). En el ejemplo se puede observar que la variable i es utilizada como índice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como se aprecia, las posiciones van de 0 a 9 (total 10 elementos). Ejemplo: /* Declaración de un arreglo. */ #include <stdio.h> main() int vector[10],i; for (i=0;i<10;i++) vector[i]=i; for (i=0;i<10;i++) printf(" %d", vector[i]); (13)

22 Podemos inicializar (asignarle valores) un vector en el momento de declararlo(igual que en Java). Si lo hacemos así no es necesario indicar el tamaño. Su sintaxis es: <tipo> <nombre> []=<valor_1>,<valor_2>,... Ejemplos: int vector[]=1,2,3,4,5,6,7,8; char vector[]="programador"; char vector[]='p','r','o','g','r','a','m','a','d','o','r'; Una particularidad con los vectores de tipo char (cadena de caracteres), es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el caracter nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este carácter al final de la cadena. Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4], debemos asignar el caracter nulo a vector[5]. Es muy sencillo: vector[5]='\0'; Ahora veremos un ejemplo de como se rellena un vector de tipo char. /* Vector de tipo char. */ #include <stdio.h> main() char cadena[20]; int i; for (i=0;i<19 && cadena[i-1]!=13;i++) cadena[i]=getche( ); if (i==19) cadena[i]='\0'; else cadena[i-1]='\0'; printf("\n%s",cadena); Podemos ver que en el for se encuentran dos condiciones: 1.- Que no se hayan rellenado todos los elementos (i<19). 2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13. También podemos observar una nueva función llamada getche( ), que se encuentra en conio.h. Esta función permite la entrada de un caracter por teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el caracter nulo en el elemento 20 (cadena[19]). En caso contrario tenemos el else, que asigna el caracter nulo al elemento que almacenó el caracter ENTER. (14)

23 En resumen: al declarar una cadena deberemos reservar una posición más que la longitud que queremos que tenga dicha cadena. Llamadas a funciones con arreglos Como ya se comentó en el tema anterior, los arreglos únicamente pueden ser enviados a una función por referencia. Para ello deberemos enviar la dirección de memoria del primer elemento del arreglo. Por tanto, el argumento de la función deberá ser un puntero. Ejemplo: /* Envío de un arreglo a una función. */ #include <stdio.h> void visualizar(int []); /* prototipo */ main() int array[25],i; for (i=0;i<25;i++) printf("elemento nº %d",i+1); scanf("%d",&array[i]); visualizar(&array[0]); void visualizar(int array[]) /* desarrollo */ int i; for (i=0;i<25;i++) printf("%d",array[i]); En el ejemplo se puede apreciar la forma de enviar un arreglo por referencia. La función se podía haber declarado de otra manera, aunque funciona exactamente igual: declaración o prototipo void visualizar(int *); desarrollo de la función void visualizar(int *arreglo) Arreglos multidimensionales (Matrices) Una matriz es un arreglo multidimensional. Se definen igual que los vectores excepto que se requiere un índice por cada dimensión. (15)

24 Su sintaxis es la siguiente: <tipo> <nombre> [<tamaño_1>][<tamaño_2>],...,[<tamaño_n>]; Una matriz bidimensional se podría representar gráficamente como una tabla con filas y columnas. La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos 3D. En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional. Se necesitan dos bucles para cada una de las operaciones. Un bucle controla las filas y otro las columnas. Ejemplo: /* Matriz bidimensional. */ #include <stdio.h> main() int x, i, numeros[3][4]; /* rellenamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) scanf("%d",&numeros[x][i]); /* visualizamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) printf("%d",numeros[x][i]); Si al declarar una matriz también queremos inicializarla, habrá que tener en cuenta el orden en el que los valores son asignados a los elementos de la matriz. Veamos algunos ejemplos: int numeros[3][4]=1,2,3,4,5,6,7,8,9,10,11,12; Quedarían asignados de la siguiente manera: numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3 numeros[0][3]=4 numeros[1][0]=5 numeros[1][1]=6 numeros[1][2]=7 numeros[1][3]=8 numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11 numeros[2][3]=12 (16)

25 También se pueden inicializar cadenas de texto: char dias[7][10]="lunes","martes",,"viernes","sábado","domingo"; Para referirnos a cada palabra bastaría con el primer índice: printf("%s",dias[i]); Registros Concepto de registro Un registro es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo. Su utilización más habitual es para la programación de bases de datos, ya que están especialmente indicadas para el trabajo con registros o fichas. La sintaxis de su declaración es la siguiente: struct <nombre_tipo_estructura> <TDD> <nombre_variable1>; <TDD> <nombre_variable2>; <TDD> <nombre_variable3>; ; Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado. Por último, tipo_variable y nombre_variable son las variables que forman parte del registro. Para definir variables del tipo que acabamos de crear lo podemos hacer de varias maneras, aunque las dos más utilizadas son éstas: Una forma de definir el registro es: struct trabajador char nombre[20]; char apellidos[40]; int edad; char puesto[10]; ; struct trabajador fijo, temporal; (17)

26 Otra forma es: struct trabajador char nombre[20]; char apellidos[40]; int edad; char puesto[10]; fijo, temporal; En el primer caso declaramos el registro, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que al registro. El problema del segundo método es que no podremos declarar más variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo registro, el mismo tiene que estar declarado previamente. Se debe declarar antes de la función main. El manejo de los registros es muy sencillo, así como el acceso a los campos (o variables) de estos registros. La forma de acceder a estos campos es la siguiente: <variable>.<campo>; Donde variable es el nombre de la variable de tipo registro que hemos creado, y campo es el nombre de la variable que forma parte del registro. Lo veremos mejor con un ejemplo basado en el registro definido anteriormente: temporal.edad = 25; Lo que estamos haciendo es almacenar el valor 25 en el campo edad de la variable temporal de tipo trabajador. Otra característica interesante de los registros es que permiten pasar el contenido de un registro a otro, siempre que sean del mismo tipo naturalmente: (Véase: Operaciones con Objetos en C++, paj. 47) fijo=temporal; Al igual que con los otros tipos de datos, también es posible inicializar variables de tipo registro en el momento de su declaración: struct trabajador fijo="pedro","hernández Suárez", 32, "gerente"; Si uno de los campos del registro es un arreglo de números, los valores de la inicialización deberán ir entre llaves: struct notas char nombre[30]; int notas[5]; ; struct notas alumno="carlos Pérez",8,7,9,6,10; (18)

27 Registros y funciones Podemos enviar un registro a una función de las dos maneras conocidas: 1.- Por valor: su declaración sería: Ejemplo: void visualizar(struct trabajador); Después declararíamos la variable fijo y su llamada sería: visualizar(fijo); Por último, el desarrollo de la función sería: void visualizar(struct trabajador datos) /* Paso de un registro por valor. */ #include <stdio.h> struct trabajador char nombre[20]; char apellidos[40]; int edad; char puesto[10]; ; void visualizar(struct trabajador); main() struct trabajador fijo; printf("nombre: "); scanf("%s",fijo.nombre); printf("\napellidos: "); scanf("%s",fijo.apellidos); printf("\nedad: "); scanf("%d",&fijo.edad); printf("\npuesto: "); scanf("%s",fijo.puesto); visualizar(fijo); void visualizar(struct trabajador datos) printf("nombre: %s",datos.nombre); printf("\napellidos: %s",datos.apellidos); printf("\nedad: %d",datos.edad); printf("\npuesto: %s",datos.puesto); (19)

28 2.- Por referencia: su declaración sería: void visualizar(struct trabajador*); Después declararemos la variable fijo y su llamada será: visualizar (&fijo); Por último, el desarrollo de la función será: void visualizar(struct trabajador *datos) Fíjense que en la función visualizar, el acceso a los campos de la variable datos se realiza mediante el operador ->, ya que lo tratamos con un puntero. En estos casos siempre utilizaremos el operador ->. Se consigue con el signo menos seguido de mayor que. Ejemplo: /* Paso de un registro por referencia. */ #include <stdio.h> struct trabajador char nombre[20]; char apellidos[40]; int edad; char puesto[10]; ; void visualizar(struct trabajador *); main() struct trabajador fijo; printf("nombre: "); scanf("%s",fijo.nombre); printf("\napellidos: "); scanf("%s",fijo.apellidos); printf("\nedad: "); scanf("%d",&fijo.edad); printf("\npuesto: "); scanf("%s",fijo.puesto); visualizar(&fijo); void visualizar(struct trabajador *datos) printf("nombre: %s",datos->nombre); printf("\napellidos: %s",datos->apellidos); printf("\nedad: %d",datos->edad); printf("\npuesto: %s",datos->puesto); (20)

29 Arreglos de registros Es posible agrupar un conjunto de elementos de tipo registro en un arreglo. Esto se conoce como arreglo de registros: struct trabajador char nombre[20]; char apellidos[40]; int edad; ; struct trabajador fijo[20]; Así podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;. Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para inicializar la variable en el momento de declararla lo haremos de esta manera: struct trabajador fijo[20] = "José", "Herrero Martínez", 29, "Luis", "García Sánchez", 46 ; Definición de tipos El lenguaje 'C' dispone de una declaración llamada typedef que permite la creación de nuevos tipos de datos. Ejemplos: typedef int entero; entero*/ entero a, b = 3; /*acabamos de crear un tipo de dato llamado /*declaramos dos variables de este tipo*/ Su empleo con registros está especialmente indicado. Se puede hacer de varias formas: Una forma de hacerlo: struct trabajador char nombre[20]; char apellidos[40]; int edad; ; typedef struct trabajador datos; datos fijo, temporal; (21)

30 Otra forma: typedef struct char nombre[20]; char apellidos[40]; int edad; trabajador datos; datos fijo, temporal; Archivos Por último veremos la forma de almacenar datos que podremos recuperar cuando deseemos. Estudiaremos los distintos modos en que podemos abrir un archivo, así como las funciones para leer y escribir en él. Apertura de archivos Antes de abrir un archivo necesitamos declarar un puntero de tipo FILE, con el que trabajaremos durante todo el proceso. Para abrir el archivo utilizaremos la función fopen(). Su sintaxis es: FILE *<nombre_del_puntero>; puntero = fopen (<nombre del archivo>, "<modo de apertura>" ); Donde puntero es la variable de tipo FILE, nombre del archivo es el nombre que daremos al archivo que queremos crear o abrir. Este nombre debe ir encerrado entre comillas. También podemos especificar la ruta donde se encuentra o utilizar un arreglo que contenga el nombre del archivo (en este caso no se pondrán las comillas). Algunos ejemplos: puntero = fopen("datos.dat","r"); puntero = fopen("c:\\txt\\saludo.txt","w"); Un archivo puede ser abierto en dos modos diferentes, en modo texto o en modo binario. A continuación lo veremos con más detalle. Modo texto w crea un archivo de escritura. Si ya existe lo crea de nuevo. w+ crea un archivo de lectura y escritura. Si ya existe lo crea de nuevo. a abre o crea un archivo para añadir datos al final del mismo. a+ abre o crea un archivo para leer y añadir datos al final del mismo. r abre un archivo de lectura. r+ abre un archivo de lectura y escritura. (22)

31 Modo binario wb w+b ab a+b rb r+b crea un archivo de escritura. Si ya existe lo crea de nuevo. crea un archivo de lectura y escritura. Si ya existe lo crea de nuevo. abre o crea un archivo para añadir datos al final del mismo. abre o crea un archivo para leer y añadir datos al final del mismo. abre un archivo de lectura. abre un archivo de lectura y escritura. La función fopen devuelve, como ya hemos visto, un puntero de tipo FILE. Si al intentar abrir el archivo se produjese un error (por ejemplo si no existe y lo estamos abriendo en modo lectura), la función fopen devolvería NULL. Por esta razón es mejor controlar las posibles causas de error a la hora de programar. Un ejemplo: FILE *pf; pf=fopen("datos.txt","r"); if (pf == NULL) printf("error al abrir el archivo"); La función freopen cierra el archivo apuntado por el puntero y reasigna este puntero a un archivo que será abierto. Su sintaxis es: freopen(<nombre del archivo>,"<modo de apertura>",<nomb_puntero>); Donde nombre del archivo es el nombre del nuevo archivo que queremos abrir, luego el modo de apertura, y finalmente el puntero que va a ser reasignado. Cierre de registros Una vez que hemos acabado nuestro trabajo con un archivo es recomendable cerrarlo. Los archivos se cierran al finalizar el programa pero el número de estos que pueden estar abiertos es limitado. Para cerrar los archivos utilizaremos la función fclose();. Esta función cierra el archivo, cuyo puntero le indicamos como parámetro. Si el archivo se cierra con éxito devuelve 0. fclose(<nomb_puntero>); Un ejemplo ilustrativo es: FILE *pf; pf = fopen("agenda.dat","rb"); if ( pf == NULL ) printf ("Error al abrir el archivo"); else fclose(pf); (23)

32 Escritura y lectura de registros A continuación veremos las funciones que se podrán utilizar dependiendo del dato que queramos escribir y/o leer en el archivo. Un ejemplo: Un carácter: fputc(<variable_caracter>,<puntero_archivo>); Escribimos un caracter en un archivo (abierto en modo escritura). FILE *pf; char letra='a'; if (!(pf=fopen("datos.txt","w"))) /* forma de controlar si hay un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fputc(letra,pf); fclose(pf); La función fgetc(<puntero_archivo>), lee un caracter de un archivo (abierto en modo lectura). Deberemos guardarlo en una variable. Un ejemplo: FILE *pf; char letra; if (!(pf=fopen("datos.txt","r"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else letra=fgetc(pf); printf("%c",letra); fclose(pf); (24)

33 Un número entero: putw(<variable_entera>,<puntero_archivo>); Escribe un número entero en formato binario en el archivo. Ejemplo: FILE *pf; int num=3; if (!(pf=fopen("datos.txt","wb"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fputw(num,pf); /* también podíamos haber hecho: fputw(3,pf); */ fclose(pf); La función getw( puntero_archivo ), lee un número entero de un archivo, avanzando dos bytes después de cada lectura. Un ejemplo: FILE *pf; int num; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else num=getw(pf); printf("%d",num); fclose(pf); (25)

34 Una cadena de caracteres: fputs(<variable_array>,<puntero_archivo>); Escribe una cadena de caracteres en el archivo. Ejemplo: FILE *pf; char cad="me llamo Vicente"; if (!(pf=fopen("datos.txt","w"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fputs(cad,pf); /* o también así: fputs("me llamo Vicente",pf); */ fclose(pf); La función fgets( variable_array, variable_entera, puntero_archivo ), lee una cadena de caracteres del archivo y la almacena en variable_array. La variable_entera indica la longitud máxima de caracteres que puede leer. Un ejemplo: FILE *pf; char cad[80]; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fgets(cad,80,pf); printf("%s",cad); fclose(pf); (26)

35 Con formato: fprintf(<puntero_archivo>,<formato>,<argumentos>); Funciona igual que un printf pero guarda la salida en un archivo. Ejemplo: FILE *pf; char nombre[20]="santiago"; int edad=34; if (!(pf=fopen("datos.txt","w"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fprintf(pf,"%20s%2d\n",nombre,edad); fclose(pf); La función fscanf(<puntero_archivo>,<formato>,<argumentos>), lee los argumentos del archivo. Al igual que con un scanf, deberemos indicar la dirección de memoria de los argumentos con el símbolo & ( ampersand ). Un ejemplo: FILE *pf; char nombre[20]; int edad; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ printf("error al abrir el archivo"); exit(0); /* abandonamos el programa */ else fscanf(pf,"%20s%2d\",nombre,&edad); printf("nombre: %s Edad: %d",nombre,edad); fclose(pf); (27)

36 Registros fwrite( *buffer,<tamaño>,<nº de veces>,<puntero_archivo>); Se utiliza para escribir bloques de texto o de datos, registros, en un archivo. En esta función, *buffer será la dirección de memoria de la cuál se recogerán los datos; tamaño, el tamaño en bytes que ocupan esos datos y nº de veces, será el número de elementos del tamaño indicado que se escribirán. fread( *buffer,<tamaño>,<nº de veces>,<puntero_archivo>); Se utiliza para leer bloques de texto o de datos de un archivo. En esta función, *buffer es la dirección de memoria en la que se almacenan los datos; tamaño, el tamaño en bytes que ocupan esos datos y nº de veces, será el número de elementos del tamaño indicado que se leerán. Otras funciones para archivos: rewind( <puntero_archivo> ): Sitúa el puntero al principio del archivo. fseek(<puntero_archivo>,long <posición>,int <origen>): Sitúa el puntero en la posicion que le indiquemos. Como origen podremos poner: 0 = SEEK_SET, el principio del archivo 1 = SEEK_CUR, la posición actual 2 = SEEK_END, el final del archivo rename(<nombre1>,<nombre2>): Su función es exactamente la misma que la que conocemos en MS-DOS. Cambia el nombre del archivo nombre1 por un nuevo nombre, nombre2. remove(<nombre>): Como la función del DOS del, podremos eliminar el archivo indicado en nombre. Detección de final de archivo La función feof(<puntero_archivo>), siempre deberemos controlar si hemos llegado al final de archivo cuando estemos leyendo, de lo contrario podrían producirse errores de lectura no deseados. Para este fin disponemos de la función feof(). Esta función retorna 0 si no ha llegado al final, y un valor diferente de 0 si lo ha alcanzado. Pues con esto llegamos al final del tema. Espero que no haya sido muy pesado. No es necesario que te aprendas todas las funciones de memoria. Céntrate sobre todo en las funciones fputs(), fgets(), fprintf(), fwrite() y fread(). Con estas cinco se pueden gestionar los archivos perfectamente. (28)

37 Prototipos de función y verificación de tipo de dato Los prototipos de función le permiten al compilador verificar por tipo la exactitud de las llamadas de función. En C++ los prototipos de función son requeridos para todas las funciones. Sin embargo, una función definida en un archivo, antes de cualquier llamada a la misma, no requiere de un prototipo de función, ya que el encabezado de función actúa como tal. Todos los parámetros de la función deberán declararse entre los paréntesis del prototipo y de la definición de función. En caso que no existan parámetros, bastará con colocar paréntesis vacíos. Ejemplo: int potencia (int, int); Operador de resolución de alcance unario Es posible declarar variables locales y globales con un mismo nombre. El operador de resolución de alcance unario (::) permite tener acceso a una variable global cuando está en alcance una variable local con el mismo nombre. El operador de resolución de alcance unario no puede ser utilizado para tener acceso a una variable con el mismo nombre en un bloque externo. Se puede tener acceso a una variable global de forma directa, sin usar el operador de resolución de alcance unario, siempre que no exista una variable local en alcance con el mismo nombre. Cómo llamar funciones: parámetros por valor y parámetros por referencia. Cuándo los argumentos se pasan en una llamada de una función por valor se efectúa una copia del valor del argumento y este se pasa a la función llamada. Las modificaciones a la copia no afectarán el valor original de la variable del llamador. Cuando un argumento es pasado por referencia, el compilador pasa la dirección de memoria del valor del parámetro a la función. Cuando se modifica el valor del parámetro (la variable local), este valor queda almacenado en la misma dirección de memoria, por lo que al retornar a la función llamadora la dirección de memoria donde se almacenó el parámetro contendrá el valor modificado. Para declarar una variable parámetro como paso por referencia, el símbolo & debe preceder al nombre de la variable. Por ejemplo la función de intercambio, que intercambia los valores de dos variables: void intercambio ( int &a, int &b) int aux = a; a = b; b = aux; Los parámetros a y b son parámetros por referencia. Por consiguiente, cualquier cambio efectuado en el interior de la función se transmitirá al exterior de la misma. Para llamar a la función intercambio () por referencia, simplemente se pasan las variables a intercambiar, por ejemplo: (29)

38 Ejemplo: int i = 3, j = 50; intercambio (i, j); También un parámetro por referencia es un seudónimo ( alias ) de su argumento correspondiente. Para indicar que un parámetro de función es pasado por referencia, solo hay que colocar un ampersand (&) después del tipo del parámetro en el prototipo de función. Debemos usar apuntadores para pasar argumentos que pudieran ser modificados por la función llamada, y usar referencias a constantes para pasar argumentos extensos que no serán modificados. Las variables de referencia deben ser inicializadas en sus declaraciones, y no pueden ser reasignadas como seudónimos a otras variables. Cuando se regresa un apuntador o una referencia a una variable declarada en la función llamada, la variable deberá ser declarada static dentro de dicha función. Las referencias pueden ser usadas como argumentos de funciones y regresar valores. Ejemplo: int ix; // ix es una variable en entera int &rx=ix; // rx es el alias de ix ix=1; // tambien rx ==1 rx=2; // tambien ix==2 Las referencias se pueden usar para proveer una función con un alias de un argumento real de llamada de función. Este permite cambiar el valor del argumento de llamada de función tal como se conoce de otros lenguajes de programación de llamada por referencia: /*U se pasa por valor y S por referencia*/ void mira (int U, int &S) U=42; S=42; void mar() int U,S; U=S=1; //inicializacion en una linea mirar(u,s); //en este punto S=42 y U=1; (30)