fundamentos de informática sintaxis básica de c/c++ · de las posibles obras derivadas, la...

Fundamentos de informáticaSintaxis básica de C/C++

1º de Grado en Ingenierías

Departamento de Lenguajes y Ciencias de la ComputaciónEscuela Politécnica Superior

Universidad de Málaga

30 de noviembre de 2012

Esta obra está bajo una licencia Reconocimiento-NoComercial-CompartirIgual 3.0 Un-ported de Creative Commons: No se permite un uso comercial de la obra original nide las posibles obras derivadas, la distribución de las cuales se debe hacer con una li-cencia igual a la que regula la obra original. Para ver una copia de esta licencia, visi-te http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es_ES o envie una carta aCreative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA. ía. inclu-ye

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 maneraespecificada por el autor o el licenciador (pero no de una manera que sugiera que tienesu 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 licenciaidéntica a ésta.

Entendiendo que:

• Renuncia – Alguna de estas condiciones puede no aplicarse si se obtiene el permiso deltitular de los derechos de autor

• Dominio Público – Cuando la obra o alguno de sus elementos se halle en el dominiopú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 ningunamanera:◦ Los derechos derivados de usos legítimos u otras limitaciones reconocidas por leyno se ven afectados por lo anterior.

◦ Los derechos morales del autor◦ Derechos que pueden ostentar otras personas sobre la propia obra o su uso, comopor ejemplo derechos de imagen o de privacidad.

• Aviso – Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de lalicencia de esta obra.

Contenidos

II Introducción a C/C++ 3

1. Sintaxis básica 41. El preprocesador de C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42. Palabras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43. Literales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66. Tipos predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77. Definición de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88. La asignación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99. Bloque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1010. Sentencias de selección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1011. Sentencias de repetición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112. Subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

12.1. Procedimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1212.2. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312.3. Parámetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

13. Tipos definidos por el programador . . . . . . . . . . . . . . . . . . . . . . . . . . . 1413.1. Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1413.2. Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1613.3. Anidamientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

A. Bibliotecas estándares de C++ 241. Entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242. Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

B. Bibliotecas estándares de C 271. Entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272. Clasificación de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273. Matemática . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284. Utilidades estándares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 deestas 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 paraincluir ficheros, bien ubicados en directorios estándares poniendo entre <> el nombre del fichero:

#include <fichero>

o bien ubicados en directorios no estándares, poniendo entre comillas dobles el nombre de ficheroy empezando el camino en el directorio actual:

#include "fichero"

Otra de las directivas del preprocesador más utilizadas es define, la cual sustituye todas lasocurrencias 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 parautilizarla a modo de función o macro.

2. Palabras reservadasSon 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:

autobreakcasecharconstcontinuedefaultdo

doubleelseenumexternfloatforgotoif

intlongregisterreturnshortsignedsizeofstatic

structswitchtypedefunionunsignedvoidvolatilewhile

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

4

Capítulo 1. Sintaxis básica 5

asmboolcatchclassconst_castdeletedynamic_castexplicit

falsefriendinlinemutablenamespacenewoperatorprivate

protectedpublicreinterpret_caststatic_casttemplatethisthrowtrue

trytypeidtypenameusingvirtualwchar_t

3. LiteralesSon 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 sufijospara 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 comosecuencias de escape.

Secuencia de escape Nombre del carácter'\a' campana (alarm)'\b' retroceso (backspace)'\f' avance de página (form feed)'\n' avance de línea (new line)'\r' retorno de carro (carriage return)'\t' tabulador (tabulator)'\v' 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


4. IdentificadoresUn identificador es una palabra que no es reservada, tiene un máximo de 32 caracteres, comien-

za 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 enblanco), while.

5. ExpresionesC 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 puedenmezclarse para no violar las llamadas reglas de compatibilidad de tipos, las cuales, por ejemplo, nopermiten 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. Lasllamadas a funciones que devuelven caracteres también son expresiones de caracteres. Con loscaracteres simples en general no se opera, pero en C++ (no en C) podemos comparar las cadenasde caracteres con los operadores relacionales <, >, <=, >=, == y !=, y también podemos unirlas conel 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. Estasexpresiones 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 comosqrt(), 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 compara-ciones formadas con los operadores relacionales <, >, <=, >=, == y != también son expresiones detipo 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 deconjunció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 aparecerdistintos tipos de operadores, los cuales se operan en el orden que indiquen los paréntesis escritosen la expresión y según el orden que les corresponda por su precedencia. La tabla 2 muestrala precedencia de operadores de mayor a menor prioridad. En general, los aritméticos son másprioritarios que los comparativos, y éstos a su vez son más prioritarios que los lógicos. Nótese, noobstante, la alta prioridad del operador lógico de negación !.

6


Tipo Operadores AsociatividadDe agrupación () izquierda a derechaDe acceso . [] -> izquierda a derechaUnarios ++ -- + - ! derecha a izquierdaMultiplicativos * /% izquierda a derechaAditivos + - izquierda a derechaEntrada/salida << >> izquierda a derechaRelacional < > <= >= izquierda a derechaIgualdad == != izquierda a derechaAND lógico && izquierda a derechaOR lógico || izquierda a derechaCondicional ?: derecha a izquierdaAsignación = += -= *= /= %= derecha a izquierdaSecuencia , 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 laexpresió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 demenor precisión, la expresión se convierte al tipo de la variable destino, perdiéndose laprecisión.

Los caracteres en realidad se almacenan con su código ascii, por lo que C/C++ los admitenen 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 herededa-do 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, enlas expresiones se puede utilizar el llamado cast con el nombre de tipo destino entre paréntesis alestilo C:

(tipo) expresion

o bien al estilo C++, llamando al tipo como si fuera una función:

tipo (expresion)

6. Tipos predefinidosLos 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 concualquiera de ellos. Por otro lado, el tipo lógico es un tipo simple y predefinido en C++, pero noexiste en C.

Todos los tipos predefinidos, a excepción de los numéricos de tipo real, son ordinales porquecada 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


La tabla 3 muestra los tipos predefinidos indicando si almacenan signo y sus variantes segúnsu tamaño. La función predefinida sizeof(tipo) puede utilizarse para determinar el tamañoen bytes de un determinado tipo.

Caracteres char(ordinales) unsigned charCadenas de caracteres string(no escalares) (Sólo en C++)Números naturales unsigned short [int](ordinales) unsigned int

unsigned long [int]unsigned long long [int]

Números enteros short [int](ordinales) int

long [int]long long [int]

Números reales: float(no ordinales) double

long doubleValores lógicos: bool(ordinales: false<true) (Sólo en C++)

Tabla 3: Tipos predefinidos en C/C++ (los corchetes no se escriben, indican lo que es opcional).

7. Definición de datosVariables

Todas las variables deben definirse antes de ser usadas. Tienen alcance de bloque (block scope),por lo que sólo pueden utilizarse dentro del bloque donde se definen (véase sección 9 más adelante).Pueden definirse sin inicializar:

tipo identificador;

o con un valor inicial:tipo identificador = expr_constante;

La expr_constante puede ser un literal, una constante simbólica o una expresión constantepreviamente definida que sea compatible con el tipo de la variable.

Constantes simbólicas

Las constantes simbólicas son constantes con un nombre. En C++ se definen con la palabrareservada const seguida del tipo:

const tipo identificador = expr_constante;

donde la expr_constante puede ser un literal o bien otra constante simbólica previamentedefinida que sea de tipo compatible. En C se suele utilizar la directiva define del preprocesador,la cual no asigna ningún tipo a la constante ni tampoco le reserva memoria porque es una simplesustitución que realiza el preprocesador previa a la compilación:

#define identificador constante

8


8. La asignaciónEs la sentencia de transferencia de datos por excelencia en C/C++. Su sintaxis es la siguiente:

valorL = valorR;

Esta sentencia simplemente transfiere el resultado obtenido después de evaluar valorR a laposición de memoria indicada por valorL 1. Nótese que el sentido de la transferencia es de derechaa izquierda y que el operador = no tiene nada que ver con la comparación de igualdad.

El valorR puede ser cualquier expresión tipo compatible con el valorL, pero el valorL debe seruna variable o cualquier otra referencia válida a una posición de memoria, tal como muestran lossiguientes ejemplos:

float a, b, c;// ejemplos validosa = 4.0;a = c;a = b + c;b = 2*sin(a) + c;

// en los ejemplos siguientes el valorL no es validoa + b = 3.0; // 3.0 se guarda en a o en b?sin(a) = a; // sin(a) no es una posicion de memoria4 = a; // 4 tampoco es una posicion de memoria

Cuando el valorL es una expresión que no referencia una posición de memoria, es típico elsiguiente mensaje o alguno similar con el que responden los compiladores o alguno similar:

error: lvalue required as left operand of assignment

E/S básicaEn C++ se utiliza la biblioteca estándar moderna <iostream>:

#include <iostream>using namespace std;...cout << expresion << expresion << ...; // salidacin >> variable >> variable >> ...; // entrada

Los tipos de las expresiones y variables pueden ser cualesquiera de los predefinidos, incluyendocadenas 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 <stdio.h>: 3

#include <stdio.h>...printf("formato", expresion, expresion, ...); // salidascanf("formato", & variable, & variable, ...); // entrada

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

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

9


9. BloqueAgrupació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 anidadosentencias}

}}

10. Sentencias de selecciónSon sentencias de control de flujo que permiten seleccionar qué sentencias se ejecutan a conti-

nuación en función del valor verdadero o falso que toma una condición. Todas las condiciones sonexpresiones 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


Selección basada en una expresión común

Las condiciones de la sentencia if-else son independientes unas de otras, pero a vecestodas las condiciones dependen de una sola expresión y resulta incómodo y propenso a errorestener que repetirla varias veces. La sentencia switch permite seleccionar sentencias en funcióndel valor que toma una expresión escribiéndola una sola vez. Se ejecutan las sentencias del casocoincidente 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 detodos los casos por debajo del caso coincidente hasta el siguiente break o hasta el final de lasentencia switch.

11. Sentencias de repeticiónSon 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 cadarepetición o iteración. Los bucles pre-test evalúan la condición antes de cada iteración, mientrasque los post-test la evalúan después de cada iteración.

Bucles pre-test

while (condicion) {

sentencias

}

for (expresion; condicion; expresion) {

sentencias

}

11


La primera expresion del for sólo se ejecuta una vez antes de empezar el bucle. La condiciónse evalúa justo antes de cada iteración. Y la última expresión se ejecuta después de cada iteracióncompleta, 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 dependela 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 menossiempre 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ónactual y todo el bucle respectivamente. Pero son sentencias que no se deben utilizar porque tiendena desestructurar el código.

12. SubprogramasLos subprogramas permiten ejecutar bloques de sentencias que se definen una sola vez en

el programa, pero que pueden l lamarse múltiples veces con diferentes datos o parámetros. Es-tos parámetros pueden ser de entrada, cuando suministran información al subprograma llamadopara realizar sus cálculos, o pueden ser de salida si devuelven información que ha calculado elsubprograma. También pueden ser de entrada-salida.

Los parámetros que aparecen dentro del subprograma se llaman formales, o fictíceos4, mientrasque los que aparecen en las llamadas son los parámetros reales. Esto es así porque los parámetrosde los subprogramas no están en memoria hasta que cobran vida cuando son llamados y sustituidospor los reales, que ya existen en memoria. Al terminar el subprograma, los parámetros fictíceosdesaparecen de la memoria del proceso.

Cada parámetro formal definido en la cabecera del subprograma especifica el tipo del corres-pondiente parámetro real que debe aparecer en la llamada en el mismo orden, de tal manera queel 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 procedi-mientos, cuyas llamadas representan una acción; y las funciones, cuyas llamadas representan unvalor y tratan de simular el comportamiento de una función matemática.

12.1. ProcedimientosLos 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 desalida o por algún dispositivo de salida como la pantalla. Antes de realizarse llamadas, hay quedefinir el procedimiento como se muestra a continuación:

4En inglés dummy arguments.

12


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. FuncionesLas funciones son subprogramas que pueden simular las llamadas a las típicas funciones mate-

máticas, ya que devuelven el valor que toma la propia función a través de la sentencia return, lacual debe aparecer al menos una vez dentro del subprograma, y preferentemente una sola vez alfinal. 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 determinadotipo, y como tal, normalmente estará dentro de una expresión que sea compatible con el tipo delvalor 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 laexpresión donde aparece la llamada.

12.3. ParámetrosYa 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, yaque es información de entrada al subprograma. Los parámetros de salida deben modificarse almenos una vez dentro del cuerpo del subprograma, ya que es la información que generará elsubprograma. 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 generadapor el subprograma después de la llamada, el parámetro real de la llamada debe ser una variableo valorL que haga referencia a una posición de memoria donde se guardará el resultado. Se diceque se pasan por referencia. La definición del parámetro formal utiliza el carácter ‘&’ detrás deltipo:

tipo Subprograma( ..., tipo & param_formal, ...)

Sin embargo, los parámetros reales de entrada pueden ser cualquier expresión compatible conel correspondiente parámetro formal. En realidad, se crea una copia nueva del parámetro real, yaque 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


para que el compilador avise cuando se modifique un parámetro de entrada, lo que normalmenteno es necesario5:

tipo Subprograma( ..., const tipo param_formal, ...)

Una tercera posibilidad, habitual en el paso de variables de tipo compuesto de entrada, espasarlos por referencia constante. Esto evita la sobrecarga de la copia innecesaria de registros quepodrí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 sedebe poner tanto la palabra const como el carácter & en la definición del parámetro formal (versección 13.1).

13. Tipos definidos por el programadorSon 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 especificarel 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 conla sentencia typedef. En una sentencia posterior se utilizará ese nombre para definir las variablesde ese tipo compuesto como un tipo predefinido. Pero C/C++ admiten la definición de arrays deforma implícita, sin nombre, en la misma sentencia que se define la variable, como veremos en lasección 13.2.

13.1. RegistrosUn 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 campodentro 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 palabrareservada struct propia de los registros. A continuación y entre llaves {} se define cada campocon su tipo como si fueran variables locales al registro.

// definicion del tipo registrotypedef 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:

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

14


// definicion de 3 registrosTPersona empleado, directivo, becario;

// los campos se pueden inicializar por orden de definicionTPersona maquinista = {

12345678,"Pepito Grillo","C/La que sea, 3, Villarriba de Abajo",1.83, // metros95.3 // kilos

};

Y la definición de registros constantes es muy parecida a la de los registros variables, pero conla 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 mismotipo. Se acceden con el nombre común del registro, el operador de acceso ‘.’ y el nombre del camposin 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 typedefy el nombre del tipo registro cambia de posición:

// definicion del tipo registrostruct DatosPersona { // nombre del tipo nuevo

int dni;string nombre;string domicilio;float estatura;float peso;

};

// definicion de 3 registrosDatosPersona 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


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 tipopredefinido. 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 entradavoid Subprograma(const TPersona persona) // por valorvoid Subprograma(TPersona persona) // por valorvoid Subprograma(DatosPersona persona) // por valorvoid Subprograma(const TPersona & persona) // por ref. cte.

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

13.2. ArraysUn 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 formaque cada valor del array se identifica de forma única con el nombre del array y por su índice. EnC/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 índicede cada posición debajo.

-12 1 55 0 -54 72 -6 -88 523 320 1 2 3 4 5 6 7 8 9

Al igual que con los registros, para utilizar arrays primero hay que definir el tipo array. Despuésse definirán todos los arrays que se vayan a utilizar como variables, ya que el tipo no especifica nireserva ninguna posición de memoria, sino sólo la estructura de una variable de tipo array. En ladefinición del tipo array, además de indicar el tipo base, hay que indicar la longitud máxima entiempo de compilación, es decir, esta longitud debe ser una expresión constante, por lo que sonestructuras estáticas6.

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óncompleta 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, ysuelen 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úmerode elementos, o con la función sizeof en número de bytes, tal como se muestra en el siguienteejemplo. Nótese la diferencia en la notación entre ambas funciones, ya que la primera es unafunción de biblioteca, y la segunda es propia de C/C++.

6Existen también en C++ arrays dinámicos que permiten indicar la longitud en tiempo de ejecución usando eloperador new.

7Es posible que se necesite activar la correspondiente opción al compilar, -std=c++0x.

16


#include <array> // necesaria en el estandar C++ 2011.using namespace std;

const unsigned MaxZs=1000; // longitud maximatypedef array <int,MaxZs> TZs; // el nuevo tipo array es TZs

int main(){TZs array1; // variable array sin inicializarTZs array2 = {0,1,2}; // inicializadas solo 3 primeras posiciones...cout <<"Numero de elementos: " <<array1.size() <<endl;cout <<"Numero de bytes: " <<sizeof(array1) <<endl;...

Acceso a componentes individuales

Para acceder a una determinada posicíon se escribe el nombre del array (la variable, no el tipo)seguido por el índice entre corchetes: a[0], a[1], a[2]...

El índice puede ser cualquier expresión entera, pero ¡ojo! el resultado debe estardentro del rango de valores que admita la longitud del array.

Una alternativa para acceder a elementos de un array chequeando el rango de errores es con eloperador at: a.at(0), a.at(1), a.at(2)... Esta alternativa sí chequea los errores de rango.

Con una componente individual se puede realizar todas las operaciones que admita el tipobase, por ejemplo, si el tipo base es int, los componentes se pueden sumar, comparar, asignar,pasar como parámetros, leer de teclado, etc.

Acceso a componentes individuales

Además del acceso individual, también se pueden hacer las siguientes operaciones con un arrayscompletos independientemente del tipo base de sus componentes:

Asignación de arrays. Cada componente del array fuente (valor-R) se asignan al correspon-diente componente del array destino (valor-L). Por ejemplo, la sentencia

array_destino = array_fuente;produciría las asignaciones de todas las componentes individuales:

... array_destino↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑-12 1 55 0 -54 72 -6 -88 523 ... array_fuente

Paso como parámetro a un subprograma, ya sea de entrada, salida o entrada/salida. Losarrays de salida y entrada/salida se deben pasar por referencia; pero los arrays de entradase pueden pasar por valor, sin evitar la copia completa del array, o por referencia constante,si se desea evitar la copia8.

Valor devuelto por una función con la correspondiente sentencia return9.8Los arrays tradicionales de C/C++ siempre se pasaban por referencia, en cambio, la asignación de arrays C++

2011 permite también el paso por valor para crear la copia del parámetro real en el parámetro formal. No obstante,es más eficiente pasar un array de entrada por referencia constante.

9La asignación es la que también posibilita la devolución completa de un array como valor de una función.

17


La entrada/salida de arrays completos mediante cin y cout de la biblioteca <iostream>no es posible, por lo que hay que hacerlo componente a componente.

Los siguientes ejemplos ilustran estas operaciones.

/** Paso de un array (por referencia) como parametro de salida.

* Lectura de enteros por teclado hasta introducir un 0.

*/int LeerZs(TZs &a){int nleidos=0;int numero;

cin >>numero;while (nleidos<MaxZs && numero!=0) {

// 0 es el centinela, no se almacenaa[nleidos] = numero;cin >>numero;nleidos++;

}return nleidos;

}

/** Paso de un array (por ref. cte.) como parametro de entrada.

* Escritura en pantalla de los n primeros elementos de un array.

*/void EscribirZs(const TZs &a, const int n){int i;// n debe ser menor que MaxTZsfor (i=0; i<n; i++) {

cout<< a[i]<< ’ ’;}cout <<endl;

}

/** Devolucion de un array como valor de una funcion.

* Suma de dos arrays componente a componente.

*/TZs SumarZs(const TZs &a1, const TZs &a2, const int n){TZs suma; // para devolver en el returnint i;// n debe ser menor que MaxTZsfor (i=0; i<n; i++) {

suma[i] = a1[i] + a2[i];}return suma;

}

18


/** Paso de un array (por referencia) como parametro de e/s.

* Invertir los n primeros elementos de un array.

*/void VoltearZs(TZs &a, const int n){int i=0, temp;// n debe ser menor que MaxTZs// si n es impar, el elemento central no hace falta moverlofor (i=0; i<n/2; i++) {

temp = a[i];a[i] = a[n-i-1];a[n-i-1] = temp;

}}

/** Suma 3 series de numeros enteros.

* Despues se invierten los componentes de las 2 primeras.

*/int main(){TZs serie1, serie2, suma;int long1, long2, long_menor;// una de las series es un array constanteconst TZs serie3 = { 1, 1, 1, 1, 1};const int long3 = 5;

// lectura de numeros enteroscout<< "Primera serie de enteros (fin-> 0): ";long1 = LeerZs(serie1);cout<< "Segunda serie de enteros (fin-> 0): ";long2 = LeerZs(serie2);

// solo se suma hasta la longitud menorlong_menor = long1<long2 ? long1 : long2;suma = SumarZs(serie1, serie2, long_menor);// sumamos tambien el array constantelong_menor = long_menor<long3 ? long_menor : long3;suma = SumarZs(suma, serie3, long_menor);cout << "La suma total es: ";EscribirZs(suma, long_menor);

// voltear las series leidas por tecladoVoltearZs(serie1, long1);VoltearZs(serie2, long2);cout << "Serie primera volteada: ";EscribirZs(serie1, long1);cout << "Serie segunda volteada: ";EscribirZs(serie2, long2);

}

19


Arrays multidimensionales

Puesto que el tipo base de un array puede ser cualquiera, cada componente puede ser a su vezotro array, con lo que tendríamos un array bidimensional. Las definiciones siguientes definen untipo para matrices no necesariamente cuadradas. Observa que el tipo base del tipo TMatriz esun array vector fila.

// dimensiones de la matrizconst unsigned NE = 2; // numero de columnasconst unsigned NF = 3; // numero de filastypedef array <float,NE> TFila;typedef array <TFila,NF> TMatriz;

Los siguientes subprogramas ilustran un manejo básico de suma de matrices. Por supuesto,para acceder ahora a una posición individual se necesita especificar un índice por cada una de las2 dimensiones.

/** Lectura de una matriz completa por teclado.

* Se pasa la matriz como parametro de salida.

*/void LeerMatriz(TMatriz &m){int j, k;for (j=0; j<NF; j++) {

for (k=0; k<NE; k++) {cin >>m[j][k];

}}

}

/** Escritura en pantalla de una matriz completa.

* Se pasa la matriz como parametro de entrada.

*/void EscribirMatriz(const TMatriz &m){for (int j=0; j<NF; j++) {

for (int k=0; k<NE; k++) {cout <<m[j][k] <<’ ’;

}cout <<endl;

}}

20


/** Suma de 2 matrices elemento a elemento.

* Se pasan las matrices como parametro de entrada y el resultado

* se devuelve como valor de la funcion.

*/TMatriz SumarMatrices(const TMatriz &m1, const TMatriz &m2){TMatriz suma;int j, k;for (j=0; j<NF; j++) {

for (k=0; k<NE; k++) {suma[j][k] = m1[j][k] + m2[j][k];

}} return suma;

}


* El primer parametro es de entrada/salida: la matriz original.

* El segundo parametro es de entrada y se suma a la original.

*/void AcumularMatriz(TMatriz &original, const TMatriz &m){for (int j=0; j<NF; j++) {

for (int k=0; k<NE; k++) {original[j][k] += m[j][k];

}}

}


* Las 2 primeras se suman con SumarMatrices(), y

* la 3ra. se suma con AcumularMatriz().

*/int main(){TMatriz msuma, m1, m2;const TMatriz m3 = {10, 10, 10, 10, 10, 10}; // esta no se lee.

cout <<"Introduce primera matriz de " <<NF<<"x"<<NE<<": ";LeerMatriz(m1);cout <<"Introduce segunda matriz de " <<NF<<"x"<<NE<<": ";LeerMatriz(m2);msuma = SumarMatrices(m1, m2);AcumularMatriz(msuma, m3);EscribirMatriz(msuma);

}

21


El siguiente ejemplo ilustra la suma de tensores, los cuales pueden representarse con arraystridimensionales, donde el tipo base de cada componente es una matriz. Nótese que se puedereutilizar algunos de los subprogramas de matrices definidos en el ejemplo anterior.

// dimensiones del tensorconst unsigned NE = 2; // numero de columnasconst unsigned NF = 3; // numero de filasconst unsigned NC = 2; // numero de capastypedef array <float,NE> TFila;typedef array <TFila,NF> TMatriz;typedef array <TMatriz,NC> TTensor;

void LeerTensor(TTensor &t){for (int i=0; i<NC; i++) {

// lee una matriz completa del tensorLeerMatriz(t[i]);

}}

void EscribirTensor(const TTensor &t){for (int i=0; i<NC; i++) {

EscribirMatriz(t[i]);cout <<endl;

}}

TTensor SumarTensores(const TTensor &t1, const TTensor &t2){TTensor suma;for (int i=0; i<NC; i++) {

// suma de matricessuma[i] = SumarMatrices(t1[i], t2[i]);

}return suma;

}

int main(){TTensor t1, t2, tsuma;const TTensor t3 = {1,1, 2,2, 3,3, 4,4, 5,5, 6,6};

cout <<"Introduce primer tensor de " <<NC<<’x’<<NF<<’x’<<NE<<": ";LeerTensor(t1);cout <<"Introduce otro tensor de " <<NC<<’x’<<NF<<’x’<<NE<<": ";LeerTensor(t2);tsuma = SumarTensores(t1, t2);tsuma = SumarTensores(tsuma, t3);EscribirTensor(tsuma);

}

22


Cadenas

En C++ existe la clase string que se puede utilizar como tipo de datos para almacenarcadenas de caracteres. Está definida en la biblioteca estándar <string> que además dispone demuchas funciones para realizar operaciones con cadenas sin tener que programarlas. Las cadenasde tipo string pueden asignarse, pasarse como parámetros por valor y por referencia, y puedendevolverse como valor de una función.

En la sección 3 del anexo puede consultarse algunas de las funciones habituales que ofrece estaclase. En este caso las cadenas son objetos y la sintaxis para las llamadas utilizan el operador ‘.’como si el objeto (la cadena) fuese un registro.

13.3. AnidamientosTanto el tipo base de un array, como el de los campos de un registro pueden ser de tipo com-

puesto, posibilitando la definición y uso de muchos tipos de estructuras de datos. A continuaciónse muestran dos posibilidades habituales.

Anidamientos dentro de registros. En estos casos el tipo de uno de los campos es otro tipocompuesto previamente definido.

typedef struct {dia, mes, anio;

} TFecha; // definicion del tipo TFecha

typedef struct {int dni;string nombre;string domicilio;TFecha f_nacim;float estatura;float peso;

} TJugador; // definicion del tipo TJugador

TJugador delantero; // definicion del registro delantero

// accesos posibles... delantero.nombre ... // nombre del delantero... delantero.f_nacim ... // registro con fecha de nacimiento... delantero.f_nacim.dia ... // dia de nacimiento del delantero... delantero.f_nacim.mes ... // mes de nacimiento del delantero

Anidamientos dentro de arrays. Aquí simplemente se pone como tipo base del array otrotipo compuesto previamente definido.

// definicion del tipo array para un maximo de 20 jugadorestypedef array <TJugador,20> TEquipo;

// definicion de 2 arrays de 20 jugadores como maximoTEquipo visitante, locales;

// accesos posibles... visitante[0].nombre ... // nombre primer jugador visitante... visitante[0].f_nacim ... // fecha de nacimiento completa... visitante[i].f_nacim.anio ... // nacimiento del jugador i...

23

Apéndice A

Bibliotecas estándares de C++

1. Entrada/salidaEn C++ la escritura en pantalla y lectura de teclado se manejan con los flujos estándares

de entrada/salida, que son objetos, y como tales, las llamadas a sus operaciones (o métodos) serealizan con el operador de acceso ’.’.

El flujo estándar de entrada es cin y, por defecto es el teclado, aunque desde el sistemaoperativo (sin modificar el programa) puede redirigirse a un fichero o a otro dispositivo. Los flujosde salida son cout, que es la salida estándar, y cerr, que es la salida de errores. Al igual que elflujo de entrada, ambos pueden redirigirse desde el sistema operativo de forma separada.

#include <iostream>

Entrada de números o caracteres saltando espacios precedentes:cin >> variable >> variable >> ...

Salto de los espacios pendientes de leer:cin >> ws

Lectura de un carácter sin saltar espacios:char c = cin.get()

Lectura de una línea completa en un array de un máximo de max caracteres:getline(cin, cad)cin.getline(cad)cin.getline(cad, max)

Salida de números o caracteres:cout << expresion << expresion << ...cerr << expresion << expresion << ...

Vaciado de la salida pendiente:cout << flushcerr << flush

Envío a la salida de un salto de línea:cout << endlcerr << endl

2. FicherosEn C++ los ficheros se consideran flujos (stream) como los flujos estándares cin y cout, por

lo que su manejo es muy similar a éstos.

24

Apéndice A. Bibliotecas estándares de C++ 25

#include <fstream>

Definición de flujosifstream fi fichero de entradaofstream fo fichero de salidafstream f fichero de entrada/salidaApertura y cierre de flujosfi.open("nombre.dat") modo de entradafo.open("nombre.dat") modo de salidaf.open("nombre.dat", ios::in) modo de entradaf.open("nombre.dat", ios::out) modo de salidaf.open("nombre.dat", ios::binary) modo binariofo.open("nombre.dat", ios::app) modo salida para añadir al finalf.open("nombre.dat", ios::in|ios::out) modo de entrada/salidaf.close() cierre del flujo fLectura y escritura en flujosf >> variable >> variable >> ... lectura del flujo ff.get(c) lectura de un carácterf.getline(cadena, tam) lectura de una línea f

(máximo tam caracteres)f << expresion << expresion << ... escritura en el flujo f

25

Apéndice A. Bibliotecas estándares de C++ 26

3. CadenasEn C++ las cadenas pueden manejarse como arrays de caracteres al estilo de C, o como objetos

de la clase string. En particular, los siguientes ejemplos dan una idea de la potencia de la clasestring de C++.

#include <string>

Definiciónstring s, s1, s2 Define las cadenas s, s1 y s2.string s2="vinicial" Define la cadena s2 y la inicializa.string s(s2) Define la cadena s y la inicializa con s2.Entrada/salidacin >> s Lee una cadena de teclado en s saltando los espacios.getline(cin,s) Lee una línea de teclado en s.cout << s Imprime en pantalla s.Longitud y acceso individuals.length() Devuelve la longitud efectiva (tipo int) de s.c = s[0] Pone en la variable c (char) el primer carácter de s.c = s[s.length()-1] Pone en c el último carácter de s.Asignacións = "valor" Asigna la cadena valor a s.s[i] = c Pone en s[i] el carácter c.s = s2 Asigna la cadena s2 a s.s += s2 Concatena la cadena s2 al final de s.s = s1 + s2 Asigna a s la concatenación de s1 y s2.s.append(s1+s2) Añade a s la concatenación de s1 y s2.Comparacioness == s2 Devuelve true si s y s2 son iguales.s < s2 Devuelve true si s es menor que s2 por orden ascii.r = s.compare(5,3,s2) Pone en r (int) el valor 0 si s==s2, -1 si s<s2, y +1 si s>s2.Búsqueda y sustituciónpos = s.find(s2) Devuelve la posición (int) donde empieza la subcadena s2 dentro

de s.s2 = s.substr(5,3) Devuelve en s2 la subcadena de 3 caracteres de s que empieza en

la posición 5.s.replace(5,3,s2) Reemplaza los 3 caracteres de s que empiezan en la posición 5

por la cadena s2.s.insert(5,s2) Inserta en s a partir de la posición 5 la cadena s2.

La clase string también tiene métodos (subprogramas) para convertir y trabajar con arraysde caracteres equivalentes al estilo de C.

26

Apéndice B

Bibliotecas estándares de C

En C++ se pueden declarar sus cabeceras (headers) bien al estilo C:

#include <biblioteca.h>

o bien al estilo propio de C++, formando parte del espacio de nombres estándar:

#include <cbiblioteca>using namespace std;

1. Entrada/salida

#include <cstdio>

scanf(formato, &arg1, &arg2, ...) Entrada de teclado.printf(formato, arg1, arg2, ...) Salida en pantalla.

2. Clasificación de caracteres

#include <cctype>

isalnum(caracter) Devuelve verdadero si es alfanumérico.isalpha(caracter) Devuelve verdadero si es alfabético.iscntrl(caracter) Devuelve verdadero si es dígito de control.isdigit(caracter) Devuelve verdadero si es dígito.isgraph(caracter) Devuelve verdadero si es carácter.islower(caracter) Devuelve verdadero si es minúscula.isupper(caracter) Devuelve verdadero si es mayúscula.isspace(caracter) Devuelve verdadero si es ‘ ’, ‘\f’, ‘\n’, ‘\r’, ‘\t’ o ‘\v’.isprint(caracter) Devuelve verdadero si es imprimible.ispunct(caracter) Devuelve verdadero si es especial.isxdigit(caracter) Devuelve verdadero si es dígito hexadecimal.tolower(caracter) Devuelve el carácter en minúsculas.toupper(caracter) Devuelve el carácter en mayúsculas.

27

Apéndice B. Bibliotecas estándares de C 28

3. Matemática

#include <cmath>

sqrt(x) Devuelve√x.

exp(x) Devuelve ex.log(x) Devuelve loge(x).log10(x) Devuelve log10(x).pow(base, expo) Devuelve baseexpo.fabs(x) Devuelve |x| ∈ R.floor(x) Devuelve bxc.ceil(x) Devuelve dxe.sin(alfa) Devuelve sin(alpha).cos(alfa) Devuelve cos(alpha).tan(alfa) Devuelve tan(alpha).asin(x) Devuelve sin−1(x) en el rango [−π/2, π/2].acos(x) Devuelve cos−1(x) en el rango [0, π].atan(x) Devuelve tan−1(x) en el rango [−π/2, π/2].atan(y,x) Devuelve tan−1(y/x) en el rango [−π, π].

Todas devuelven un número real de tipo double. Y las trigonométricas trabajan con ángulosen radianes.

4. Utilidades estándares

#include <cstdlib>

atoi(cadena) Convierte la cadena a un número entero.atof(cadena) Convierte la cadena a un número real.rand() Devuelve un número aleatorio entre 0 y RAND_MAX.srand(semilla) Inicializa la secuencia de números aleatorios (semilla de tipo int).exit(status) Termina el programa devolviendo status de tipo int.system(cadena) Ejecuta cadena en la línea de comandos del sistema.abs(x) Devuelve |x| ∈ Z.

28

fundamentos de informática sintaxis básica de c/c++ · de las posibles obras derivadas, la...

Documents