Fundamentos de informática Sintaxis básica de C/C++ 1º de Grado en Ingenierías Departamento de Lenguajes y Ciencias de la Computación Escuela Politécnica Superior Universidad de Málaga

30 de noviembre de 2012

Esta obra está bajo una licencia Reconocimiento-NoComercial-CompartirIgual 3.0 Unported de Creative Commons: No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original. Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es_ES o envie una carta a Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA. ía. incluye Usted es libre de: • Copiar, distribuir y comunicar públicamente la obra. • Hacer obras derivadas. Bajo las siguientes condiciones: • Reconocimiento (Attribution) – Debe reconocer los créditos de la obra de la manera especificada por el autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan el uso que hace de su obra). • No comercial (Non commercial) – No puede utilizar esta obra para fines comerciales. • Compartir bajo la misma licencia (Share alike) – Si altera o transforma esta obra, o genera una obra derivada, sólo puede distribuir la obra generada bajo una licencia idéntica a ésta. Entendiendo que: • Renuncia – Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos de autor • Dominio Público – Cuando la obra o alguno de sus elementos se halle en el dominio público según la ley vigente aplicable, esta situación no quedará afectada por la licencia. • Otros derechos – Los derechos siguientes no quedan afectados por la licencia de ninguna manera: ◦ Los derechos derivados de usos legítimos u otras limitaciones reconocidas por ley no se ven afectados por lo anterior. ◦ Los derechos morales del autor ◦ Derechos que pueden ostentar otras personas sobre la propia obra o su uso, como por ejemplo derechos de imagen o de privacidad. • Aviso – Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia de esta obra.

Contenidos II

Introducción a C/C++

3

1. Sintaxis básica 1. El preprocesador de C/C++ . . . 2. Palabras reservadas . . . . . . . . . 3. Literales . . . . . . . . . . . . . . . 4. Identificadores . . . . . . . . . . . 5. Expresiones . . . . . . . . . . . . . 6. Tipos predefinidos . . . . . . . . . 7. Definición de datos . . . . . . . . . 8. La asignación . . . . . . . . . . . . 9. Bloque . . . . . . . . . . . . . . . . 10. Sentencias de selección . . . . . . . 11. Sentencias de repetición . . . . . . 12. Subprogramas . . . . . . . . . . . . 12.1. Procedimientos . . . . . . . 12.2. Funciones . . . . . . . . . . 12.3. Parámetros . . . . . . . . . 13. Tipos definidos por el programador 13.1. Registros . . . . . . . . . . 13.2. Arrays . . . . . . . . . . . . 13.3. Anidamientos . . . . . . . .

. . . . . . . . . . . . . . . . . . .

4 4 4 5 6 6 7 8 9 10 10 11 12 12 13 13 14 14 16 23

A. Bibliotecas estándares de C++ 1. Entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2. Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

24 24 24 26

B. Bibliotecas estándares de C 1. Entrada/salida . . . . . . 2. Clasificación de caracteres 3. Matemática . . . . . . . . 4. Utilidades estándares . . .

27 27 27 28 28

. . . .

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

2

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . . . . . . . . . . . . . . . . .

. . . .

. . . .

Parte II

Introducción a C/C++

3

Capítulo 1

Sintaxis básica 1.

El preprocesador de C/C++

El preprocesador de C/C++ examina el código fuente y lo modifica antes de ser compilado. Busca líneas o directivas que empiezan con el carácter ‘#’ en la primera columna. La mayoría de estas directivas sirve para compilar (o no) selectivamente trozos del código fuente. Una de las más utilizadas es la directiva de inclusión de ficheros, include y se utiliza para incluir ficheros, bien ubicados en directorios estándares poniendo entre el nombre del fichero: #include o bien ubicados en directorios no estándares, poniendo entre comillas dobles el nombre de fichero y empezando el camino en el directorio actual: #include "fichero" Otra de las directivas del preprocesador más utilizadas es define, la cual sustituye todas las ocurrencias de una cadena abreviada en el código fuente por otra más compleja de escribir. #define cadena_abreviada cadena_compilada El uso de define es más general y admite incluso argumentos en la cadena abreviada para utilizarla a modo de función o macro.

2.

Palabras reservadas

Son las palabras clave que permiten construir la estructura sintáctica de C y C++ y no necesitan definirse porque el compilador ya conoce su significado: auto break case char const continue default do

double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

Posteriormente se añadieron las palabras reservadas que se incorporaron a la sintaxis de C++:

4

Capítulo 1. Sintaxis básica

asm bool catch class const_cast delete dynamic_cast explicit

3.

5

false friend inline mutable namespace new operator private

protected public reinterpret_cast static_cast template this throw true

try typeid typename using virtual wchar_t

Literales

Son las constantes sin nombre, tanto numéricas como textuales, que no necesitan ser definidas. Los caracteres van entre comillas y los números no. Además, los números pueden llevar sufijos para indicar el tipo de dato que es: Números naturales: 1452, 12345u, 123456789ul. Números enteros: 1452, -325, 123456789l. Números en base octal: 0166, 0777. Números en base hexadecimal: 0x1a, 0X1A. Números reales en coma fija de doble precisión: 1.4. Números reales en coma fija de simple precisión: 1.4f. Números reales en coma fija de gran precisión: -4.2L. Números reales en coma flotante: -4e2, 3e-5, 12e-9L. Caracteres simples imprimibles: 'a', '+', '&'. Caracteres ascii especificados con su código en octal: '\017'. Caracteres ascii especificados con su código en hexadecimal: '\x2c'. Cadenas de caracteres: "Si es una cadena, las comillas son dobles.". Cadena de caracteres vacía: "". La tabla 1 muestra algunos caracteres no imprimibles que en C/C++ se pueden escribir como secuencias de escape. Secuencia de escape '\a' '\b' '\f' '\n' '\r' '\t' '\v' '\\' '\?' '\' ' '\"'

Nombre del carácter campana (alarm) retroceso (backspace) avance de página (form feed) avance de línea (new line) retorno de carro (carriage return) tabulador (tabulator) tabulador vertical (vertical tabulator) diagonal invertida (backslash) interrogación (question mark) apóstrofe (apostrophe) comillas (quotation mark)

Tabla 1: Secuencias de escape de C/C++.

5

Capítulo 1. Sintaxis básica

4.

6

Identificadores

Un identificador es una palabra que no es reservada, tiene un máximo de 32 caracteres, comienza por una letra y va seguida de letras, dígitos o el carácter subguión ‘_’. Así son identificadores: dato, dato1, dato2000, Pi_Al_Cuadrado, Pi_doble, pero no son identificadores: 50_Al_Cuadrado, 5por15, variable.entera, constante K (con el espacio en blanco), while.

5.

Expresiones

C y C++ admiten distintos tipos de expresiones combinadas con distintos tipos de operadores. Pueden ser textuales, numéricas y lógicas. En general, las expresiones de distinto tipo no pueden mezclarse para no violar las llamadas reglas de compatibilidad de tipos, las cuales, por ejemplo, no permiten mezclar caracteres con números o números con expresiones lógicas. Expresiones de caracteres Los operandos básicos son literales, constantes simbólicas o variables de tipo carácter. Las llamadas a funciones que devuelven caracteres también son expresiones de caracteres. Con los caracteres simples en general no se opera, pero en C++ (no en C) podemos comparar las cadenas de caracteres con los operadores relacionales , =, == y !=, y también podemos unirlas con el operador de concatenación +, es decir, la expresión "Hola, " + "que tal!" nos produce "Hola, que tal!". Expresiones numéricas Los operandos básicos son literales, constantes simbólicas o variables de tipo numérico. Estas expresiones se forman combinando operandos numéricos con los operadores aritméticos +, -, *, /, % y los paréntesis (). Pueden contener llamadas a funciones que devuelvan valores numéricos como sqrt(), sin(), floor()... definidas en la biblioteca matemática estándar (véase el apéndice B). Expresiones lógicas Son expresiones que devuelven true o false, llamadas de tipo lógico. Pueden ser variables, constantes simbólicas o llamadas a funciones que devuelvan valores de tipo lógico. Las comparaciones formadas con los operadores relacionales , =, == y != también son expresiones de tipo lógico, aunque sus operandos pueden ser de cualquier tipo cuyos dominios estén ordenados, como los números o los caracteres. Las expresiones lógicas pueden agrupar subexpresiones lógicas con los operadores lógicos de conjunción, &&, disyunción, ||, o negación, !, y los paréntesis. Precedencia de operadores Siempre que no se violen las reglas de compatibilidad de tipos, en una expresión pueden aparecer distintos tipos de operadores, los cuales se operan en el orden que indiquen los paréntesis escritos en la expresión y según el orden que les corresponda por su precedencia. La tabla 2 muestra la precedencia de operadores de mayor a menor prioridad. En general, los aritméticos son más prioritarios que los comparativos, y éstos a su vez son más prioritarios que los lógicos. Nótese, no obstante, la alta prioridad del operador lógico de negación !.

6

Capítulo 1. Sintaxis básica

Tipo De agrupación De acceso Unarios Multiplicativos Aditivos Entrada/salida Relacional Igualdad AND lógico OR lógico Condicional Asignación Secuencia

7

Operadores () . [] -> ++ -- + - ! * /% + > < > = == != && || ?: = += -= *= /= %= ,

Asociatividad izquierda a derecha izquierda a derecha derecha a izquierda izquierda a derecha izquierda a derecha izquierda a derecha izquierda a derecha izquierda a derecha izquierda a derecha izquierda a derecha derecha a izquierda derecha a izquierda izquierda a derecha

Tabla 2: Precedencia de operadores por orden descendente de prioridad. Conversiones de tipos C/C++ realiza las siguientes conversiones de tipos implícitas: Cuando se mezclan operandos numéricos enteros y/o reales en una expresión, el tipo de la expresión se promociona al más preciso y/o al de mayor tamaño. Cuando una expresión de tipo numérico se asigna a una variable del mismo tipo pero de menor precisión, la expresión se convierte al tipo de la variable destino, perdiéndose la precisión. Los caracteres en realidad se almacenan con su código ascii, por lo que C/C++ los admiten en expresiones de tipo entero, pero no es recomendable mezclar caracteres con números. Aunque las expresiones enteras utilizadas como expresiones lógicas es un concepto herededado de C, tanto en C como en C++ pueden emplearse expresiones enteras en las condiciones, considerándose falso el valor 0, y verdadero cualquier valor distinto de 0. Por otro lado, son posibles las conversiones de tipo explícitas que tengan sentido. Para ello, en las expresiones se puede utilizar el llamado cast con el nombre de tipo destino entre paréntesis al estilo C: (tipo) expresion o bien al estilo C++, llamando al tipo como si fuera una función: tipo (expresion)

6.

Tipos predefinidos

Los tipos predefinidos son los tipos carácter o numéricos simples, también llamados escalares. Aunque no se considera escalar, en C++ se puede utilizar también como predefinido el tipo cadena, string. Sus dominios están ordenados, por lo que puede utilizarse los operadores relacionales con cualquiera de ellos. Por otro lado, el tipo lógico es un tipo simple y predefinido en C++, pero no existe en C. Todos los tipos predefinidos, a excepción de los numéricos de tipo real, son ordinales porque cada valor tiene un sucesor y un predecesor únicos (excepto el primer y último valor, lógicamente). Las cadenas, al no ser escalares, tampoco se consideran ordinales.

7

Capítulo 1. Sintaxis básica

8

La tabla 3 muestra los tipos predefinidos indicando si almacenan signo y sus variantes según su tamaño. La función predefinida sizeof(tipo) puede utilizarse para determinar el tamaño en bytes de un determinado tipo. Caracteres (ordinales) Cadenas de caracteres (no escalares) Números naturales (ordinales)

Números enteros (ordinales)

Números reales: (no ordinales) Valores lógicos: (ordinales: false variable >> ...;

// salida // entrada

Los tipos de las expresiones y variables pueden ser cualesquiera de los predefinidos, incluyendo cadenas de caracteres. En el caso de la lectura de cadenas, sólo se lee hasta el primer blanco (espacio, tabulador o carácter de fin de línea).2 En C sólo podemos utilizar la biblioteca tradicional : 3 #include ... printf("formato", expresion, expresion, ...); scanf("formato", & variable, & variable, ...);

// salida // entrada

Nótese en ambos casos que la entrada debe producirse siempre sobre variables o valoresL que hagan referencia a una posición de memoria donde se pueda guardar el valor que entra. El valor de salida en cambio puede ser cualquier expresión o valorR. 1 La

L y la R vienen del inglés, left y right, por estar a la izquierda y a la derecha del operador = respectivamente. leer una línea completa, utilícese la función getline de la biblioteca (ver sección A). 3 Véase algún libro de programación en C para más información.

2 Para

9

Capítulo 1. Sintaxis básica

9.

10

Bloque

Agrupación de sentencias entre llaves {} que pueden incluso anidar otros bloques. Suelen formar parte de las sentencias de control de flujo. { sentencias { // bloque anidado sentencias } sentencias {

// otro bloque anidado { // aun mas anidado sentencias }

} }

10.

Sentencias de selección

Son sentencias de control de flujo que permiten seleccionar qué sentencias se ejecutan a continuación en función del valor verdadero o falso que toma una condición. Todas las condiciones son expresiones de tipo lógico. Selección genérica múltiple if (condicion) { sentencias } else if (condicion) {

// opcional

sentencias } else if (condicion) {

// opcional

sentencias } ... else {

// opcional

sentencias }

10

Capítulo 1. Sintaxis básica

11

Selección basada en una expresión común Las condiciones de la sentencia if-else son independientes unas de otras, pero a veces todas las condiciones dependen de una sola expresión y resulta incómodo y propenso a errores tener que repetirla varias veces. La sentencia switch permite seleccionar sentencias en función del valor que toma una expresión escribiéndola una sola vez. Se ejecutan las sentencias del caso coincidente con el valor que toma la expresión. La expresión debe ser de tipo ordinal, es decir, escalar pero no de tipo real. switch (expresion) { case valor11: case valor12: ... sentencias; break; case valor21: case valor22: ... sentencias; break; ... default: sentencias; } Aunque la sentencia break es opcional, su ausencia provoca la ejecución de las sentencias de todos los casos por debajo del caso coincidente hasta el siguiente break o hasta el final de la sentencia switch.

11.

Sentencias de repetición

Son sentencias de control de flujo que permiten ejecutar un bloque de sentencias mientras sea verdadero la condición de control del bucle. Esta condición se evalúa después o antes de cada repetición o iteración. Los bucles pre-test evalúan la condición antes de cada iteración, mientras que los post-test la evalúan después de cada iteración. Bucles pre-test while (condicion) { sentencias } for (expresion; condicion; expresion) { sentencias }

11

Capítulo 1. Sintaxis básica

12

La primera expresion del for sólo se ejecuta una vez antes de empezar el bucle. La condición se evalúa justo antes de cada iteración. Y la última expresión se ejecuta después de cada iteración completa, justo antes de la siguiente evaluación de la condición de control. El bucle for es más adecuado cuando existe una variable de control clara de la que depende la terminación. Bucle post-test En los bucles post-test la condición se evalúa después de cada iteración, por lo que al menos siempre se ejecuta el cuerpo del bucle una vez. do { sentencias } while (condicion); La sentencias continue y break dentro de un bucle terminan prematuramente la iteración actual y todo el bucle respectivamente. Pero son sentencias que no se deben utilizar porque tienden a desestructurar el código.

12.

Subprogramas

Los subprogramas permiten ejecutar bloques de sentencias que se definen una sola vez en el programa, pero que pueden llamarse múltiples veces con diferentes datos o parámetros. Estos parámetros pueden ser de entrada, cuando suministran información al subprograma llamado para realizar sus cálculos, o pueden ser de salida si devuelven información que ha calculado el subprograma. También pueden ser de entrada-salida. Los parámetros que aparecen dentro del subprograma se llaman formales, o fictíceos 4 , mientras que los que aparecen en las llamadas son los parámetros reales. Esto es así porque los parámetros de los subprogramas no están en memoria hasta que cobran vida cuando son llamados y sustituidos por los reales, que ya existen en memoria. Al terminar el subprograma, los parámetros fictíceos desaparecen de la memoria del proceso. Cada parámetro formal definido en la cabecera del subprograma especifica el tipo del correspondiente parámetro real que debe aparecer en la llamada en el mismo orden, de tal manera que el tipo del parámetro real debe ser compatible con el que indica el parámetro formal. En general, en los lenguajes de programación existen dos tipos de subprogramas: los procedimientos, cuyas llamadas representan una acción; y las funciones, cuyas llamadas representan un valor y tratan de simular el comportamiento de una función matemática.

12.1.

Procedimientos

Los procedimientos no devuelven nada como valor de función por lo que no actúan como las típicas funciones matemáticas, y la información de salida la devuelven siempre en parámetros de salida o por algún dispositivo de salida como la pantalla. Antes de realizarse llamadas, hay que definir el procedimiento como se muestra a continuación: 4 En

inglés dummy arguments.

12

Capítulo 1. Sintaxis básica

13

void Identificador(definicion param_formal1, definicion param_formal2, ...) { sentencias } La llamada a un procedimiento es una sentencia por sí sola: Identificador(param_real1, param_real2, ...);

12.2.

Funciones

Las funciones son subprogramas que pueden simular las llamadas a las típicas funciones matemáticas, ya que devuelven el valor que toma la propia función a través de la sentencia return, la cual debe aparecer al menos una vez dentro del subprograma, y preferentemente una sola vez al final. En la definición debe especificarse el tipo del valor devuelto, tal como se indica a continuación: tipo Identificador(definicion param_formal1, definicion param_formal2, ...) { sentencias return expresion;

// del tipo de la funcion

} La llamada a una función en realidad no es una sentencia, sino un valor de un determinado tipo, y como tal, normalmente estará dentro de una expresión que sea compatible con el tipo del valor que toma la función. ... Identificador(param_real1, param_real2, ... ) ... Antes de evaluar la función se evalúan sus argumentos, y la función se evalúa antes que la expresión donde aparece la llamada.

12.3.

Parámetros

Ya hemos dicho que los parámetros puede ser de entrada o salida según la dirección hacia donde fluya la información. Los parámetros de entrada deben estar inicializados antes de la llamada, ya que es información de entrada al subprograma. Los parámetros de salida deben modificarse al menos una vez dentro del cuerpo del subprograma, ya que es la información que generará el subprograma. Los parámetros de salida no necesitan ser inicializados antes de realizar la llamada, pero los de entrada-salida sí. Puesto que los parámetros de salida y de entrada-salida van a contener la información generada por el subprograma después de la llamada, el parámetro real de la llamada debe ser una variable o valorL que haga referencia a una posición de memoria donde se guardará el resultado. Se dice que se pasan por referencia. La definición del parámetro formal utiliza el carácter ‘&’ detrás del tipo: tipo Subprograma( ..., tipo & param_formal, ...) Sin embargo, los parámetros reales de entrada pueden ser cualquier expresión compatible con el correspondiente parámetro formal. En realidad, se crea una copia nueva del parámetro real, ya que el original no es necesario modificarlo. Se dice que se pasa por valor. Aunque no es obligatorio, es conveniente poner el calificador const delante del tipo en la definición del parámetro formal 13

Capítulo 1. Sintaxis básica

14

para que el compilador avise cuando se modifique un parámetro de entrada, lo que normalmente no es necesario5 : tipo Subprograma( ..., const tipo param_formal, ...) Una tercera posibilidad, habitual en el paso de variables de tipo compuesto de entrada, es pasarlos por referencia constante. Esto evita la sobrecarga de la copia innecesaria de registros que podrían ocupar mucho espacio de memoria y, aunque hagan referencia directa al parámetro real, se protegen para que dentro del subprograma no se modifique accidentalmente. En este caso se debe poner tanto la palabra const como el carácter & en la definición del parámetro formal (ver sección 13.1).

13.

Tipos definidos por el programador

Son tipos no predefinidos por el lenguaje, pero que puede definir el programador basándose en los tipos predefinidos elementales o en otros tipos definidos anteriormente por el programador. En general, los tipos compuestos o estructurados debe definirlos el programador para especificar el tamaño y tipo de cada uno de sus componentes. La definición de un tipo compuesto puede hacerse de forma explícita, dándole un nombre con la sentencia typedef. En una sentencia posterior se utilizará ese nombre para definir las variables de ese tipo compuesto como un tipo predefinido. Pero C/C++ admiten la definición de arrays de forma implícita, sin nombre, en la misma sentencia que se define la variable, como veremos en la sección 13.2.

13.1.

Registros

Un registro es una colección heterogénea (de tipos distintos) de variables o campos que se acceden con el nombre común de todo el registro y un nombre único que identifica el campo dentro del registro. El tipo de cada campo puede ser cualquiera. La definición de un tipo registro se hace con la sentencia typedef utilizando además la palabra reservada struct propia de los registros. A continuación y entre llaves {} se define cada campo con su tipo como si fueran variables locales al registro. // definicion del tipo registro typedef struct { int dni; string nombre; string domicilio; float estatura; float peso; } TPersona; // nombre del tipo nuevo Una vez definido el tipo registro, la definición de variables registro es similar a la habitual, pudiéndose inicializar incluyendo entre { } los valores de cada campo separados por comas: 5 Siempre

se puede definir y copiar su valor en una variable local del mismo tipo.

14

Capítulo 1. Sintaxis básica

15

// definicion de 3 registros TPersona empleado, directivo, becario; // los campos se pueden inicializar por orden de definicion TPersona maquinista = { 12345678, "Pepito Grillo", "C/La que sea, 3, Villarriba de Abajo", 1.83, // metros 95.3 // kilos }; Y la definición de registros constantes es muy parecida a la de los registros variables, pero con la palabra reservada const, que evita su posterior modificación: const TPersona DomenicoEscarlati = { 31283130, "Domenico Escarlati Perolo", "C/ Brieva del Verano, 31, Messina", 1.70, 72.2, }; Los campos de los registros se pueden utilizar exactamente igual que las variables del mismo tipo. Se acceden con el nombre común del registro, el operador de acceso ‘.’ y el nombre del campo sin dejar espacios en blanco entre ellos: maquinista.dni = 87654321; maquinista.nombre = "Juanito Cigarra"; if (empleado.peso < 100) ... return maquinista.estatura; La alternativa tradicional de C para definir registros no utiliza la palabra reservada typedef y el nombre del tipo registro cambia de posición: // definicion del tipo registro struct DatosPersona { // nombre del tipo nuevo int dni; string nombre; string domicilio; float estatura; float peso; }; // definicion de 3 registros DatosPersona empleado, directivo, becario; Los registros completos se pueden: Inicializar total o parcialmente en la definición. Pasar como parámetros a subprogramas. Asignar con una sola sentencia =. Devolver como valor de una función con la sentencia return. Pero no se puede: Enviarlos al flujo cout. Hay que hacerlo campo a campo. 15

Capítulo 1. Sintaxis básica

16

Aceptarlos del flujo cin. Hay que leerlos campo a campo. Registros como parámetros a subprogramas La definición de un registro como parámetro formal de un subprograma es similar a las de tipo predefinido. La única salvedad es cuando los registros son parámetros de entrada de gran tamaño. Entonces se utiliza el paso por referencia constante para evitar la copia de muchos datos: // registros como parametros de entrada void Subprograma(const TPersona persona) void Subprograma(TPersona persona) void Subprograma(DatosPersona persona) void Subprograma(const TPersona & persona)

// // // //

por por por por

valor valor valor ref. cte.

// registros como parametros de salida o entrada/salida void Subprograma(TPersona & persona) // por ref. void Subprograma(DatosPersona & persona) // por ref.

13.2.

Arrays

Un array es una colección homogénea de datos o componentes de un mismo tipo base con un nombre común, y colocadas consecutivamente en memoria ordenadas por un índice, de tal forma que cada valor del array se identifica de forma única con el nombre del array y por su índice. En C/C++ la primera posición es siempre la 0. El siguiente esquema muestra el contenido en memoria de un array de 10 enteros con el índice de cada posición debajo. -12 0

1 1

55 2

0 3

-54 4

72 5

-6 6

-88 7

523 8

32 9

Al igual que con los registros, para utilizar arrays primero hay que definir el tipo array. Después se definirán todos los arrays que se vayan a utilizar como variables, ya que el tipo no especifica ni reserva ninguna posición de memoria, sino sólo la estructura de una variable de tipo array. En la definición del tipo array, además de indicar el tipo base, hay que indicar la longitud máxima en tiempo de compilación, es decir, esta longitud debe ser una expresión constante, por lo que son estructuras estáticas 6 . En estas notas vamos a trabajar con los nuevos arrays que incorpora el estándar de C++ 20117 . La diferencia fundamental con los arrays tradicionales es que los nuevos permiten la asignación completa de dos arrays, mientras que esto no era posible con los arrays tradicionales de C/C++. Definición de arrays Los tipos array se definen con la sentencia typedef, normalmente como una definición global. A continuación se definen los arrays que se necesiten, que ya sí son datos reales en memoria, y suelen definirse como variables locales o constantes simbólicas. El tamaño máximo de un array ya definido puede obtenerse con la función size() en número de elementos, o con la función sizeof en número de bytes, tal como se muestra en el siguiente ejemplo. Nótese la diferencia en la notación entre ambas funciones, ya que la primera es una función de biblioteca, y la segunda es propia de C/C++. 6 Existen también en C++ arrays dinámicos que permiten indicar la longitud en tiempo de ejecución usando el operador new. 7 Es posible que se necesite activar la correspondiente opción al compilar, -std=c++0x.

16

Capítulo 1. Sintaxis básica

17

#include // necesaria en el estandar C++ 2011. using namespace std; const unsigned MaxZs=1000; // longitud maxima typedef array TZs; // el nuevo tipo array es TZs int main() { TZs array1; // variable array sin inicializar TZs array2 = {0,1,2}; // inicializadas solo 3 primeras posiciones ... cout