UNIVERSIDAD DE MA´LAGA

Dpt. Lenguajes y CC. Computaci´on

E.T.S.I. Inform´atica
Ingenier´ıa Inform´atica

Fundamentos de Programaci
´on con
el Lenguaje de Programacio´n
C++

Vicente Benjumea Manuel Rold

´an 6 de julio de 2011

2

Este obra est ´a bajo una licencia Reconocimiento-NoComercial-CompartirIgual 3.0

Un- ported de Creative Commons: No se permite un uso comercial de la obra
original ni de las posibles obras derivadas, la distribuci´on 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,
visite http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es ES o envie una carta a Creative Com-
mons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.

Usted es libre de:

• Copiar, distribuir y comunicar pu´blicamente la obra.

• Hacer obras derivadas.
Bajo las siguientes condiciones:

• Reconocimiento (Attribution) – Debe reconocer los cr´editos 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´ol o puede distribuir la obra generada bajo una
licencia id´entica a ´esta.
Entendiendo que:

• Renuncia – Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del

titular de los derechos de autor

• Dominio Pu´blico – Cuando la obra o alguno de sus elementos se halle en el dominio

pu´blico segu´n la ley vigente aplicable, esta situaci´on no quedar´a 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´erminos de la
licencia de esta obra.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 ´Indice general

Pr´ologo................................................................................................................................................9

I Programaci´on B´asica 11
1. Un Programa C++ 13

2. Tipos Simples 17
2.1. Declaraci´on Vs. Definici´on............................................................................................................................17
2.2. Tipos Simples Predefinidos.................................................................................................................................17
2.3. Tipos Simples Enumerados.................................................................................................................................19
2.4. Constantes y Variables.......................................................................................................................................20
2.5. Operadores 21
2.6. Conversiones Autom´aticas (Impl´ıcitas) de Tipos..........................................................................................23
2.7. Conversiones Expl´ıcitas de Tipos.......................................................................................................................23
2.8. Tabla ASCII 25
2.9. Algunas Consideraciones Respecto a Operaciones con Nu´meros Reales....................................................25

3. Entrada y Salida de Datos B´asica 27

3.1. Salida de Datos....................................................................................................................................................27
3.2. Entrada de Datos................................................................................................................................................29
3.3. El “Buffer” de Entrada y el “Buffer” de Salida..............................................................................................30
3.4. Otras Operaciones de Entrada y Salida...........................................................................................................30
3.5. Control del Estado del Flujo de Datos.............................................................................................................30

4. Estructuras de Control 33
4.1. Sentencia, Secuencia y Bloque...........................................................................................................................33
4.2. Declaraciones Globales y Locales.......................................................................................................................33
4.3. Sentencias de Asignaci´on.................................................................................................................................34
4.4. Sentencias de Selecci´on....................................................................................................................................35
4.5. Sentencias de Iteraci´on. Bucles........................................................................................................................37
4.6. Programaci´on Estructurada.............................................................................................................................39
4.7. Ejemplos 39

5. Subprogramas. Funciones y Procedimientos 41

5.1. Funciones y Procedimientos...............................................................................................................................41
5.2. Definici´on de Subprogramas..............................................................................................................................42
5.3. Ejecuci´on de Subprogramas...............................................................................................................................43
5.4. Paso de Par´ametros. Par´ametros por Valor y por Referencia..................................................................43
5.5. Criterios de Modularizaci´on............................................................................................................................45
5.6. Subprogramas “en L´ınea”.................................................................................................................................46
5.7. Declaraci´on de Subprogramas. Prototipos......................................................................................................46
5.8. Sobrecarga de Subprogramas y Operadores.....................................................................................................46
5.9. Par´ametros por Defecto....................................................................................................................................47

3
 ´INDICE GENERAL 1

5.10. Subprogramas y Flujos de Entrada y Salida...................................................................................................48

5.11. Pre-Condiciones y Post-Condiciones.................................................................................................................48
5.12. Ejemplos 49

6. Tipos Compuestos 51
6.1. Paso de Par´ametros de Tipos Compuestos....................................................................................................51
6.2. Cadenas de Caracteres en C++: el Tipo String.............................................................................................52
6.3. Registros o Estructuras.......................................................................................................................................59
6.4. Agregados: el Tipo Array...................................................................................................................................62
6.5. Resoluci´on de Problemas Utilizando Tipos Compuestos...............................................................................71

7. Bu´squeda y Ordenaci´on 77
7.1. Bu´squeda Lineal (Secuencial)...........................................................................................................................77
7.2. Bu´squeda Binaria..............................................................................................................................................78
7.3. Ordenaci´on por Intercambio (Burbuja)...........................................................................................................79
7.4. Ordenaci´on por Selecci´on..............................................................................................................................80
7.5. Ordenaci´on por Inserci´on..............................................................................................................................80
7.6. Ordenaci´on por Inserci´on Binaria...................................................................................................................81
7.7. Aplicaci´on de los Algoritmos de Bu´squeda y Ordenaci´on......................................................................82

8. Otros Tipos Compuestos en C 87

8.1. Agregados o Arrays Predefinidos......................................................................................................................87
8.2. Cadenas de Caracteres al Estilo-C....................................................................................................................98
8.3. Uniones 104
8.4. Campos de Bits..................................................................................................................................................105
8.5. Resoluci´on de Problemas Utilizando Tipos Compuestos............................................................................105

9. Algunas Bibliotecas U´ tiles 111

II Programaci´on Intermedia 113

10.Almacenamiento en Memoria Secundaria: Ficheros 115
10.1. Flujos de Entrada y Salida Asociados a Ficheros.........................................................................................116
10.2. Entrada de Datos desde Ficheros de Texto....................................................................................................117
10.3. Salida de Datos a Ficheros de Texto...............................................................................................................119
10.4. Ejemplos 121
10.5. Otros Tipos de Flujos de Ficheros..................................................................................................................126
10.5.1. Ficheros Binarios 126
10.5.2. Acceso Directo en Ficheros..............................................................................................................................129
10.5.3. Flujos de Entrada y Salida...............................................................................................................................130
10.6. Flujos de Entrada y Salida Vinculados a Cadenas de Caracteres..............................................................130

11. M´odulos y Bibliotecas 133

11.1. Interfaz e Implementaci´on del M´odulo......................................................................................................133
11.2. Compilaci´on Separada y Enlazado.................................................................................................................135
11.3. Espacios de Nombre..........................................................................................................................................136
11.4. Herramientas de Ayuda a la Gesti´on de la Compilaci´on Separada.........................................................141

12. Manejo de Errores. Excepciones 145

12.1. Errores de Programaci´on y Asertos...............................................................................................................145
12.2. Situaciones An´omalas Excepcionales.............................................................................................................146
12.3. Gesti´on de Errores Mediante Excepciones....................................................................................................147
12.4. Excepciones Est´andares.................................................................................................................................152
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 2 ´INDICE GENERAL

13. Tipos Abstractos de Datos 155

13.1. Tipos Abstractos de Datos en C++: Clases..................................................................................................156
13.1.1. Definici´on e Implementaci´on de Clases “en L´ınea”..................................................................................156
13.1.2. Definici´on de Clases e Implementaci´on Separada......................................................................................159
13.2. M´etodos Definidos Autom´aticamente por el Compilador..........................................................................172
13.3. Requisitos de las Clases Respecto a las Excepciones....................................................................................173
13.4. M ´as sobre M´etodos y Atributos.....................................................................................................................173
13.5. Sobrecarga de Operadores..................................................................................................................................177

14.Introducci´on a la Programaci´on Gen´erica. Plantillas 179

14.1. Subprogramas Gen´ericos................................................................................................................................179
14.2. Tipos Abstractos de Datos Gen´ericos...........................................................................................................181
14.3. Par´ametros Gen´ericos por Defecto.................................................................................................................184
14.4. Definici´on de Tipos dentro de la Definici´on de Tipos Gen´ericos..........................................................185
14.5. Separaci´on de Definici´on e Implementaci´on............................................................................................186

15. Memoria Din´amica. Punteros 191

15.1. Punteros 192
15.2. Gesti´on de Memoria Din´amica....................................................................................................................193
15.3. Operaciones con Variables de Tipo Puntero.................................................................................................194
15.4. Paso de Par´ametros de Variables de Tipo Puntero....................................................................................196
15.5. Abstracci´on en la Gesti´on de Memoria Din´amica.................................................................................197
15.6. Estructuras Enlazadas.......................................................................................................................................198
15.7. Operaciones con Listas Enlazadas...................................................................................................................200
15.8. Gesti´on de Memoria Din´amica en Presencia de Excepciones..................................................................207
15.9. Comprobaci´on de Gesti´on de Memoria Din´amica..................................................................................217
15.10. Operador de Direcci´on.........................................................................................................218

16.Introducci´on a los Contenedores de la Biblioteca Est´andar (STL) 221

16.1. Vector 221
16.2. Stack 225
16.3. Queue 227
16.4. Resoluci´on de Problemas Utilizando Contenedores.....................................................................................229

III Programaci´on Avanzada 233

17. Programaci´on Orientada a Objetos 237

18.Memoria Din´amica Avanzada 241

18.1. Memoria Din´amica de Agregados...................................................................................................................241
18.2. Punteros a Subprogramas................................................................................................................................242
18.3. Punteros Inteligentes.........................................................................................................................................242

19.Tipos Abstractos de Datos Avanzados 245

19.1. Punteros a Miembros.......................................................................................................................................245
19.2. Ocultar la Implementaci´on..........................................................................................................................245
19.3. Control de Elementos de un Contenedor......................................................................................................250

20. Programaci´on Gen´erica Avanzada 255

20.1. Par´ametros Gen´ericos por Defecto................................................................................................................255
20.2. Tipos dentro de Clases Gen´ericas..................................................................................................................255
20.3. M´etodos de Clase Gen´ericos.........................................................................................................................255
20.4. Amigos Gen´ericos............................................................................................................................................256
20.5. Restricciones en Programaci´on Gen´erica....................................................................................................257
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 ´INDICE GENERAL 3

20.6. Especializaciones...............................................................................................................................................258
20.7. Meta-programaci´on.......................................................................................................................................259
20.8.SFINAE 260

21. Buffer y Flujos de Entrada y Salida 263

21.1. Operaciones de Salida.......................................................................................................................................263
21.2. Operaciones de Entrada....................................................................................................................................263
21.3. Buffer 265
21.4. Redirecci´on Transparente de la Salida Est´andar a un String.................................................................267
21.5. Ficheros 268
21.6. Ficheros de Entrada..........................................................................................................................................268
21.7. Ficheros de Salida.............................................................................................................................................269
21.8. Ejemplo de Ficheros.........................................................................................................................................269
21.9. Ficheros de Entrada y Salida...........................................................................................................................270
21.10. Flujo de Entrada desde una Cadena.....................................................................................270
21.11. Flujo de Salida a una Cadena...............................................................................................270
21.12. Jerarqu´ıa de Clases de Flujo Est´andar.............................................................................271

22. T´ecnicas de Programaci´on Usuales en C++ 273

22.1. Adquisici´on de Recursos es Inicializaci´on (RAII)......................................................................................273
22.1.1. auto ptr (unique ptr) 273
22.1.2. RAII Simple de Memoria Din´amica............................................................................................................274
22.1.3. RAII Simple Gen´erico.....................................................................................................................................275
22.1.4. RAII Gen´erico 276
22.1.5. RAII Gen´erico 276

23. Gesti´on Din´amica de Memoria 279

23.1. Gesti´on de Memoria Din´amica...................................................................................................................279
23.2. Gesti´on de Memoria Din´amica sin Inicializar............................................................................................282
23.3. RAII: auto ptr....................................................................................................................................................282
23.4. Comprobaci´on de Gesti´on de Memoria Din´amica.................................................................................283

24. Biblioteca Est´andar de C++. STL 285

24.1. Caracter´ısticas Comunes..................................................................................................................................285
24.1.1. Ficheros 285
24.1.2. Contenedores 286
24.1.3. Tipos Definidos 286
24.1.4. Iteradores 286
24.1.5. Acceso 287
24.1.6. Operaciones de Pila y Cola..............................................................................................................................287
24.1.7. Operaciones de Lista 287
24.1.8. Operaciones 287
24.1.9. Constructores 287
24.1.10. Asignaci´on................................................................................................................288
24.1.11. Operaciones Asociativas.............................................................................................288
24.1.12. Resumen......................................................................................................................288
24.1.13. Operaciones sobre Iteradores.....................................................................................288
24.2. Contenedores 288
24.3. Vector 289
24.4. List 290
24.5. Deque 293
24.6. Stack 294
24.7. Queue 295
24.8. Priority-Queue...................................................................................................................................................296
24.9. Map............................................................................................................................................296
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 4 ´INDICE GENERAL

24.10.Multimap.................................................................................................................................297
24.11.Set..............................................................................................................................................298
24.12.Multiset 299
24.13.Bitset 299
24.14.Iteradores 300
24.15.Directos 300
24.16.Inversos 301
24.17.Inserters 302
24.18. Stream Iterators.......................................................................................................................302
24.19.Operaciones sobre Iteradores...........................................................................................................................306
24.20. Objetos Funci´on y Predicados............................................................................................306
24.21.Algoritmos 309
24.22. Garant´ıas (Excepciones) de Operaciones sobre Contenedores............................................311
24.23. Num´ericos..............................................................................................................................312
24.24. L´ımites....................................................................................................................................312
24.25. Run Time Type Information (RTTI)....................................................................................313

A. Precedencia de Operadores en C 315

B. Precedencia de Operadores en C++ 317

C. Biblioteca B´asica ANSI-C (+ conio) 321

C.1. cassert........................................................................................................................................321
C.2. cctype.........................................................................................................................................321
C.3. cmath..........................................................................................................................................321
C.4. cstdlib........................................................................................................................................322
C.5. climits........................................................................................................................................323
C.6. cfloat..........................................................................................................................................323
C.7. ctime..........................................................................................................................................323
C.8. cstring........................................................................................................................................323
C.9. cstdio..........................................................................................................................................324
C.10. cstdarg.......................................................................................................................................325
C.11. conio.h.......................................................................................................................................326

D. El Preprocesador 329

E. Errores M´a s Comunes 331

F. Caracter´ısticas no Contempladas 333

G. Bibliograf´ıa 335
´Indice 335

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

´INDICE GENERAL 5

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Pr´ologo

Este manual pretende ser una gu´ıa de referencia para la utilizaci´on del lenguaje de programaci
´on C++ en el desarrollo de programas. Es t ´a orientada a alumnos de primer curso de
programaci´on de Ingenier´ıa Inform´atica. No obstante, hay algunos cap´ıtulos y secciones que
presentan conceptos avanzados y requieren mayores conocimientos por parte del lector, y por lo
tanto exceden de los conocimientos b´asicos requeridos para un alumno de primer curso de
programaci´on. Estos cap´ıtulos y secciones que presentan o requieren conceptos avanzados se
encuentran marcados con un s´ımbolo A , y no es necesario que sean le´ıdos por el lector, a los
cuales po dr´a acceder en cualquier otro momento posterior. Otros cap´ıtulos y secciones
muestran estructuras y t´ecnicas de programaci´on obsoletas y no recomendadas en C++, sin
embargo son mostradas en este manual por completitud.
Estos cap´ıtulos y secciones est´an marcados con el s´ımboloOBS .
Este manual se concibe como material de apoyo a la docencia, y requiere de las explicaciones
im- partidas en clase por el profesor para su aprendizaje. As´ı mismo, este manual no pretende
“ensen˜ar a programar”, supone que el lector posee los fundamentos necesarios relativos a la
programaci´on, y simplemente muestra como aplicarlos utilizando el Lenguaje de Programaci
´on C++.
El lenguaje de programaci´on C++ es un lenguaje muy flexible y vers´atil, y debido a ello,
si se utiliza sin rigor puede dar lugar a construcciones y estructuras de programaci´on complejas, dif
´ıciles de comprender y propensas a errores. Debido a ello, restringiremos tanto las estructuras a
utilizar como la forma de utilizarlas.
No pretende ser una gu´ıa extensa del lenguaje de programaci´on C++. Adem´as, dada la
amplitud del lenguaje, hay caracter´ısticas del mismo que no han sido contempladas por exceder
lo que entendemos que es un curso de programaci´on elemental.
Este manual ha sido elaborado en el Dpto. de Lenguajes y Ciencias de la Computaci´on de la
Universidad de M´alaga.
ES UNA VERSIO´ N PRELIMINAR, INCOMPLETA Y SE ENCUENTRA AC-
TUALMENTE BAJO DESARROLLO. Se difunde en la creencia de que puede ser u´ til, a u´ n
siendo una versi´on preliminar.
La u´ltima versi´on de este documento puede ser descargada desde la siguiente p´agina web:
http://www.lcc.uma.es/%7Evicente/docencia/index.html

o directamente desde la siguiente direcci´on:

http://www.lcc.uma.es/%7Evicente/docencia/cpp/manual_referencia_cxx.pdf

1
1 ´INDICE GENERAL

1
 Parte I

Programacio´n B´asica

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 1

Un Programa C++

En principio, un programa C++ se almacena en un fichero cuya extensi´on ser´a una de las
sigu- ientes: “.cpp”, “.cxx”, “.cc”, etc. M ´a s adelante consideraremos programas complejos cuyo
c´odigo se encuentra distribuido entre varios ficheros (v´ease 11).
Dentro de este fichero, normalmente, aparecer´an al principio unas l´ıneas para incluir las
defini- ciones de los m´odulos de biblioteca que utilice nuestro programa. Posteriormente, se
realizar´an declaraciones y definiciones de tipos, de constantes (v´ease 2) y de subprogramas (v
´ease 5) cuyo
´ambito de visibilidad ser ´a global a todo el fichero (desde el punto donde ha sido declarado
hasta el final del fichero).
De entre las definiciones de subprogramas, debe definirse una funci´on principal,
denominada main, que indica donde comienza la ejecuci´on del programa. Al finalizar, dicha funci
´on devolver´a un nu´ mero entero que indica al Sistema Operativo el estado de terminaci´on
tras la ejecuci´on del programa (un nu´mero 0 indica terminaci´on normal). En caso de no
aparecer expl´ıcitamente el valor de retorno de main, el sistema recibir´a por defecto un valor
indicando terminaci´on normal.
Ejemplo de un programa que convierte una cantidad determinada de euros a su valor en pesetas.

//- fichero: euros.cpp

#include <iostream>
using namespace std;
const double EUR_PTS = 166.386;
int main()
{
cout << "Introduce la cantidad (en euros): ";
double euros;
cin >> euros;
double pesetas = euros * EUR_PTS;
cout << euros << " Euros equivalen a " << pesetas << " Pts" << endl;
// return 0;
}
//- fin: euros.cpp

Se deber´a compilar el programa (c´odigo fuente) contenido en el fichero euros.cpp para

tra- ducirlo a un programa ejecutable mediante un compilador. En caso de utilizar el compilador
GNU GCC, la compilaci´on se realizar´a de la siguiente forma:

g++ -ansi -Wall -Werror -o euros euros.cpp

cuya ejecuci´on podr´a ser como se indica a continuaci´on, donde el texto enmarcado
corresponde a una entrada de datos del usuario:

Introduce la cantidad (en euros): 3.5

ENTER
3.5 Euros equivalen a 582.351 Pts

13
 1 CAP´ITULO 1. UN PROGRAMA C++

En algunos entornos de programaci´on, por ejemplo Dev-C++ en Windows, puede ser

necesario pausar el programa antes de su terminaci´on, para evitar que desaparezca la ventana
de ejecuci´on. En este caso el programa anterior quedar´ıa:

//- fichero: euros.cpp

#include <iostream>
#include <cstdlib>
using namespace std;
const double EUR_PTS = 166.386;
int main()
{
cout << "Introduce la cantidad (en euros): ";
double euros;
cin >> euros;
double pesetas = euros * EUR_PTS;
cout << euros << " Euros equivalen a " << pesetas << " Pts" << endl;
system("pause"); // llamada para que el S.O. Windows pause el programa
// return 0;
}
//- fin: euros.cpp

Ejemplo de un programa que imprime los nu´meros menores que uno dado por teclado.

//- fichero: numeros.cpp

#include <iostream> // biblioteca de entrada/salida
using namespace std; // utilizaci´on del espacio de nombres de la biblioteca
//
// Imprime los n´umeros menores a ’n’
//
void imprimir_numeros(int n)
{
for (int i = 0; i < n; ++i) {
cout << i << " "; // escribe el valor de ’i’
}
cout << endl; // escribe ’fin de l´ınea’
}
//
// Imprime los n´umeros menores a ’n’
//
int main()
{
int maximo;
cout << "Introduce un n´umero: ";
cin >> maximo;
imprimir_numeros(maximo);
// return 0;
}
//- fin: numeros.cpp

En un programa C++ podemos distinguir los siguientes elementos b´asicos, considerando

que las letras minu´sculas se consideran diferentes de las letras mayu´sculas:

Palabras reservadas
Son un conjunto de palabras que tienen un significado predeterminado para el compilador,
y s ´o lo pueden ser utilizadas con dicho sentido. Por ejemplo: using, namespace, const,
double, int, char, bool, void, for, while, do, if, switch, case, default, return, typedef,
enum, struct, etc.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 15

Identificadores
Son nombres elegidos por el programador para representar entidades (tipos, constantes, vari-
ables, funciones, etc) en el programa.
Se construyen mediante una secuencia de letras y d´ıgitos, siendo el primer car´acter una
letra. El car´acter ’_’ se considera como una letra, sin embargo, los nombres que
comienzan con dicho car´acter se reservan para situaciones especiales, por lo que no
deber´ıan utilizarse en programas.
En este manual, seguiremos la siguiente convenci´on para los identificadores:

Constantes Simb´olicas: S´olo se utilizar´an letras mayu´sculas, d´ıgitos y el car´acter ’_’.

Ejemplo: EUR_PTS
Tipos: Comenzar´an por una letra mayu´scula seguida por letras mayu´sculas, minu
´sculas, d´ıgitos o ’_’. Deber´a contener al menos una letra minu´scula. Ejemplo:
Persona Variables: S´olo se utilizar´an letras minu´sculas, d´ıgitos y el car´acter ’_’.
Ejemplo: euros,
pesetas, n, i1, etc.
Funciones: S´olo se utilizar´an letras minu´sculas, d´ıgitos y el car´acter ’_’. Ejemplo: imprimir_numeros
Campos de Registros: S´olo se utilizar´an letras minu´sculas, d´ıgitos y el car´acter ’_’.
Ejem- plo: nombre
Constantes literales
Son valores que aparecen expl´ıcitamente en el programa, y podr´an ser l´ogicos, num
´ericos, caracteres y cadenas. Ejemplo: true, false, 0, 25, 166.386, " Pts", ’ ’, etc.
Operadores
S´ımbolos con significado propio segu´n el contexto en el que se utilicen. Ejemplo: = << >> * /
% + - < > <= >= == != ++ -- . , etc.
Delimitadores
S´ımbolos que indican comienzo o fin de una entidad. Ejemplo: ( ) { } ; , < >
Comentarios y espacios en blanco
Los espacios en blanco, tabuladores, nueva l´ınea, retorno de carro, avance de p´agina y
los comentarios son ignorados por el compilador, excepto en el sentido en que separan
elementos.
Los comentarios en un programa es texto que el programador escribe para facilitar la com-
prensi´on, o remarcar algu´n hecho importante a un lector humano, y son, por lo tanto,
igno- rados por el compilador.
Los comentarios en C++ se expresan de dos formas diferentes:

• Comentarios hasta fin de l´ınea: los s´ımbolos // marcan el comienzo del comentario, que
se extiende hasta el final de la l´ınea.
// acumula el siguiente n´umero
suma = suma + n; // acumula el valor de ’n’

• Comentarios enmarcados: los s´ımbolos /* marcan el comienzo del comentario, que se

extiende hasta los s´ımbolos del fin del comentario */
/*
* acumula el siguiente n´umero
*/
suma = suma + n; /* acumula el valor de ’n’ */

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 1. UN PROGRAMA C++

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 2

Tipos Simples

El tipo define las caracter´ısticas que tiene una determinada entidad, de tal forma que toda
entidad manipulada por un programa lleva asociado un determinado tipo. Las caracter´ısticas que
el tipo define son:
El rango de posibles valores que la entidad puede tomar.
El conjunto de operaciones/manipulaciones aplicables a la entidad.
El espacio de almacenamiento necesario para almacenar dichos
valores. La interpretaci´on del valor almacenado.
Los tipos se pueden clasificar en tipos simples y tipos compuestos. Los tipos simples se
carac- terizan porque sus valores son indivisibles, es decir, no se puede acceder o modificar
parte de ellos (aunque ´esto se pueda realizar indirectamente mediante operaciones de bits) y los
tipos compuestos se caracterizan por estar formados como un agregado o composici´on de otros
tipos, ya sean simples o compuestos.

2.1. Declaracio´n Vs. Definici´on

Con objeto de clarificar la terminolog´ıa, en C++ una declaraci´on “presenta” un
identificador para el cual la entidad a la que hace referencia deber´a ser definida
posteriormente.
Una definici´on “establece las caracter´ısticas” de una determinada entidad para el
identificador al cual se refiere. Toda definici´on es a su vez tambi´en una declaraci´on.
Es obligatorio que por cada entidad, s´olo exista una u´nica definici´on en la unidad de
compi- laci´on, aunque pueden existir varias declaraciones. As´ı mismo, tambi´en es obligatorio la
declaraci´on de las entidades que se manipulen en el programa, especificando su tipo, identificador,
valores, etc. antes de que sean utilizados.

2.2. Tipos Simples Predefinidos

Los tipos simples predefinidos en el lenguaje de programaci´on C++ son:

bool char int float double

El tipo bool se utiliza para representar valores l´ogicos o booleanos, es decir, los valores
“Ver- dadero” o “Falso” o las constantes l´ogicas true y false. Suele almacenarse en el taman˜o
de palabra m ´a s pequen˜o posible direccionable (normalmente 1 byte).
El tipo char se utiliza para representar los caracteres, es decir, s´ımbolos alfanum´ericos (d´ıgitos
y letras mayu´sculas y minu´sculas), de puntuaci´on, espacios, control, etc. Normalmente
utiliza un espacio de almacenamiento de 1 byte (8 bits) y puede representar 256 valores
diferentes.

17
1 CAP´ITULO 2. TIPOS SIMPLES

El tipo int se utiliza para representar los nu´meros Enteros. Su representaci´on suele
coincidir con la definida por el taman˜o de palabra del procesador sobre el que va a ser
ejecutado, hoy d´ıa puede ser de 4 bytes (32 bits), aunque actualmente en los ordenadores m ´a s
modernos, puede ser de 8 bytes (64 bits).

Puede ser modificado para representar un rango de valores menor mediante el mod-
ificador short (normalmente 2 bytes [16 bits]) o para representar un rango de valores
mayor mediante el modificador long (normalmente 4 bytes [32 bits] u 8 bytes [64
bits]) y long long (normalmente 8 bytes [64 bits]).
Tambi´en puede ser modificado para representar solamente nu´meros Naturales
(en- teros positivos) utilizando el modificador unsigned.

Tanto el tipo float como el double se utilizan para representar nu´meros reales en formato
de punto flotante diferenci´andose en el rango de valores que representan, utiliz´andose el
tipo double (normalmente 8 bytes [64 bits]) para representar nu´meros de punto flotante en “doble
precisi´on” y el tipo float (normalmente 4 bytes [32 bits]) para representar la “simple precisi
´on”. El tipo double tambi´en puede ser modificado con long para representar “cu´adruple
precisi´on” (normalmente 12 bytes [96 bits]).
Todos los tipos simples tienen la propiedad de ser indivisibles y adem´as mantener una relaci
´on de orden entre sus elementos (se les pueden aplicar los operadores relacionales). Se les
conoce tambi´en como tipos Escalares. Todos ellos, salvo los de punto flotante (float y double),
tienen tambi´en la propiedad de que cada posible valor tiene un u´nico antecesor y un u´nico
sucesor. A
´estos se les conoce como tipos Ordinales (en terminolog´ıa C++, tambi´en se les conoce como
tipos integrales, o enteros).

Valores L´ımites de los Tipos Predefinidos

Tanto la biblioteca est´andar climits como cfloat definen constantes, accesibles por los
progra- mas, que proporcionan los valores l´ımites que pueden contener las entidades (constantes y
variables) de tipos simples. Para ello, si un programa necesita acceder a algu´n valor definido,
deber´a incluir la biblioteca correspondiente, y utilizar las constantes adecuadas.

Biblioteca climits
#include <climits>

char short int long long long

unsigned m´aximo UCHAR_MAX USHRT_MAX UINT_MAX ULONG_MAX ULONG_LONG_MAX
signed m´aximo SCHAR_MAX SHRT_MAX INT_MAX LONG_MAX LONG_LONG_MAX
m´ınimo SCHAR_MIN SHRT_MIN INT_MIN LONG_MIN LONG_LONG_MIN
m´aximo CHAR_MAX
m´ınimo CHAR_MIN
n bits CHAR_BIT

Biblioteca cfloat
#include <cfloat>

FLT_EPSILON Menor nu´ mero float x tal que 1,0 + x 6= 1,0

FLT_MAX M´aximo nu´mero float de punto flotante
FLT_MIN M´ınimo nu´mero float normalizado de punto
flotante DBL_EPSILON Menor nu´ mero double x tal que 1,0 + x
6= 1,0 DBL_MAXM´aximo nu´mero double de punto flotante
DBL_MIN M´ınimo nu´mero double normalizado de punto
flotante LDBL_EPSILON Menor nu´ mero long double x tal que 1,0 +
x 6= 1,0 LDBL_MAX M´aximo nu´ mero long double de punto
flotante
LDBL_MIN M´ınimo nu´mero long double normalizado de punto flotante

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 2.3. TIPOS SIMPLES ENUMERADOS 19

Para ver el taman˜o (en bytes) que ocupa un determinado tipo/entidad en memoria, podemos
aplicarle el siguiente operador:
unsigned sz = sizeof(tipo);
unsigned sz = sizeof(variable);

Por definici´on, sizeof(char) es 1. El nu´mero de bits que ocupa un determinado tipo se puede
calcular de la siguiente forma:
#include <iostream>
#include <climits>
using namespace std;
int main()
{
unsigned nbytes = sizeof(int);
unsigned nbits = sizeof(int) / sizeof(char) * CHAR_BIT ;
cout << "int: "<<nbytes<<" "<<nbits<<" "<<INT_MIN<<" "<<INT_MAX<<endl;
}

Veamos un cuadro resumen con los tipos predefinidos, su espacio de almacenamiento y el rango
de valores para una m´aquina de 32 bits, donde para una representaci´on de n bits, en caso de
ser un tipo entero con signo, sus valores m´ınimo y m´aximo vienen especificados por el
rango
[(−2n−1) · · · (+2n−1 − 1)], y en caso de ser un tipo entero sin signo, sus valores m´ınimo y m´aximo
vienen especificados por el rango [0 · · · (+2n − 1)]:

Tipo Bytes Bits Min.Valor Max.Valor

bool 1 8 false true
char 1 8 -128 127
short 2 16 -32768 32767
int 4 32 -2147483648 2147483647
long 4 32 -2147483648 2147483647
long long 8 64 -9223372036854775808 9223372036854775807
unsigned char 1 8 0 255
unsigned short 2 16 0 65535
unsigned 4 32 0 4294967295
unsigned long 4 32 0 4294967295
unsigned long long 8 64 0 18446744073709551615
float 4 32 1.17549435e-38 3.40282347e+38
double 8 64 2.2250738585072014e-308 1.7976931348623157e+308
long double 12 96 3.36210314311209350626e-4932 1.18973149535723176502e+4932

2.3. Tipos Simples Enumerados

Adem´as de los tipos simples predefinidos, el programador puede definir nuevos tipos
simples que expresen mejor las caracter´ısticas de las entidades manipuladas por el programa.
As´ı, dicho tipo se definir´a en base a una enumeraci´on de los posibles valores que pueda
tomar la entidad asociada. A dicho tipo se le denomina tipo enumerado, es un tipo simple
ordinal, y se define de la siguiente forma:

enum Color {
ROJO,
AZUL,
AMARILLO
};

De esta forma definimos el tipo Color, que definir´a una entidad (constante o variable) que
po dr´a tomar cualquiera de los diferentes valores enumerados. Los tipos enumerados, al ser
tipos definidos por el programador, no tiene entrada ni salida predefinida por el lenguaje, sino
que deber´a ser el programador el que especifique (programe) como se realizar´a la entrada y
salida de datos en caso de ser necesaria. Otro ejemplo de enumeraci´on:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 2. TIPOS SIMPLES

enum Meses {
Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio,
Agosto, Septiembre, Octubre, Noviembre, Diciembre
};

Es posible asignar valores concretos a las enumeraciones. Aquellos valores que no se especifiquen
ser´an consecutivos a los anteriores. Si no se especifica ningu´n valor, al primer valor se le
asigna el cero.

enum Color {
ROJO = 1,
AZUL,
AMARILLO = 4
};

cout << ROJO << " " << AZUL << " " << AMARILLO << endl; // 1 2 4

2.4. Constantes y Variables

Podemos dividir las entidades que nuestro programa manipula en dos clases fundamentales:
aquellos cuyo valor no var´ıa durante la ejecuci´on del programa (constantes) y aquellos otros
cuyo valor puede ir cambiando durante la ejecuci´on del programa (variables).

Constantes
Las constantes pueden aparecer a su vez como constantes literales, son aquellas cuyo valor
aparece directamente en el programa, y como constantes simb´olicas , aquellas cuyo valor se asocia
a un identificador, a trav´es del cual se representa.
Ejemplos de constantes
literales: Constantes l´ogicas
(bool):
false, true

Constantes car´acter (char), el s´ımbolo constante aparece entre comillas simples:

’a’, ’b’, ..., ’z’,
’A’, ’B’, ..., ’Z’,
’0’, ’1’, ..., ’9’,
’ ’, ’.’, ’,’, ’:’, ’;’, ...

As´ı mismo, ciertos caracteres constantes tienen un significado especial (caracteres de escape):

• ’\n’: fin de l´ınea (newline)

• ’\r’: retorno de carro (carriage-return)
• ’\b’: retroceso (backspace)
• ’\t’: tabulador horizontal
• ’\v’: tabulador vertical
• ’\f’: avance de p´agina (form-feed)
• ’\a’: sonido (audible-bell)
• ’\0’: fin de cadena
• ’\137’, ’\x5F’: caracter correspondiente al valor especificado en notaci´on octal y
hexadecimal respectivamente

Constantes cadenas de caracteres literales, la secuencia de caracteres aparece entre comillas

dobles (puede contener caracteres de escape):
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 2.5. OPERADORES 21

"Hola Pepe"
"Hola\nJuan\n"
"Hola " "Mar´ıa"

Constantes enteras, pueden ser expresadas en decimal (base 10), hexadecimal (base 16) y
octal (base 8). El sufijo L se utiliza para especificar long, el sufijo LL se utiliza para es-
pecificar long long, el sufijo U se utiliza para especificar unsigned, el sufijo UL especifica
unsigned long, y el sufijo ULL especifica unsigned long long:

123, -1520, 2345U, 30000L, 50000UL, 0x10B3FC23 (hexadecimal), 0751 (octal)

Constantes reales, nu´meros en punto flotante. El sufijo F especifica float, y el sufijo L

especifica long double:

3.1415, -1e12, 5.3456e-5, 2.54e-1F, 3.25e200L

Constantes Simb´olicas
Las constantes simb´olicas se declaran indicando la palabra reservada const seguida por su
tipo, el nombre simb´olico (o identificador) con el que nos referiremos a ella y el valor asociado
tras el s´ımbolo (=). Ejemplos de constantes simb´olicas:
const bool OK = true;
const char SONIDO = ’\a’;
const short ELEMENTO = 1000;
const int MAXIMO = 5000;
const long ULTIMO = 100000L;
const long long TAMANO = 1000000LL;
const unsigned short VALOR = 100U;
const unsigned FILAS = 200U;
const unsigned long COLUMNAS = 200UL;
const unsigned long long NELMS = 2000ULL;
const float N_E = 2.7182F;
const double LOG10E = log(N_E);
const long double N_PI = 3.141592L;
const Color COLOR_DEFECTO = ROJO;

Variables
Las variables se definen, dentro de un bloque de sentencias (v´ease 4.1), especificando su
tipo y el identificador con el que nos referiremos a ella, y ser´an visibles desde el punto de
declaraci´on hasta el final del cuerpo (bloque) donde han sido declaradas. Se les po dr´a
asignar un valor inicial en la definici´on (mediante el s´ımbolo =), si no se les asigna ningu´n
valor inicial, entonces tendr´an un valor inespecificado. Su valor podr´a cambiar mediante la
sentencia de asignaci´on (v´ease 4.3) o mediante una sentencia de entrada de datos (v´ease 3.2).

{
char letra; // valor inicial inespecificado
int contador = 0;
double total = 5.0;
...
}

2.5. Operadores
Los siguientes operadores se pueden aplicar a los datos (de mayor a menor orden de precedencia):

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 2. TIPOS SIMPLES

Operador Tipo de Operador Asociatividad

! ~ - Unarios Dch. a Izq.
* / % Binarios Izq. a Dch.
+ - Binarios Izq. a Dch.
<< >> Binarios Izq. a Dch.
< <= > >= Binarios Izq. a Dch.
== != Binarios Izq. a Dch.
& Binario Izq. a Dch.
^ Binario Izq. a Dch.
| Binario Izq. a Dch.
&& Binario Izq. a Dch.
|| Binario Izq. a Dch.
?: Ternario Dch. a Izq.

Significado de los operadores:

Aritm´eticos. El resultado es del mismo tipo que los operandos (v´ease 2.6):

- valor Menos unario

valor * valor Producto (multiplicaci´on)
valor / valor Divisi´on (entera o real segu´n el tipo de
operandos) valor % valorM´odulo (resto de la divisi´on) (s´olo tipos
enteros) valor + valor Suma
valor - valor Resta

Relacionales/Comparaciones. El resultado es de tipo bool

valor < valor Comparaci´on menor
valor <= valor Comparaci´on menor o igual
valor > valor Comparaci´on mayor
valor >= valor Comparaci´on mayor o
igual valor == valor Comparaci´on
igualdad valor != valor Comparaci´on
desigualdad

Operadores de Bits, s´olo aplicable a operandos de tipos enteros. El resultado es del

mismo tipo que los operandos (v´ease 2.6):

~ valor Negacion de bits

(complemento) valor << despl Desplazamiento de
bits a la izq. valor >> despl Desplazamiento de
bits a la dch. valor & valor AND de bits
valor ^ valor XOR de bits
valor | valor OR de bits

L´ogicos, s´o lo aplicable operandos de tipo booleano. Tanto el operador && como el operador
|| se evalu´an en cortocircuito. El resultado es de tipo bool:
! valor Negaci´on l´ogica (Si valor es true entonces false, en otro caso true)
valor1 && valor2 AND l´ogico (Si valor1 es false entonces false, en otro caso valor2)
valor1 || valor2 OR logico (Si valor1 es true entonces true, en otro caso valor2)

x ! x x y x && y x || y
F F F F F
T F T F T
T F F T
T T T T

Condicional. El resultado es del mismo tipo que los operandos:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 2. TIPOS SIMPLES
cond ? valor1 : valor2 Si cond es true entonces valor1, en otro caso valor2

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 2.6. CONVERSIONES AUTOMA´ TICAS (IMPL´ICITAS) DE TIPOS 23

2.6. Conversiones Autom´aticas (Impl´ıcitas) de Tipos

Es posible que nos interese realizar operaciones en las que se mezclen datos de tipos diferentes.
El lenguaje de programaci´on C++ realiza conversiones de tipo autom´aticas (“castings”),
de tal forma que el resultado de la operaci´on sea del tipo m ´a s amplio de los implicados en
ella. Siempre que sea posible, los valores se convierten de tal forma que no se pierda informaci
´on.

Promociones Enteras
Son conversiones impl´ıcitas que preservan valores. Antes de realizar una operaci´on aritm
´etica, se utiliza promoci´on a entero para crear int a partir de otros tipos integrales mas cortos.
Para los siguientes tipos origen: bool, char, signed char, unsigned char, short, unsigned
short
Si int puede representar todos los valores posibles del tipo origen, entonces sus valores
promocionan a int.

En otro caso, promocionan a unsigned int

Conversiones Enteras
Si el tipo destino es unsigned, el valor resultante es el menor unsigned congruente con el valor
origen m´odulo 2n, siendo n el nu´mero de bits utilizados en la representaci´on del tipo
destino (en representaci´on de complemento a dos, simplemente tiene tantos bits del origen
como quepan en el destino, descartando los de mayor orden).
Si el tipo destino es signed, el valor no cambia si se puede representar en el tipo destino, si no,
viene definido por la implementaci´on.

Conversiones Aritm´eticas Impl´ıcitas Habituales

Se realizan sobre los operandos de un operador binario para convertirlos a un tipo comu´ n
que se r ´a el tipo del resultado:

1. Si algu´n operando es de tipo de punto flotante (real):

a) Si algu´ n operando es de tipo long double, el otro se convierte a long double.

b) En otro caso, si algu´ n operando es double el otro se convierte a double.
c) En otro caso, si algu´n operando es float el otro se convierte a float.

2. En otro caso, se realizan promociones enteras (v´ease sec. 2.6) sobre ambos operandos:

a) Si algu´ n operando es de tipo unsigned long, el otro se convierte a unsigned long.

b) En otro caso, si algu´ n operando es long int y el otro es unsigned int, si un long
int puede representar todos los valores de un unsigned int, el unsigned int se
convierte a long int; en caso contrario, ambos se convierten a unsigned long int.
c) En otro caso, si algu´n operando es long el otro se convierte a long.
d) ) En otro caso, si algu´ n operando es unsigned el otro se convierte a unsigned.
e) En otro caso, ambos operandos son int

2.7. Conversiones Expl´ıcitas de Tipos

Tambi´en es posible realizar conversiones de tipo expl´ıcitas . Para ello, se escribe el tipo al
que queremos convertir y entre par´entesis la expresi´on cuyo valor queremos convertir. Por
ejemplo:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 2. TIPOS SIMPLES

char x = char(65); produce el car´acter ’A’

int x = int(’a’); convierte el car´acter ’a’ a su valor entero (97)
int x = int(ROJO); produce el entero 0
int x = int(AMARILLO); produce el entero 2
int x = int(3.7); produce el entero 3
double x = double(2); produce el real (doble precisi´on) 2.0
Color x = Color(1); produce el Color AZUL
Color x = Color(c+1); si c es de tipo Color, produce el siguiente valor de la enumeraci´on

El tipo enumerado se convierte autom´aticamente a entero, aunque la conversi´on inversa

no se realiza de forma autom´atica. As´ı, para incrementar una variable de tipo color se
realizar´a de la siguiente forma:

enum Color {
ROJO, AZUL, AMARILLO
};
int main()
{
Color c = ROJO;
c = Color(c + 1);
// ahora c tiene el valor AZUL
}

A Otras Conversiones Expl´ıcitas de Tipos

Otra posibilidad de realizar conversiones expl´ıcitas es mediante los siguientes operadores:

El operador static_cast<tipo>(valor) realiza conversiones entre tipos relacionados como
por ejemplo para conversiones entre tipo enumerado y tipo integral, o entre tipo de coma
flotante y tipo integral, o para convertir de tipo puntero a Derivado a tipo puntero a
Base en la misma jerarqu´ıa de clases. Para un tipo primitivo, la conversi´on de tipos
expresada de la siguiente forma: Tipo(valor) es equivalente a
static_cast<Tipo>(valor). Ejemplo:
int* p_int = static_cast<int*>(p_void);

El operador reinterpret_cast<tipo>(valor) trata las conversiones entre tipos no rela-

cionados como un puntero y un entero, o un puntero y otro puntero no relacionado.
General- mente produce un valor del nuevo tipo que tiene el mismo patr´on de bits que su
par´ametro. Suelen corresponder a zonas de c´odigo no portable, y posiblemente problem
´atica. Ejemplo:
disp* ptr = reinterpret_cast<disp*>(0xff00);

El operador dynamic_cast<tipo*>(ptr) comprueba en tiempo de ejecuci´on que ptr puede

ser convertido al tipo destino (utiliza informaci´on de tipos en tiempo de ejecuci´on RTTI).
Si no puede ser convertido devuelve 0. Nota: ptr debe ser un puntero a un tipo polim
´orfico, y se suele utilizar para convertir de tipo puntero a Base a tipo puntero a Derivado.
Ejemplo:
ave* ptr = dynamic_cast<ave*>(p_animal);

El operador dynamic_cast<tipo&>(ref) comprueba en tiempo de ejecuci´on que ref

puede ser convertido al tipo destino (utiliza informaci´on de tipos en tiempo de ejecuci
´on RTTI). Si no puede ser convertido lanza la excepci´on bad_cast. Nota: ref debe ser una
referencia a un tipo polim´orfico, y se suele utilizar para convertir de tipo Base a tipo
Derivado. Ejemplo:
ave& ref = dynamic_cast<ave&>(r_animal);

El operador const_cast<tipo*>(ptr_const_tipo) elimina la restricci´on constante de valor.

No se garantiza que funcione cuando se aplica a una entidad declarada originalmente
como const. Ejemplo:
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 2. TIPOS SIMPLES
char* ptr = const_cast<char*>(ptr_const_char)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 2.8. TABLA ASCII 25

Esta distinci´on permite al compilador aplicar una verificaci´on de tipos m´ınima para static_cast
y haga m ´a s f´acil al programador la bu´squeda de conversiones peligrosas representadas por
reinterpret_cast. Algunos static_cast son portables, pero pocos reinterpret_cast lo son.

2.8. Tabla ASCII

La tabla ASCII es comu´nmente utilizada como base para la representaci´on de los
caracteres, donde los nu´meros del 0 al 31 se utilizan para representar caracteres de control, y
los nu´meros del 128 al 255 se utilizan para representar caracteres extendidos.

Rep Simb Rep Simb Rep Simb Rep Simb

0 \0 32 SP 64 @ 96 ‘
1 SOH 33 ! 65 A 97 a
2 STX 34 " 66 B 98 b
3 ETX 35 # 67 C 99 c
4 EOT 36 $ 68 D 100 d
5 ENQ 37 % 69 E 101 e
6 ACK 38 & 70 F 102 f
7 \a 39 ’ 71 G 103 g
8 \b 40 ( 72 H 104 h
9 \t 41 ) 73 I 105 i
10 \n 42 * 74 J 106 j
11 \v 43 + 75 K 107 k
12 \f 44 , 76 L 108 l
13 \r 45 - 77 M 109 m
14 SO 46 . 78 N 110 n
15 SI 47 / 79 O 111 o
16 DLE 48 0 80 P 112 p
17 DC1 49 1 81 Q 113 q
18 DC2 50 2 82 R 114 r
19 DC3 51 3 83 S 115 s
20 DC4 52 4 84 T 116 t
21 NAK 53 5 85 U 117 u
22 SYN 54 6 86 V 118 v
23 ETB 55 7 87 W 119 w
24 CAN 56 8 88 X 120 x
25 EM 57 9 89 Y 121 y
26 SUB 58 : 90 Z 122 z
27 ESC 59 ; 91 [ 123 {
28 FS 60 < 92 \ 124 |
29 GS 61 = 93 ] 125 }
30 RS 62 > 94 ^ 126 ~
31 US 63 ? 95 _ 127 DEL

2.9. Algunas Consideraciones Respecto a Operaciones con

Nu´ meros Reales A
La representaci´on de los nu´meros reales es limitada en cuanto al rango de valores y a la precisi
´on de los mismos, ya que el nu´mero de d´ıgitos decimales que puede almacenar es finito.
Adem´as, la representaci´on de nu´meros reales en base 2 hace que la representaci´on de
determinados nu´meros en base 10 sea inexacta, por lo tanto la realizaci´on de operaciones aritm
´eticas en punto flotante puede dar lugar a p´erdidas de precisi´on que den lugar a resultados
inesperados, distintas operaciones que matem´aticamente son equivalentes pueden ser
computacionalmente diferentes. As´ı, la comparaci´on directa de igualdad o desigualdad de nu
´meros reales debe ser evitada. Por ejemplo, el siguiente programa:

#include <iostream>
#include <string>
using namespace std;
inline double abs(double x)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 2. TIPOS SIMPLES

{
return x < 0 ? -x : x;
}
inline bool iguales(double x, double y)
{
const double ERROR_PREC = 1e-8;
return abs(x - y) < ERROR_PREC;
}
void check_iguales(double x, double y, const string& op1, const string& op2)
{
//--------------------------------
if (x == y) {
cout << " Correcto ("<<op1<<" == "<<op2<<"): ("<<x<<" == "<<y<<")"
<<endl;
} else {
cout << " Distintos ("<<op1<<" != "<<op2<<"): ("<<x<<" != "<<y
<<") Error. Diferencia: "<< abs(x-y) <<endl;
}
//--------------------------------
if (iguales(x, y)) {
cout << " Funci´on: Iguales("<<op1<<", "<<op2<<") Correcta"<<endl;
} else {
cout << " Funci´on: Iguales("<<op1<<", "<<op2<<") Error !!"<<endl;
}
//--------------------------------
}
int main()
{
//--------------------------------
// Error en conversi´on float a double
cout << "* Check Conversi´on float a double" << endl;
check_iguales(0.1F, 0.1, "0.1F", "0.1");
//--------------------------------
// Error en p´erdida de precisi´on
cout << "* Check Precisi´on" << endl;
check_iguales(0.01, (0.1*0.1), "0.01", "(0.1*0.1)");
//--------------------------------
// Error de apreciaci´on
cout << "* Check Apreciaci´on" << endl;
check_iguales(((10e30+ -10e30)+1.0), (10e30+(-10e30+1.0)),
"((10e30+ -10e30)+1.0)", "(10e30+(-10e30+1.0))");
//--------------------------------
}

produce los siguientes resultados en una m´aquina de 32 bits:

* Check Conversi´on float a double
Distintos (0.1F != 0.1): (0.1 != 0.1) Error. Diferencia: 1.49012e-09 Funci
´on: Iguales(0.1F, 0.1) Correcta
* Check Precisi´on
Distintos (0.01 != (0.1*0.1)): (0.01 != 0.01) Error. Diferencia: 1.73472e-18 Funci
´on: Iguales(0.01, (0.1*0.1)) Correcta
* Check Apreciaci´on
Distintos (((10e30+ -10e30)+1.0) != (10e30+(-10e30+1.0))): (1 != 0) Error. Diferencia: 1
Funci´on: Iguales(((10e30+ -10e30)+1.0), (10e30+(-10e30+1.0))) Error !!

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 3

Entrada y Salida de Datos B´asica

Para poder realizar entrada y salida de datos b´asica es necesario incluir la biblioteca
iostream que contiene las declaraciones de tipos y operaciones que la realizan. Todas las
definiciones y declaraciones de la biblioteca est´andar se encuentran bajo el espacio de nombres
std (ver cap´ıtu- lo 11), por lo que para utilizarlos adecuadamente habr´a que utilizar la
directiva using al comienzo del programa.
#include <iostream> // inclusi´on de la biblioteca de entrada/salida
using namespace std; // utilizaci´on del espacio de nombres de la biblioteca
const double EUR_PTS = 166.386;
int main()
{
cout << "Introduce la cantidad (en euros): ";
double euros;
cin >> euros;
double pesetas = euros * EUR_PTS;
cout << euros << " Euros equivalen a " << pesetas << " Pts" << endl;
}

3.1. Salida de Datos

La salida de datos se realiza a trav´es de los flujos de salida, as´ı el flujo de salida asociado
a la salida est´andar (usualmente la pantalla o terminal de la consola) se denomina cout. De esta
forma, la salida de datos a pantalla se realiza utilizando el operador << sobre el flujo cout
especificando el dato cuyo valor se mostrar´a. Por ejemplo:
cout << "Introduce la cantidad (en euros): ";
escribir´a en la salida est´andar el mensaje correspondiente a la cadena de caracteres especificada.
El siguiente ejemplo escribe en la salida est´andar el valor de las variables euros y pesetas, as´ı
como un mensaje para interpretarlos adecuadamente. El s´ımbolo endl indica que la sentencia deber
´a escribir un fin de l´ınea.
cout << euros << " Euros equivalen a " << pesetas << " Pts" << endl;
Tambi´en existe otro flujo de salida asociado a la salida est´andar de errores denominado
cerr (usualmente asociado tambi´en a la pantalla o terminal de la consola) que se utiliza para
notificar mensajes de error.
cerr << "Error. Divisi´on por cero." << numero << endl;
Tambi´en es posible que se fuerce la salida al dispositivo mediante el manipulador flush, de
tal forma que toda la informaci´on contenida en el buffer de salida (v´ease 3.3) se vuelque
inmediata- mente al dispositivo asociado:
cout << euros << " Euros equivalen a " << pesetas << " Pts" << flush;

27
 1 CAP´ITULO 3. ENTRADA Y SALIDA DE DATOS BA
´ SICA
Salida de Datos Formateada
Es posible especificar el formato bajo el que se realizar´a la salida de datos. Para ello se debe
incluir la biblioteca est´andar iomanip. Por ejemplo:

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
bool x = true;
cout << boolalpha << x; // escribe los booleanos como ’false’ o ’true’

cout << dec << 27 ; // escribe 27 (decimal)

cout << hex << 27 ; // escribe 1b (hexadecimal)
cout << oct << 27 ; // escribe 33 (octal)

cout << setprecision(2) << 4.567 ; // escribe 4.6

cout << setw(5) << 234 ; // escribe " 234"
cout << setfill(’#’) << setw(5) << 234 ; // escribe "##234"
}

A Salida Formateada Avanzada

Adem´as, es posible activar o desactivar las siguientes marcas (flags) para modificar el compor-
tamiento de la salida de datos:

ios::fmtflags flags = cout.flags(); obtiene los flags actuales

cout.flags(ios::fmtflags flags); pone los flags especificados

cout.unsetf(flag); desactiva el flag especificado

cout.setf(flag); activa el flag especificado
cout.setf(flag, mask); borra mask y activa el flag especificado

Las m´ascaras y flags pueden ser:

M´ascara Flags Significado

ios::skipws saltar los espacios en blanco (en flujo de entrada)
ios::showbase mostrar prefijo que indique la base (0 0x)
ios::showpoint mostrar siempre el punto decimal
ios::showpos mostrar el signo positivo
ios::uppercase usar mayu´sculas en representaci´on num´erica
ios::unitbuf forzar la salida despu´es de cada operaci´on
ios::floatfield m´ascara para notaci´on cient´ıfica
ios::fixed no usar notaci´on cient´ıfica (exponencial)
ios::scientific usar notaci´on cient´ıfica (exponencial)
ios::adjustfield m´ascara de justificaci´on
ios::left justificaci´on izquierda
ios::right justificaci´on derecha
ios::internal justificaci´on interna
ios::basefield m´ascara para indicar la base
ios::dec entrada/salida en base decimal
ios::oct entrada/salida en base octal
ios::hex entrada/salida en base hexadecimal

La precisi´on en el caso de formato por defecto de punto flotante, indica el m´aximo nu

´mero de d´ıgitos. En caso de formato fixed o scientific indica el nu´mero de d´ıgitos despu
´es del punto decimal.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 3.2. ENTRADA DE DATOS 29

cout.setf(0, ios::floatfield);
cout << setprecision(2) << 4.567; // imprime 4.6

cout.setf(ios::fixed, ios::floatfield);
cout << setprecision(2) << 4.567; // imprime 4.57

cout.setf(ios::scientific, ios::floatfield);
cout << setprecision(2) << 4.567; // imprime 4.57e+00

3.2. Entrada de Datos

La entrada de datos se realiza a trav´es de los flujos de entrada, as´ı el flujo de entrada
asociado a la entrada est´andar (usualmente el teclado) se denomina cin. De esta forma, la
entrada de datos desde el teclado se realiza mediante el operador >> sobre el flujo cin especificando la
variable donde almacenar el valor de entrada le´ıdo desde el teclado:
cin >> euros;
incluso es posible leer varios valores consecutivamente en la misma sentencia de entrada:
cin >> minimo >> maximo ;
Dicho operador de entrada se comporta de la siguiente forma: elimina los espacios en blanco
que hubiera al principio de la entrada de datos, y lee dicha entrada hasta que encuentre algu´ n
car´acter no v´alido para dicha entrada, que no ser´a le´ıdo y permanecer´a disponible en el
buffer de entrada (v´ease 3.3) hasta la pr´oxima operaci´on de entrada. En caso de que durante la
entrada surja alguna situaci´on de error, dicha entrada se detiene y el flujo de entrada se pondr
´a en un estado err´oneo (v´ease 3.5). Se consideran espacios en blanco los siguientes
caracteres: espacio en blanco, tabuladores, retorno de carro y nueva l´ınea (’ ’, ’\t’, ’\v’, ’\
f’, ’\r’, ’\n’).

A Entrada de Datos Avanzada

Tambi´en es posible leer un car´acter, desde el flujo de entrada, sin eliminar los espacios iniciales:
{
char c;
cin.get(c) ; // lee un car´acter sin eliminar espacios en blanco iniciales
...
}
En caso de querer eliminar los espacios iniciales expl´ıcitamente:
{
char c;
cin >> ws ; // elimina los espacios en blanco iniciales
cin.get(c) ; // lee sin eliminar espacios en blanco iniciales
...
}
Es posible tambi´en eliminar un nu´mero determinado de caracteres del flujo de entrada, o hasta un
determinado car´acter:
{
cin.ignore() ; // elimina el pr´oximo car´acter
cin.ignore(5) ; // elimina los 5 pr´oximos caracteres
cin.ignore(1000, ’\n’) ; // elimina 1000 caracteres o hasta nueva-l´ınea
cin.ignore(numeric_limits<streamsize>::max(), ’\n’) ; // elimina hasta nueva-l´ınea
}

Para utilizar numeric_limits es necesario incluir al principio del programa la biblioteca limits.
La entrada y salida de cadenas de caracteres se puede ver en los cap´ıtulos correspondientes
(cap. 6.2 y cap. 8.2).
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 1 CAP´ITULO 3. ENTRADA Y SALIDA DE DATOS BA
´ SICA
3.3. El “Buffer” de Entrada y el “Buffer” de Salida A
Ningu´n dato de entrada o de salida en un programa C++ se obtiene o env´ıa directamente
del/al hardware, sino que se realiza a trav´es de “buffers” de entrada y salida respectivamente
controlados por el Sistema Operativo y son independientes de nuestro programa.
As´ı, cuando se pulsa alguna tecla, el Sistema Operativo almacena en secuencia las teclas
pul- sadas en una zona de memoria intermedia: el “buffer” de entrada. Cuando un programa
realiza una operaci´on de entrada de datos (cin >> valor), accede al “buffer” de entrada y obtiene
los valores all´ı almacenados si los hubiera, o esperar´a hasta que los haya (se pulsen una serie
de teclas seguidas por la tecla “enter”). Una vez obtenidos las teclas pulsadas (caracteres), se
convertir´an a
un valor del tipo especificado por la operaci´on de entrada, y dicho valor se asignar´a a la
variable especificada.
De igual forma, cuando se va a mostrar alguna informaci´on de salida dichos datos no van
direc- tamente a la pantalla, sino que se convierten a un formato adecuado para ser impresos
(caracteres) y se almacenan en una zona de memoria intermedia denominada “buffer” de salida,
desde donde el Sistema Operativo tomar´a la informaci´on para ser mostrada por pantalla.
cout << "Valor: " << val << endl;

3.4. Otras Operaciones de Entrada y Salida A

Adem´as de con el operador >>, tambi´en es posible enviar un car´acter a un determinado
flujo de salida mediante la siguiente operaci´on:
cout.put(’#’);

Dado un flujo de entrada, es posible conocer el pr´oximo car´acter (sin eliminarlo del
buffer de entrada) que se leer´a en la siguiente operaci´on de entrada:
char c = char(cin.peek());

As´ı mismo, tambi´en es posible devolver al flujo (buffer) de entrada el u´ltimo car´acter
previamente le´ıdo.
cin.unget();

o incluso devolver al flujo (buffer) de entrada otro car´acter diferente al previamente le´ıdo:
cin.putback(c);

3.5. Control del Estado del Flujo de Datos A

Despu´es de realizar una operaci´on de entrada o salida con un determinado flujo, es posible
que dicha operaci´on no se hubiese realizado satisfactoriamente. En dicho caso el flujo se
pondr´a en un estado err´oneo, y cualquier operaci´on de entrada o salida posterior sobre
dicho flujo tambi´en fallar´a. El lenguaje de programaci´on C++ proporciona una serie de m
´etodos para comprobar cual es el estado en que se encuentra un determinado flujo y tambi´en
para restaurarlo a un estado adecuado en caso de ser necesario. La situaci´on m ´a s usual es
comprobar si la u´ltima operaci´on sobre el flujo se realiz´o adecuadamente:
cin >> valor;
if (cin.fail()) {
// ocurri´o un error y pr´oxima operaci´on fallar´a
// (cin.rdstate() & (ios::badbit | ios::failbit)) != 0
} else {
// ...
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 3. ENTRADA Y SALIDA DE DATOS BA
} ´ SICA

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

3.5. CONTROL DEL ESTADO DEL FLUJO DE DATOS 31

En caso de haber fallado, para comprobar si se ha alcanzado el final de la entrada de datos (final
de fichero), o el flujo se encuentra en mal estado:
cin >> valor;
if (cin.fail()) {
// ocurri´o un error y pr´oxima operaci´on fallar´a
// (cin.rdstate() & (ios::badbit | ios::failbit))!=0
if (cin.bad()) {
// flujo en mal estado
//(cin.rdstate() & ios::badbit) != 0
} else if (cin.eof()) {
// fin de fichero
// (cin.rdstate() & ios::eofbit) != 0
} else {
// ocurri´o un error de formato de entrada
//(cin.rdstate() & ios::failbit) != 0
}
} else {
// lectura de datos correcta
// ...
}

Tambi´en se puede preguntar si un determinado flujo se encuentra en buen estado:

cout << valor;
if (cout.good()) {
// ...
}

Como se ha visto en el ejemplo, la operaci´on rdstate() sobre el flujo de datos proporciona infor-
maci´on sobre el motivo del error, comprob´andose con respecto a las siguientes marcas (flags):
goodbit: Indica que todo es correcto (goodbit == iostate(0)).
eofbit: Indica que una operaci´on de entrada alcanz´o el final de una secuencia de entrada.
failbit: Indica que una operaci´on de entrada fall´o al leer los caracteres esperados, o que una
operaci´on de salida fall´o al generar los caracteres deseados.
badbit: Indica p´erdida de integridad en una secuencia de entrada o salida (tal como un error irrecu-
perable de un fichero).
Es posible recuperar el estado err´oneo de un determinado flujo mediante la operaci´on clear()
o setstate() sobre el flujo de datos.
FLAGS: [ios::goodbit | ios::failbit | ios::eofbit | ios:badbit]

cin.clear(); // pone el estado a ios::goodbit

cin.clear(flags); // pone el estado al especificado por los flags

ios::iostate e = cin.rdstate(); // obtiene el estado del flujo

cin.setstate(flags); // equiv. a cin.clear(cin.rdstate() | flags);

Por ejemplo, para leer un nu´mero y restaurar el estado en caso de lectura err´onea:
void leer(int& numero, bool& ok)
{
cin >> numero;
if (cin.fail()) {
ok = false;
if (! cin.eof() && ! cin.bad()) {
cin.clear();
cin.ignore(10000, ’\n’);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 3. ENTRADA Y SALIDA DE DATOS BA
´ SICA
} else {
ok = true;
}
}

Tambi´en es posible iterar hasta que se produzca una entrada correcta:

void leer(int& numero)
{
cin >> numero;
while (cin.fail() && ! cin.eof() && ! cin.bad()) {
cout << "Error. Int´entelo de nuevo" << endl;
cin.clear();
cin.ignore(10000, ’\n’);
cin >> numero;
}
}

Es posible configurar el sistema de entrada y salida de C++ para hacer que lance una excepci´on
(v´ease 12) del tipo ios::failure cuando ocurra algu´n error:
ios::iostate old_state = cin.exceptions();
cin.exceptions(ios::badbit | ios::failbit );
cout.exceptions(ios::badbit | ios::failbit );

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 4

Estructuras de Control

Las estructuras de control en el lenguaje de programaci´on C++ son muy flexibles, sin
embargo, la excesiva flexibilidad puede dar lugar a estructuras complejas. Por ello s´ol o
veremos algunas de ellas y utilizadas en contextos y situaciones restringidas.

4.1. Sentencia, Secuencia y Bloque

En C++ la unidad b´asica de acci´on es la sentencia, y expresamos la composici´on de
sentencias como una secuencia de sentencias terminadas cada una de ellas por el car´acter
“punto y coma” (;), de tal forma que su flujo de ejecuci´on es secuencial , es decir, se ejecuta una
sentencia, y cuando
´esta termina, entonces se ejecuta la siguiente sentencia, y as´ı sucesivamente.
Un bloque es una unidad de ejecuci´on mayor que la sentencia, y permite agrupar una secuencia
de sentencias como una unidad. Para ello enmarcamos la secuencia de sentencias entre dos
llaves para formar un bloque. Es posible el anidamiento de bloques.
int main()
{
<sentencia_1> ;
<sentencia_2> ;
{
<sentencia_3> ;
<sentencia_4> ;
. . .
}
<sentencia_n> ;
}

4.2. Declaraciones Globales y Locales

Como ya se vio en el cap´ıtulo anterior, es obligatoria la declaraci´on de las entidades
manipuladas en el programa. Distinguiremos dos clases de declaraciones: globales y locales.
Entidades globales son aquellas que han sido definidas fuera de cualquier bloque. Su
´ambito de visibilidad comprende desde el punto en el que se definen hasta el final del fichero.
Respecto a su tiempo de vida, se crean al principio de la ejecuci´on del programa y se
destruyen al finalizar
´este. Normalmente ser´an constantes simb´olicas, definiciones de tipos, declaraci´on de prototipos
de subprogramas y definiciones de subprogramas.
Entidades locales son aquellas que se definen dentro de un bloque. Su ´ambito de
visibilidad comprende desde el punto en el que se definen hasta el final de dicho bloque.
Respecto a su tiempo de vida, se crean en el punto donde se realiza la definici´on, y se
destruyen al finalizar el bloque. Normalmente ser´an constantes simb´olicas y variables locales.

33
 1 CAP´ITULO 4. ESTRUCTURAS DE CONTROL

#include <iostream>
using namespace std;
const double EUR_PTS = 166.386; // Declaraci´on de constante GLOBAL
int main()
{
cout << "Introduce la cantidad (en euros): ";
double euros; // Declaraci´on de variable LOCAL
cin >> euros;
double pesetas = euros * EUR_PTS; // Declaraci´on de variable LOCAL
cout << euros << " Euros equivalen a " << pesetas << " Pts" << endl;
}

Respecto al ´ambito de visibilidad de una entidad, en caso de declaraciones de diferentes

enti- dades con el mismo identificador en diferentes niveles de anidamiento, la entidad visible ser ´a
aquella que se encuentre declarada en el bloque de nivel de anidamiento m ´a s interno. Es decir,
cuando se solapa el ´ambito de visibilidad de dos entidades con el mismo identificador, en
dicha zona de solapamiento s er ´a visible el identificador declarado/definido en el bloque m ´a s
interno. Sin embar- go, no es una buena pr´actica de programaci´on ocultar identificadores al
redefinirlos en niveles de anidamiento mas internos, ya que conduce a programas dif´ıciles de
leer y propensos a errores.

int main()
{
int x = 3;
int z = x * 2; // x es vble de tipo int con valor 3
{
double x = 5.0;
double n = x * 2; // x es vble de tipo double con valor 5.0
}
int y = x + 4; // x es vble de tipo int con valor 3
}

4.3. Sentencias de Asignaci´on

La sentencia de asignaci´on permite asignar a una variable el resultado de evaluar una expresi
´on aritm´etica expresada en notaci´on infija, de tal forma que primero se evalu´ a la expresi
´on, con- siderando las reglas de precedencia y asociatividad de los operadores (v´ease 2.5), y a
continuaci´on el valor resultante se asigna a la variable, que perder´a el valor anterior que
tuviese. Por ejemplo:

const int MAXIMO = 15;

int main()
{
int cnt; // valor inicial inespecificado
cnt = 30 * MAXIMO + 1; // asigna a cnt el valor 451
cnt = cnt + 10; // cnt pasa ahora a contener el valor 461
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 4. ESTRUCTURAS DE CONTROL
Adem´as, se definen las siguientes sentencias de incremento/decremento:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 4.4. SENTENCIAS DE SELECCIO´ N 35

Sentencia Equivalencia
++variable; variable = variable + 1;
--variable; variable = variable - 1;
variable++; variable = variable + 1;
variable--; variable = variable - 1;

variable += expresion; variable = variable + (expresion);

variable -= expresion; variable = variable - (expresion);
variable *= expresion; variable = variable * (expresion);
variable /= expresion; variable = variable / (expresion);
variable %= expresion; variable = variable % (expresion);
variable &= expresion; variable = variable & (expresion);
variable ^= expresion; variable = variable ^ (expresion);
variable |= expresion; variable = variable | (expresion);
variable <<= expresion; variable = variable << (expresion);
variable >>= expresion; variable = variable >> (expresion);

Nota: las sentencias de asignaci´on vistas anteriormente se pueden utilizar en otras formas
muy diversas, pero nosotros restringiremos su utilizaci´on a la expresada anteriormente,
debido a que otras utilizaciones pueden dificultar la legibilidad y aumentar las posibilidades de
cometer errores de programaci´on.

4.4. Sentencias de Seleccio´n

Las sentencias de selecci´on alteran el flujo secuencial de ejecuci´on de un programa, de tal
forma que permiten seleccionar flujos de ejecuci´on alternativos y excluyentes dependiendo de
expresiones l´ogicas. La m ´a s simple de todas es la sentencia de selecci´on condicional if
cuya sintaxis es la siguiente:
int main()
{
if ( <expresi´on_l´ogica> ) {
<secuencia_de_sentencias> ;
}
}
y cuya sem´antica consiste en evaluar la expresi´on l´ogica, y si su resultado es Verdadero
(true) entonces se ejecuta la secuencia de sentencias entre las llaves. Ejemplo de programa que
imprime el valor mayor de tres nu´meros:

#include <iostream>
using namespace std;
int main ()
{
unsigned a, b, c;
cin >> a >> b >> c;
unsigned mayor = a;
if (b > mayor) {
mayor = b;
}
if (c > mayor) {
mayor = c;
}
cout << mayor << endl;
}

Otra posibilidad es la sentencia de selecci´on condicional compuesta, que tiene la siguiente

sintaxis:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 4. ESTRUCTURAS DE CONTROL

int main()
{
if ( <expresi´on_l´ogica> ) {
<secuencia_de_sentencias_v> ;
} else {
<secuencia_de_sentencias_f> ;
}
}
y cuya sem´antica consiste en evaluar la expresi´on l´ogica, y si su resultado es Verdadero
(true) entonces se ejecuta la <secuencia de sentencias v> . Sin embargo, si el resultado de
evaluar la expresi´on l´ogica es Falso (false) entonces se ejecuta la <secuencia de sentencias
f> .
La sentencia de selecci´on condicional se puede encadenar de la siguiente forma con el flujo de
control esperado:
#include <iostream>
using namespace std;
int main ()
{
double nota;
cin >> nota;
if ( ! ((nota >= 0.0) && (nota <= 10.0)))
{ cout << "Error: 0 <= n <= 10" <<
endl;
} else if (nota >= 9.5) {
cout << "Matr´ıcula de Honor" << endl;
} else if (nota >= 9.0) {
cout << "Sobresaliente" << endl;
} else if (nota >= 7.0) {
cout << "Notable" << endl;
} else if (nota >= 5.0) {
cout << "Aprobado" << endl;
} else {
cout << "Suspenso" << endl;
}
}

La sentencia switch es otro tipo de sentencia de selecci´on en la cual la secuencia de

sentencias alternativas a ejecutar no se decide en base a expresiones l´ogicas, sino en funci´on del
valor que tome una determinada expresi´on de tipo ordinal (v´ease 2.2), es decir, una relaci
´on de igualdad entre el valor de una expresi´on y unos determinados valores constantes de tipo
ordinal especificados. Su sintaxis es la siguiente:
int main()
{
switch ( <expresi´on> ) {
case <valor_1> :
<secuencia_de_sentencias_1> ;
break;
case <valor_2> :
case <valor_3> :
<secuencia_de_sentencias_2> ;
break;
case <valor_4> :
<secuencia_de_sentencias_3> ;
break;
. . .
default:
<secuencia_de_sentencias_d> ;
break;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 4. ESTRUCTURAS DE CONTROL
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 4.5. SENTENCIAS DE ITERACIO´ N. BUCLES 37

}
en la cual se evalu´ a la expresi´on, y si su valor coincide con <valor 1> entonces se ejecuta la
<secuencia de sentencias 1> . Si su valor coincide con <valor 2> o con <valor 3> se ejecuta
la <secuencia de sentencias 2> y as´ı sucesivamente. Si el valor de la expresi´on no
coincide con ningu´n valor especificado, se ejecuta la secuencia de sentencias correspondiente
a la etiqueta default (si es que existe). N´otese que la sentencia break; termina la secuencia de
sentencias a ejecutar para cada caso. Ejemplo:
#include <iostream>
using namespace std;
enum Dia_Semana {
lunes, martes, miercoles, jueves, viernes, sabado, domingo
};
int main ()
{
Dia_Semana dia;
...
// ’dia’ tiene alg´un valor v´alido
switch (dia) {
case lunes:
cout << "Lunes" << endl;
break;
case martes:
cout << "Martes" << endl;
break;
case miercoles:
cout << "Mi´ercoles" << endl;
break;
case jueves:
cout << "Jueves" << endl;
break;
case viernes:
cout << "Viernes" << endl;
break;
case sabado:
cout << "S´abado" << endl;
break;
case domingo:
cout << "Domingo" << endl;
break;
default:
cout << "Error" << endl;
break;
}
}

4.5. Sentencias de Iteraci´on. Bucles

Vamos a utilizar tres tipos de sentencias diferentes para expresar la repetici´on de la ejecuci
´on de un grupo de sentencias: while, for y do-while.
La sentencia while es la m ´a s utilizada y su sintaxis es la siguiente:
int main()
{
while ( <expresi´on_l´ogica> ) {
<secuencia_de_sentencias> ;
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 4. ESTRUCTURAS DE CONTROL

en la cual primero se evalu´a la expresi´on l´ogica, y si es cierta, se ejecuta la secuencia de

sentencias entre llaves completamente. Posteriormente se vuelve a evaluar la expresi´on l´ogica y
si vuelve a ser cierta se vuelve a ejecutar la secuencia de sentencias entre llaves. Este ciclo
iterativo consistente en evaluar la condici´on y ejecutar las sentencias se realizar´a MIENTRAS
que la condici´on se evalu´e a Verdadera y finalizar´a cuando la condici´on se evalu´e a
Falsa. Ejemplo:

#include <iostream>
using namespace std;
int main ()
{
unsigned num, divisor;
cin >> num;
if (num <= 1) {
divisor = 1;
} else {
divisor = 2;
while ((num % divisor) != 0) {
++divisor;
}
}
cout << "El primer divisor de " << num << " es " << divisor << endl;
}

La sentencia for es semejante a la estructura FOR de Pascal o Modula-2, aunque en C++

toma una dimensi´on m ´a s amplia y flexible. En realidad se trata de la misma construcci´on
while vista anteriormente pero con una sintaxis diferente para hacer m ´a s expl´ıcito los casos
en los que la iteraci´on e st ´a controlada por los valores que toma una determinada variable de
control, de tal forma que existe una clara inicializaci´on y un claro incremento de la variable de
control hasta llegar al caso final. La sintaxis es la siguiente:
int main()
{
for ( <inicializaci´on> ; <expresi´on_l´ogica> ; <incremento> ) {
<secuencia_de_sentencias> ;
}
}
y es equivalente a:
int main()
{
<inicializaci´on> ;
while ( <expresi´on_l´ogica> ) {
<secuencia_de_sentencias> ;
<incremento> ;
}
}
Nota: es posible declarar e inicializar la variable de control del bucle en el lugar de la inicializaci
´on. En este caso especial, el ´ambito de visibilidad de la variable de control del bucle es
solamente hasta el final del bloque de la estructura for.
#include <iostream>
using namespace std;
int main ()
{
unsigned n;
cin >> n;
for (unsigned i = 0; i < n; ++i)
{ cout << i << " ";

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 4.6. PROGRAMACIO´ N ESTRUCTURADA 39

}
// i ya no es visible aqu´ı
cout << endl;
}

La sentencia do-while presenta la siguiente estructura

int main()
{
do {
<secuencia_de_sentencias> ;
} while ( <expresi´on_l´ogica> );
}
tambi´en expresa la iteraci´on en la ejecuci´on de la secuencia de sentencias, pero a diferencia
de la primera estructura iterativa ya vista, donde primero se evalu´a la expresi´on l´ogica y
despu´es, en caso de ser cierta, se ejecuta la secuencia de sentencias, en esta estructura se
ejecuta primero la secuencia de sentencias y posteriormente se evalu´a la expresi´on l´ogica, y
si ´esta es cierta se repite el proceso.
#include <iostream>
using namespace std;
int main ()
{
unsigned num;
do {
cin >> num;
} while ((num % 2) != 0);
cout << "El n´umero par es " << num << endl;
}

4.6. Programaci´on Estructurada

Un programa sigue una metodolog´ıa de programaci´on estructurada si todas las estructuras
de control que se utilizan (secuencia, selecci´on, iteraci´on y modularizaci´on) tienen un u
´nico punto de entrada y un u´ nico punto de salida. Esta caracter´ıstica hace posible que se
pueda aplicar la abstracci´on para su disen˜o y desarrollo. La abstracci´on se basa en la
identificaci´on de los elementos a un determinado nivel, ignorando los detalles especificados en
niveles inferiores. Un algoritmo que use tan s ´ol o las estructuras de control tratadas en este
tema, se denomina estructurado.
Bohm y Jacopini demostraron que todo problema computable puede resolverse usando u
´nica- mente estas estructuras de control. E´ s ta es la base de la programaci´on estructurada. La
abstracci´on
algor´ıtmica va un paso m ´a s al l ´a y considera que cada nivel de refinamiento corresponde
con un subprograma independiente

4.7. Ejemplos
Ejemplo 1
Programa que multiplica dos nu´meros mediante sumas acumulativas:
#include <iostream>
using namespace std;
int main ()
{
cout << "Introduzca dos n´umeros: ";
unsigned m, n;
cin >> m >> n;
// Sumar: m+m+m+...+m (n veces)
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
1 CAP´ITULO 4. ESTRUCTURAS DE CONTROL

unsigned total = 0;
for (unsigned i = 0; i < n; ++i) {
// Proceso iterativo: acumular el valor de ’m’ al total
total = total + m;
}
cout << total << endl;
}

Ejemplo 2
Programa que suma los nu´meros naturales menor a uno dado:
#include <iostream>
using namespace std;
int main ()
{
cout << "Introduzca un n´umero: ";
unsigned n;
cin >> n;
// Sumar: 1 2 3 4 5 6 7 ... n
unsigned suma = 0;
for (unsigned i = 1; i <= n; ++i) {
// Proceso iterativo: acumular el valor de ’i’ al total
suma = suma + i;
}
cout << suma << endl;
}

Ejemplo 3
Programa que divide dos nu´meros mediante restas sucesivas:
#include <iostream>
using namespace std;
int main ()
{
cout << "Introduzca dos n´umeros: ";
unsigned dividendo, divisor;
cin >> dividendo >> divisor;
if (divisor == 0) {
cout << "El divisor no puede ser cero" << endl;
} else {
unsigned resto = dividendo;
unsigned cociente = 0;
while (resto >= divisor) {
resto -= divisor;
++cociente;
}
cout << cociente << " " << resto << endl;
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 5

Subprogramas. Funciones y
Procedimientos

La abstracci´on es una herramienta mental que nos permite analizar, comprender y construir
sis- temas complejos. As´ı, identificamos y denominamos conceptos abstractos y aplicamos
refinamientos sucesivos hasta comprender y construir el sistema completo.
Los subprogramas constituyen una herramienta del lenguaje de programaci´on que permite
al programador aplicar expl´ıcitamente la abstracci´on al disen˜o y construcci´on del software,
propor- cionando abstracci´on algor´ıtmica (procedimental) a la construcci´on de programas.
Los subprogramas pueden ser vistos como un mini programa encargado de resolver algor
´ıtmi- camente un subproblema que se encuentra englobado dentro de otro mayor. En ocasiones
tam- bi´en pueden ser vistos como una ampliaci´on/elevaci´on del conjunto de operaciones b
´asicas (ac- ciones primitivas) del lenguaje de programaci´on, proporcion´andole nuevos
mecanismos para re- solver nuevos problemas.

5.1. Funciones y Procedimientos

Los subprogramas codifican la soluci´on algor´ıtmica a un determinado problema, de tal
forma que cuando es necesario resolver dicho problema en un determinado momento de la
computaci´on, se invocar´a a una instancia del subprograma (mediante una llamada al
subprograma) para que resuelva el problema para unos determinados par´ametros. As´ı, en la
invocaci´on al subprograma, se transfiere la informaci´on que necesita para resolver el
problema, entonces se ejecuta el c´odigo del subprograma que resolver´a el problema y produce
unos resultados que devuelve al lugar donde ha sido requerido. Podemos distinguir dos tipos de
subprogramas:
Procedimientos: encargados de resolver un problema computacional general. En el
sigu- iente ejemplo el procedimiento ordenar ordena los valores de las variables pasadas
como par´ametros (x e y), de tal forma que cuando termine el procedimiento, las
variables x e y tendr´an el menor y el mayor valor respectivamente de los valores
originales:
int main()
{
int x = 8;
int y = 4;
ordenar(x, y);
cout << x << " " << y << endl;
}

Funciones: encargadas de realizar un c´alculo computacional y generar un u´nico

resultado, normalmente calculado en funci´on de los datos recibidos. En el siguiente
ejemplo, la fun- ci ´on calcular_menor calcula (y devuelve) el menor valor de los dos valores
recibidos como par´ametros:

41
 1 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS

int main()
{
int x = 8;
int y = 4;
int z = calcular_menor(x, y);
cout << "Menor: " << z << endl;
}

La llamada (invocaci´on) a un subprograma se realiza mediante el nombre seguido por los

par´ametros actuales entre par´entesis, considerando que:
La llamada a un procedimiento constituye por s´ı sola una sentencia independiente que puede
ser utilizada como tal en el cuerpo de otros subprogramas (y del programa principal).
La llamada a una funci´on no constituye por s´ı sola una sentencia, por lo que debe aparecer
dentro de alguna sentencia que utilice el valor resultado de la funci´on.

5.2. Definici´on de Subprogramas

Los subprogramas codifican la soluci´on algor´ıtmica parametrizada a un determinado
problema, es decir, especifica la secuencia de acciones a ejecutar para resolver un determinado
problema dependiendo de unos determinados par´ametros formales. Donde sea necesaria la
resoluci´on de dicho problema, se invocar´a a una instancia del subprograma para unos
determinados par´ametros actuales.
Considerando la norma de C++ de que antes de utilizar una determinada entidad en un pro-
grama, esta entidad deber´a estar previamente declarada, normalmente deberemos definir los
sub- programas en una posici´on previa a donde sean utilizados. Esta disposici´on de los
subprogramas puede ser alterada como se indica en la secci´on 5.7. La definici´on de los
subprogramas presentados anteriormente podr´ıa ser como se indica a continuaci´on:
#include <iostream>
using namespace std;
int calcular_menor(int a, int b)
{
int menor;
if (a < b) {
menor = a;
} else {
menor = b;
}
return menor;
}
void ordenar(int& a, int& b)
{
if (a > b) {
int aux = a;
a = b;
b = aux;
}
}
int main()
{
int x = 8;
int y = 4;
int z = calcular_menor(x, y);
cout << "Menor: " << z << endl;
ordenar(x, y);
cout << x << " " << y << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 5.3. EJECUCIO´ N DE SUBPROGRAMAS 43

La definici´on de un subprograma comienza con un encabezamiento en la que se especifica

en primer lugar el tipo del valor devuelto por ´este si es una funci´on, o void en caso de ser un
procedimiento. A continuaci´on vendr´a el nombre del subprograma seguido por la declaraci
´on de sus par´ametros formales entre par´entesis.
Los par´ametros formales especifican como se realiza la transferencia de informaci´on
entre el(sub)programa llamante y el subprograma llamado (v´ease 5.4). Normalmente la soluci
´on de un subproblema depender´a del valor de algunos datos, modificar´a el valor de otros
datos, y posible- mente generar´a nuevos valores. Todo este flujo de informaci´on se realiza a trav
´es de los par´ametros del subprograma.
El cuerpo del subprograma especifica la secuencia de acciones a ejecutar necesarias para resolver
el subproblema especificado, y podr´a definir tantas variables locales como necesite para
desempen˜ar su misi´on. En el caso de una funci´on, el valor que devuelve (el valor que toma
tras la llamada) vendr´a dado por el resultado de evaluar la expresi´on de la sentencia return.
Aunque C++ es m´as
flexible, nosotros s´olo permitiremos una u´nica utilizaci´on de la sentencia return y deber´a ser al
final del cuerpo de la funci´on. As´ı mismo, un procedimiento no tendr´a ninguna sentencia return
en su cuerpo.

5.3. Ejecuci´on de Subprogramas

Cuando se produce una llamada (invocaci´on) a un subprograma:
1. Se establecen las v´ıas de comunicaci´on entre los algoritmos llamante y llamado por medio
de los par´ametros.
2. Posteriormente el flujo de ejecuci´on pasa a ejecutar la primera sentencia del cuerpo del
subprograma llamado, ejecut´andose ´este.
3. Cuando sea necesario, se crean las variables locales especificadas en el cuerpo de la definici´on
del subprograma.
4. Cuando finaliza la ejecuci´on del subprograma, las variables locales y par´ametros
previamente creados se destruyen, el flujo de ejecuci´on retorna al (sub)programa
llamante, y continu´a la ejecuci´on por la sentencia siguiente a la llamada realizada.

5.4. Paso de Par´ametros. Par´ametros por Valor y por

Ref- erencia
Todo el intercambio y transferencia de informaci´on entre el programa llamante y el
subprograma llamado se debe realizar a trav´es de los par´ametros. Los par´ametros formales son
los que aparecen en la definici´on del subprograma, mientras que los par´ametros actuales son
los que aparecen en la llamada (invocaci´on) al subprograma.

Denominamos par´ametros de entrada a aquellos par´ametros que se utilizan para

recibir la informaci´on necesaria para realizar una computaci´on. Por ejemplo los par
´ametros a y b de la funci´on calcular_menor anterior.

• Los par´ametros de entrada se definen mediante paso por valor (cuando son de
tipos simples), que significa que los par´ametros formales son variables
independientes que toman sus valores iniciales como copias de los valores de los par
´ametros actuales de la llamada en el momento de la invocaci´on al subprograma.
Se declaran especificando el tipo y el identificador asociado.
int calcular_menor(int a, int b)
{
return (a < b) ? a : b ;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS

• Cuando los par´ametros de entrada son de tipos compuestos (v´ease 6), entonces se definen
mediante paso por referencia constante que ser ´a explicado m ´a s adelante.

Denominamos par´ametros de salida a aquellos par´ametros que se utilizan para transferir

al programa llamante informaci´on producida como parte de la computaci´on/soluci´on
realizada por el subprograma.

• Los par´ametros de salida se definen mediante paso por referencia que significa que
el par´ametro formal es una referencia a la variable que se haya especificado como par
´ametro actual de la llamada en el momento de la invocaci´on al subprograma. Es decir,
cualquier acci´on dentro del subprograma que se haga sobre el par´ametro formal es
equivalente a que se realice sobre la variable referenciada que aparece como par
´ametro actual en la llamada al subprograma. Se declaran especificando el tipo, el s
´ımbolo “ampersand” (&) y el identificador asociado.
En el siguiente ejemplo, el procedimiento dividir recibe dos valores sobre los cuales
realizar´a la operaci´on de divisi´on (dividendo y divisor son par´ametros de
entrada y son pasados por valor), y devuelve dos valores como resultado de la divisi
´on (cociente y resto son par´ametros de salida y son pasados por referencia):
void dividir(int dividendo, int divisor, int& coc, int& resto)
{
coc = dividendo / divisor;
resto = dividendo % divisor;
}
int main()
{
int cociente;
int resto;

dividir(7, 3, cociente, resto);

// ahora ’cociente’ valdr´a 2 y ’resto’ valdr´a 1
}

Denominamos par´ametros de entrada/salida a aquellos par´ametros que se utilizan para

recibir informaci´on necesaria para realizar la computaci´on, y que tras ser modificada se
transfiere al lugar de llamada como parte de la informaci´on producida resultado de la
computaci´on del subprograma. Por ejemplo los par´ametros a y b del procedimiento
ordenar anterior.
Los par´ametros de entrada/salida se definen mediante paso por referencia y se declaran
como se especific´o anteriormente.
void ordenar(int& a, int& b)
{
if (a > b) {
int aux = a;
a = b;
b = aux;
}
}

En el caso de tipos compuestos, es conveniente definir los par´ametros de entrada

mediante paso por referencia constante de tal forma que el par´ametro formal ser´a
una referencia al par´ametro actual especificado en la llamada, tomando as´ı su valor, pero
no p odr´a modificarlo al ser una referencia constante, evitando as´ı la sem´antica de
salida asociada al paso por referencia.
El paso por referencia constante suele utilizarse para el paso de par´ametros de entrada
con tipos compuestos, ya que evita la duplicaci´on de memoria y la copia del valor, que en
el caso de tipos compuestos suele ser costosa.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 5.5. CRITERIOS DE MODULARIZACIO´ N 45

Para ello, los par´ametros se declaran como se especific´o anteriormente para el paso por
referencia, pero anteponiendo la palabra reservada const.
void escribir(const Persona& a)
{
cout << a.nombre << " " << a.telefono << endl;
}
Tipos
Simples Compuestos
(⇓) Entrada P.Valor P.Ref.Cte
(unsigned x) (const Persona& x)
(⇑) Salida, (m) E/S P.Ref P.Ref
(unsigned& x) (Persona& x)
En la llamada a un subprograma, se deben cumplir los siguientes requisitos:
El nu´mero de par´ametros actuales debe coincidir con el nu´mero de par´ametros
formales. La correspondencia entre par´ametros actuales y formales es posicional.
El tipo del par´ametro actual debe coincidir con el tipo del correspondiente par´ametro formal.
Un par´ametro formal de salida o entrada/salida (paso por referencia) requiere que el par´ametro
actual sea una variable.
Un par´ametro formal de entrada (paso por valor o paso por referencia constante)
requiere que el par´ametro actual sea una variable, constante o expresi´on.
Tipos Simples Tipos Compuestos
(⇓) Ent (⇑) Sal (m) E/S (⇓) Ent (⇑) Sal (m)
Parametro Formal P.Valor P.Referencia P.Ref.Constante E/S
(unsigned x) (unsigned& x) (const Persona& x)
P.Referencia
(Persona& x)
Constante Constante
Parametro Actual Variable Variable Variable Variable
Expresi´on Expresi´on

5.5. Criterios de Modularizaci´on

No existen m´etodos objetivos para determinar como descomponer la soluci´on de un
problema en subprogramas, es una labor subjetiva. No obstante, se siguen algunos criterios que
pueden guiarnos para descomponer un problema y modularizar adecuadamente. El disen˜ador
de software debe buscar un bajo acoplamiento entre los subprogramas y una alta cohesi´on
dentro de cada uno.
Acoplamiento
• Un objetivo en el disen˜o descendente es crear subprogramas aislados e independientes.
• Debe haber alguna conexi´on entre los subprogramas para formar un sistema coherente.
• Dicha conexi´on se conoce como acoplamiento.
• Maximizar la independencia entre subprogramas s er ´a minimizar el acoplamiento.
Cohesi´on

• Hace referencia al grado de relaci´on entre las diferentes partes internas dentro de un
mismo subprograma.
• Si la cohesi´on es muy d´ebil, la diversidad entre las distintas tareas realizadas dentro del
subprograma es tal que posteriores modificaciones podr´an resultar complicadas.
• Se busca maximizar la cohesi´on dentro de cada subprograma
Si no es posible analizar y comprender un subprograma de forma aislada e independiente del resto,
entonces podemos deducir que la divisi´on modular no es la m ´a s adecuada.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS

5.6. Subprogramas “en L´ınea” A

La llamada a un subprograma conlleva un pequen˜o coste debido al control y gesti´on de la
misma que ocasiona cierta p´erdida de tiempo de ejecuci´on.
Hay situaciones en las que el subprograma es muy pequen˜o y nos interesa eliminar el coste
asociado a su invocaci´on. En ese caso podemos especificar que el subprograma se traduzca
como c´odigo en l´ınea en vez de como una llamada a un subprograma. Para ello se especificar´a
la palabra reservada inline justo antes del tipo. De esta forma, se mantiene los beneficios
proporcionados por la abstracci´on, pero se eliminan los costes asociados a la invocaci´on.
inline int calcular_menor(int a, int b)
{
return (a < b) ? a : b ;
}

Este mecanismo s´o l o es adecuado cuando el cuerpo del subprograma es muy pequen˜o, de tal
forma que el coste asociado a la invocaci´on dominar´ıa respecto a la ejecuci´on del cuerpo del
mismo.

5.7. Declaracio´n de Subprogramas. Prototipos A

Los subprogramas, al igual que los tipos, constantes y variables, deben ser declarados antes
de ser utilizados. Dicha declaraci´on se puede realizar de dos formas: una de ellas consiste
simplemente en definir el subprograma antes de utilizarlo. La otra posibilidad consiste en
declarar el prototipo del subprograma antes de su utilizaci´on, y definirlo posteriormente. El
´ambito de visibilidad del subprograma s er´a global al fichero, es decir, desde el lugar donde
ha sido declarado hasta el final del fichero. Para declarar un subprograma habr´a que
especificar el tipo del valor devuelto (o void si es un procedimiento) seguido por el nombre y la
declaraci´on de los par´ametros formales igual que en la definici´on del subprograma, pero
sin definir el cuerpo del mismo. En lugar de ello se terminar´a la declaraci´on con el car
´acter “punto y coma” (;).
int calcular_menor(int a, int b); // prototipo de ’calcular_menor’
int main()
{
int x = 8;
int y = 4;
int z = calcular_menor(x, y);
}
int calcular_menor(int a, int b) // definici´on de ’calcular_menor’
{
return (a < b) ? a : b ;
}

5.8. Sobrecarga de Subprogramas y Operadores A

Se denomina sobrecarga cuando distintos subprogramas se denominan con el mismo
identifi- cador u operador, pero se aplican a par´ametros distintos. En el lenguaje de
programaci´on C++ es posible sobrecargar tanto subprogramas como operadores siempre y cuando
tengan par´ametros diferentes, y el compilador pueda discriminar entre ellos por la especificaci
´on de la llamada.
void imprimir(int x)
{
cout << "entero: " << x << endl;
}
void imprimir(double x)
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS
{
cout << "real: " << x << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 5.9. PARA´ METROS POR DEFECTO 47

inline double media(int x, int y, int z)

{
return double(x + y + z) / 3.0;
}
inline double media(int x, int y)
{
return double(x + y) / 2.0;
}

enum Color {
rojo, amarillo, azul
};
inline void operator ++(Color& x)
{
x = Color(x + 1);
}

5.9. Par´ametros por Defecto A

Es posible en C++ definir valores por defecto para los par´ametros de un determinado
subpro- grama. Para ello es necesario especificar los valores por defecto que tomar´an los par
´ametros en caso de que no sean proporcionados por la invocaci´on al mismo, desde un
determinado par´ametro hasta el final de los mismos. T´engase presente que no es posible
intercalar par´ametros con o sin valores por defecto. Por ejemplo:
#include <iostream>
using namespace std;
void escribir(int uno, int dos = 2, int tres = 3)
{
cout << uno << " " << dos << " " << tres << endl;
}
int main()
{
escribir(5, 6, 7); // escribe: 5 6 7
escribir(5, 6); // escribe: 5 6 3
escribir(5); // escribe: 5 2 3
// escribir(); // Error de compilaci´on
// escribir(5, 6, 7, 8); // Error de compilaci´on
}

N´otese que la invocaci´on al subprograma escribir() sin par´ametros actuales es un error

de compilaci´on, ya que en su definici´on requiere que la invocaci´on tenga al menos un par
´ametro actual, y como m´aximo tres par´ametros actuales.
En el caso de declarar el prototipo de un subprograma, los valores de los par´ametros por
defecto se especificar´an en la propia declaraci´on del prototipo, y no en la definici´on del
subprograma, ya que la aplicaci´on de los par´ametros por defecto se realiza a la invocaci´on
del subprograma, no a su definici´on.
#include <iostream>
using namespace std;
void escribir(int uno, int dos = 2, int tres = 3); // prototipo
int main()
{
escribir(5, 6, 7); // escribe: 5 6 7
escribir(5, 6); // escribe: 5 6 3
escribir(5); // escribe: 5 2 3
// escribir(); // Error de compilaci´on

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS

// escribir(5, 6, 7, 8); // Error de compilaci´on

}
void escribir(int uno, int dos, int tres)
{
cout << uno << " " << dos << " " << tres << endl;
}

5.10. Subprogramas y Flujos de Entrada y Salida A

Los flujos de entrada, de salida y de error (cin, cout y cerr respectivamente) pueden ser
pasados como par´ametros actuales (por referencia no constante) a subprogramas como se
indica en el siguiente ejemplo:

#include <iostream>
using namespace std;
void leer_int(istream& entrada, int& dato)
{
entrada >> dato;
}
void escribir_int(ostream& salida, int dato)
{
salida << "Valor: " << dato << endl;
}
int main()
{
int x;
leer_int(cin, x);
escribir_int(cout, x);
escribir_int(cerr, x);
}

5.11. Pre-Condiciones y Post-Condiciones A

Pre-condici´on es un enunciado que debe ser cierto antes de la llamada a un subprograma.
Especifica las condiciones bajo las cuales se ejecutar´a dicho subprograma.

Post-condici´on es un enunciado que debe ser cierto tras la ejecuci´on de un subprograma.

Especifica el comportamiento de dicho subprograma.

Codificar las pre/post-condiciones mediante asertos proporciona una valiosa documentaci

´on, y tiene varias ventajas:

• Hace al programador expl´ıcitamente consciente de los prerrequisitos y del objetivo del

subprograma.

• Durante la depuraci´on, las pre-condiciones comprueban que la llamada al subprograma

se realiza bajo condiciones validas.

• Durante la depuraci´on, las post-condiciones comprueban que el comportamiento del

subprograma es adecuado.
• Sin embargo, a veces no es posible codificarlas f´acilmente.
En C++, las pre-condiciones y post-condiciones se pueden especificar mediante asertos, para los
cuales es necesario incluir la biblioteca cassert. Por ejemplo:
#include <iostream>
#include <cassert>
using namespace std;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

5.12. EJEMPLOS 49

//---------------------------
bool es_par(int num)
{
return num % 2 == 0;
}
//---------------------------
void dividir_par(int dividendo, int divisor, int& cociente, int& resto)
{
assert(es_par(dividendo) && (divisor != 0)); // PRE-CONDICI ´ON
cociente = dividendo / divisor;
resto = dividendo % divisor;
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}

Nota: en GNU GCC es posible desactivar la comprobaci´on de asertos mediante la siguiente

directiva de compilaci´on:
g++ -DNDEBUG -ansi -Wall -Werror -o programa programa.cpp

5.12. Ejemplos
Ejemplo 1
Ejemplo de un programa que imprime los nu´meros primos existentes entre dos valores le
´ıdos por teclado:
//- fichero: primos.cpp
#include <iostream>
using namespace std;
void ordenar(int& menor, int& mayor)
{
if (mayor < menor)
{ int aux = menor;
menor = mayor;
mayor = aux;
}
}
inline bool es_divisible(int x, int y)
{
return ( x % y == 0 );
}
bool es_primo(int x)
{
int i;
for (i = 2; ((i <= x/2) && ( ! es_divisible(x, i))); ++i) {
// vac´ıo
}
return (i == x/2+1);
}
void primos(int min, int max)
{
cout << "N´umeros primos entre " << min << " y " << max << endl;
for (int i = min; i <= max; ++i) {
if (es_primo(i))
{ cout << i << " "
;
}
}
cout << endl;
}
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
1 CAP´ITULO 5. SUBPROGRAMAS. FUNCIONES Y PROCEDIMIENTOS

int main()
{
int min, max;
cout << "Introduzca el rango de valores " ;
cin >> min >> max ;
ordenar(min, max);
primos(min, max);
}
//- fin: primos.cpp

Ejemplo 2
Ejemplo de un programa que convierte grados sexagesimales a radianes:
//- fichero: gradrad.cpp
#include <iostream>
#include <string>
using namespace std;
// -- Constantes -------
const double PI = 3.1416;
const int PI_GRAD = 180;
const int MIN_GRAD = 60;
const int SEG_MIN = 60;
const int SEG_GRAD = SEG_MIN * MIN_GRAD;
// -- Subalgoritmos ----
void leer_grados (int& grad, int& min, int& seg)
{
cout << "Grados, minutos y segundos ";
cin >> grad >> min >> seg;
}
//---------------------------
void escribir_radianes (double rad)
{
cout << "Radianes: " << rad << endl;
}
//---------------------------
double calc_rad (double grad_tot)
{
return (grad_tot * PI) / double(PI_GRAD);
}
//---------------------------
double calc_grad_tot (int grad, int min, int seg)
{
return double(grad) + (double(min) / double(MIN_GRAD)) + (double(seg) / double(SEG_GRAD));
}
//---------------------------
double transf_gr_rad (int grad, int min, int seg)
{
double gr_tot = calc_grad_tot(grad, min, seg);
return calc_rad(gr_tot);
}
// -- Principal --------
int main ()
{
int grad, min, seg;
leer_grados(grad, min, seg);
double rad = transf_gr_rad(grad, min, seg);
escribir_radianes(rad);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 6

Tipos Compuestos

Los tipos compuestos surgen de la composici´on y/o agregaci´on de otros tipos para formar
nuevos tipos de mayor entidad. Existen dos formas fundamentales para crear tipos de mayor
entidad: la composici´on de elementos, que denominaremos “Registros” o “Estructuras” y la
agregaci´on de elementos del mismo tipo, y se conocen como “Agregados”, “Arreglos” o
mediante su nombre en ingl´es “Arrays”. Adem´as de los tipos compuestos definidos por el
programador mencionados ante- riormente, los lenguajes de programaci´on suelen proporcionar
algu´ n tipo adicional para representar las “cadenas de caracteres”.

6.1. Paso de Par´ametros de Tipos Compuestos

Los lenguajes de programaci´on normalmente utilizan el paso por valor y el paso por
referencia para implementar la transferencia de informaci´on entre subprogramas descrita en el
interfaz. Para la transferencia de informaci´on de entrada, el paso por valor supone duplicar y
copiar el valor del par´ametro actual en el formal. En el caso de tipos simples, el paso por valor
es adecuado para la transferencia de informaci´on de entrada, sin embargo, si el tipo de dicho par
´ametro es compuesto, es posible que dicha copia implique una alta sobrecarga, tanto en espacio
de memoria como en tiempo de ejecuci´on. El lenguaje de programaci´on C++ permite realizar de
forma eficiente la transferencia de informaci´on de entrada para tipos compuestos mediante el
paso por referencia constante.

void imprimir(const Fecha& fech)

{
cout << fech.dia << (int(fech.mes)+1) << fech.anyo << endl;
}

Tipos
Simples Compuestos
(⇓) Entrada P.Valor P.Ref.Cte
(unsigned x) (const Persona& p)
(⇑) Salida, (m) E/S P.Ref P.Ref
(unsigned& x) (Persona& p)

Funciones que Retornan Tipos Compuestos

Por la misma raz´on y como norma general, salvo excepciones, tampoco es adecuado que
una funci´on retorne un valor de tipo compuesto, debido a la sobrecarga que generalmente ´esto
conlleva. En estos casos, suele ser m ´a s adecuado que el subprograma devuelva el valor de tipo
compuesto como un par´ametro de salida mediante el paso por referencia.

51
 6.2. CADENAS DE CARACTERES EN C++: EL TIPO STRING 1

6.2. Cadenas de Caracteres en C++: el Tipo String

Las cadenas de caracteres representan una sucesi´on o secuencia de caracteres. Es un tipo
de datos muy vers´atil, y es u´ til para representar informaci´on muy diversa:
Informaci´on textual (caracteres)
Entrada de datos y salida de resultados en forma de secuencia de
caracteres. Informaci´on abstracta por medio de una secuencia de
caracteres
Es posible utilizar el tipo string de la biblioteca est´andar para representar cadenas de
caracteres de longitud finita limitada por la implementaci´on. Para ello, se debe incluir la
biblioteca est´andar
<string>, as´ı como utilizar el espacio de nombres de std. La definici´on de cadenas de
caracteres de este tipo permite definir cadenas de caracteres mas robustas y con mejores
caracter´ısticas que las cadenas de caracteres predefinidas al estilo-C explicadas en el cap´ıtulo
8.
Es posible definir tanto constantes simb´olicas como variables y par´ametros de tipo
string. Una cadena de caracteres literal se representa mediante una sucesi´on de caracteres
entre comillas dobles. Tambi´en es posible la asignaci´on de cadenas de caracteres:
#include <iostream>
#include <string>
using namespace std;
const string AUTOR = "Jos´e Luis"; AUTOR: J o s e L u i s
int main() 0 1 2 3 4 5 6 7 8
{
nombre: P e p e
string nombre = "Pepe";
0 1 2 3
// ...
nombre = AUTOR; nombre: J o s e L u i s
} 0 1 2 3 4 5 6 7 8

Si no se le asigna un valor inicial a una variable de tipo string, entonces la variable tendr´a
como valor por defecto la cadena vac´ıa ("").

Entrada y Salida de Cadenas de Caracteres

El operador << aplicado a un flujo de salida (cout para el flujo de salida est´andar,
usualmente el terminal) permite mostrar el contenido de las cadenas de caracteres, tanto
constantes como variables. Por ejemplo:
#include <iostream>
#include <string>
using namespace std;
const string AUTOR = "Jos´e Luis";
int main()
{
string nombre = "Pepe";
cout << "Nombre: " << nombre << " " << AUTOR << endl;
}

El operador >> aplicado a un flujo de entrada (cin para el flujo de entrada est´andar,
usualmente el teclado) permite leer secuencias de caracteres y almacenarlas en variables de tipo
string. Por ejemplo:
#include <iostream>
#include <string>
using namespace std;
int main()
{
cout << "Introduzca el nombre: ";
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 6. TIPOS COMPUESTOS
string nombre;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.2. CADENAS DE CARACTERES EN C++: EL TIPO STRING 3

cin >> nombre;

cout << "Nombre: " << nombre << endl;
}

Este operador de entrada (>>) se comporta (como se especific´o en el cap´ıtulo 3.2 dedicado
a la Entrada y Salida b´asica) de la siguiente forma: elimina los espacios en blanco que hubiera
al principio de la entrada de datos, y lee dicha entrada hasta que encuentre algu´n car´acter de
espacio en blanco, que no ser´a le´ıdo y permanecer´a en el buffer de entrada (v´ease 3.3) hasta
la pr´oxima operaci´on de entrada. En caso de que durante la entrada surja alguna situaci´on
de error, dicha entrada se detiene y el flujo de entrada se pondr´a en un estado err´oneo. Se
consideran espacios en blanco los siguientes caracteres: espacio en blanco, tabuladores, retorno
de carro y nueva l´ınea (’ ’, ’\t’, ’\v’, ’\f’, ’\r’, ’\n’).
Tambi´en es posible leer una l´ınea completa, hasta leer el fin de l´ınea, desde el flujo de
entrada, sin eliminar los espacios iniciales:
#include <iostream>
#include <string>
using namespace std;
int main()
{
cout << "Introduzca el nombre: ";
string nombre;
getline(cin, nombre);
cout << "Nombre: " << nombre << endl;
}

Tambi´en es posible leer una l´ınea completa, hasta leer un delimitador especificado, desde
el flujo de entrada, sin eliminar los espacios iniciales:
#include <iostream>
#include <string>
using namespace std;
const char DELIMITADOR = ’.’;
int main()
{
cout << "Introduzca el nombre: ";
string nombre;
getline(cin, nombre, DELIMITADOR);
cout << "Nombre: " << nombre << endl;
}

N´otese que realizar una operaci´on getline despu´es de una operaci´on con >> puede tener
compli- caciones, ya que >> dejara los espacios en blanco (y fin de l´ınea) en el buffer, que ser´an
le´ıdos por getline. Por ejemplo:
#include <iostream>
#include <string>
using namespace std;
int main()
{
cout << "Introduzca n´umero: ";
int n;
cin >> n;
cout << "Introduzca el nombre: ";
string nombre;
getline(cin, nombre);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

Para evitar este problema, el siguiente subprograma leer´a una cadena que sea distinta de la vac´ıa:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 6. TIPOS COMPUESTOS

#include <iostream>
#include <string>
using namespace std;
inline void leer_linea_no_vacia(istream& ent, string& linea)
{
ent >> ws; // salta los espacios en blanco y fin de l´ınea
getline(ent, linea); // leer´a la primera l´ınea no vac´ıa
}
int main()
{
cout << "Introduzca n´umero: ";
int n;
cin >> n;
cout << "Introduzca el nombre (NO puede ser vac´ıo): ";
string nombre;
leer_linea_no_vacia(cin, nombre);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

Por el contrario, en caso de que la cadena vac´ıa sea una entrada v´alida, ser´a necesario
eliminar el resto de caracteres (incluyendo los espacios en blanco y fin de l´ınea) del buffer de
entrada, despu´es de leer un dato con >>, de tal forma que el buffer est´e limpio antes de realizar
la entrada de la cadena de caracteres con getline. Por ejemplo, el subprograma leer_int elimina
los caracteres del buffer despu´es de leer un dato de tipo int:
#include <iostream>
#include <string>
#include <limits>
using namespace std;
inline void leer_int(istream& ent, int& dato)
{
ent >> dato; // lee el dato
ent.ignore(numeric_limits<streamsize>::max(), ’\n’); // elimina los caracteres del buffer
// ent.ignore(10000, ’\n’); // otra posibilidad de eliminar los caracteres del buffer
}
int main()
{
cout << "Introduzca n´umero: ";
int n;
leer_int(cin, n);
cout << "Introduzca el nombre (puede ser vac´ıo): ";
string nombre;
getline(cin, nombre);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

T´engase en cuenta que para utilizar numeric_limits<...>, es necesario incluir la biblioteca est
´andar <limits>.

Operaciones con Cadenas de Caracteres

Las cadenas de caracteres se pueden asignar a variables de dicho tipo. Por ejemplo:
#include <iostream>
#include <string>
using namespace std;
const string AUTOR = "Jos´e Luis";
int main()
{
string nombre = "Pepe";

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.2. CADENAS DE CARACTERES EN C++: EL TIPO STRING 5

// ...
nombre = AUTOR;
}

Es posible realizar la comparaci´on lexicogr´afica1 entre cadenas de caracteres del tipo string
mediante los operadores relacionales (==, !=, >, >=, <, <=). Por ejemplo:

• if (nombre >= AUTOR) { /*...*/ }

Es posible la concatenaci´on de cadenas y caracteres mediante los operadores de concatenaci
´on (+, +=):

#include <iostream>
#include <string>
using namespace std;
const string AUTOR = "Jos´e Luis";
int main ()
{
string nombre = AUTOR + "L´opez";
nombre += "V´azque";
nombre += ’z’;
nombre = AUTOR + ’s’;
}

Comprobar si la cadena de caracteres est ´a vac´ıa:

• if (nombre.empty()) { /*...*/ }
Para acceder al nu´mero de caracteres que componen la cadena:

• unsigned ncar = nombre.size();

• unsigned ncar = nombre.length();
Para acceder al i-´esimo car´acter de la cadena:

• char c = nombre[i]; donde i ∈ [0..nombre.size()-1]

• nombre[i] = ’z’; donde i ∈ [0..nombre.size()-1]
Para acceder al i-´esimo car´acter de la cadena, comprobando que el valor del ´ındice (i)
es adecuado, de tal forma que si el ´ındice (i) se encuentra fuera de rango, entonces lanza
la excepci´on out_of_range (v´ease 12):

• char c = nombre.at(i); donde i ∈ [0..nombre.size()-1].

• nombre.at(i) = ’z’; donde i ∈ [0..nombre.size()-1].
Obtener una nueva subcadena a partir del ´ındice i, con un taman˜o especificado por sz. Si
no se especifica el taman˜o, o (sz > nombre.size()-i), entonces se toma la subcadena
desde el
´ındice hasta el final. Si el ´ındice (i) se encuentra fuera de rango, entonces lanza la excepci´on
out_of_range (v´ease 12):

• string sb = nombre.substr(i); donde i ∈ [0..nombre.size()]

• string sb = nombre.substr(i, sz); donde i ∈ [0..nombre.size()]
• N´otese que no es v´alida la asignaci´on a una subcadena: nombre.substr(i, sz) = "...";
1
Comparaci´on lexicogr´afica se basa en la ordenaci´on alfab´etica, y es comu´nmente utilizada en los diccionarios.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 6. TIPOS COMPUESTOS

Ejemplos
Ejemplo 1
Programa que convierte una cadena de caracteres a mayu´sculas:
#include <iostream>
#include <string>
using namespace std;
// -- Subalgoritmos ----
void mayuscula (char& letra)
{
if ((letra >= ’a’) && (letra <= ’z’)) {
letra = char(letra - ’a’ + ’A’);
}
}
void mayusculas (string& palabra)
{
for (unsigned i = 0; i < palabra.size(); ++i) {
mayuscula(palabra[i]);
}
}
// -- Principal --------
int main ()
{
string palabra;
cin >> palabra;
mayusculas(palabra);
cout << palabra << endl;
}

Ejemplo 2
Programa que lee una palabra (formada por letras minu´sculas), y escribe su plural segu´n las
siguientes reglas:
Si acaba en vocal se le an˜ade la letra ’s’.
Si acaba en consonante se le an˜aden las letras ’es’. Si la consonante es la letra ’z’, se sustituye
por la letra ’c’
Suponemos que la palabra introducida es correcta y est´a formada por letras minu´sculas.

#include <iostream>
#include <string>
using namespace std;
// -- Subalgoritmos ----
bool es_vocal (char c)
{
return (c == ’a’) || (c == ’e’) || (c == ’i’) || (c == ’o’) || (c == ’u’);
}
void plural_1 (string& palabra)
{
if (palabra.size() > 0) {
if (es_vocal(palabra[palabra.size() - 1]))
{ palabra += ’s’;
} else {
if (palabra[palabra.size() - 1] == ’z’)
{ palabra[palabra.size() - 1] = ’c’;
}
palabra += "es";
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.2. CADENAS DE CARACTERES EN C++: EL TIPO STRING 7

}
}
void plural_2 (string& palabra)
{
if (palabra.size() > 0) {
if (es_vocal(palabra[palabra.size() - 1]))
{ palabra += ’s’;
} else if (palabra[palabra.size() - 1] == ’z’) {
palabra = palabra.substr(0, palabra.size() - 1) + "ces";
} else {
palabra += "es";
}
}
}
// -- Principal --------
int main ()
{
string palabra;
cin >> palabra;
plural_1(palabra);
cout << palabra << endl;
}

Ejemplo 3
Disen˜e una funci´on que devuelva verdadero si la palabra recibida como par´ametro es “pal
´ındro- mo” y falso en caso contrario.
bool es_palindromo (const string& palabra)
{
bool ok = false;
if (palabra.size() > 0)
{ unsigned i = 0;
unsigned j = palabra.size() - 1;
while ((i < j) && (palabra[i] == palabra[j])) {
++i;
--j;
}
ok = i >= j;
}
return ok;
}

Ejemplo 4
Disen˜e un subprograma que reemplace una parte de la cadena, especificada por un ´ındice y una
longitud, por otra cadena.
void reemplazar (string& str, unsigned i, unsigned sz, const string& nueva)
{
if (i + sz < str.size()) {
str = str.substr(0, i) + nueva + str.substr(i + sz, str.size() - (i + sz));
} else if (i <= str.size()) {
str = str.substr(0, i) + nueva;
}
}
Este subprograma es equivalente a la operaci´on str.replace(i, sz, nueva)
str.replace(i, 0, nueva) es equivalente a str.insert(i, nueva)
str.replace(i, sz, "") es equivalente a str.erase(i, sz).

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 8 CAP´ITULO 6. TIPOS COMPUESTOS

A Otras Operaciones con Cadenas de Caracteres

En las siguientes operaciones, s1 y s2 representan cadenas de caracteres de tipo string. i1
e i2 representan ´ındices dentro de dichas cadenas, as´ı como sz1 y sz2 representan taman˜os (nu
´mero de caracteres) dentro de dichas cadenas.
string s1;
string s2 = "pepeluis";
string s3 = s2;

string s4(s2, i2); // construcci´on

string s5(s2, i2, sz2);
string s6("juanluis", sz2);
string s8(sz2, ’a’);

s1.clear(); // limpieza. equivalente a: s1 = "";

s1.assign(s2); // asignar
s1.assign(s2, i2);
s1.assign(s2, i2, sz2);
s1.assign("pepe");
s1.assign("pepe", sz2);
s1.assign(sz2, ’a’);

s1.append(s2); //
a~nadir s1.append(s2, i2);
s1.append(s2, i2, sz2);
s1.append("pepe");
s1.append("pepe", sz2);
s1.append(sz2, ’a’);

s1.insert(i1, s2); // insertar

s1.insert(i1, s2, i2);
s1.insert(i1, s2, i2, sz2);
s1.insert(i1, "pepe");
s1.insert(i1, "pepe", sz2);
s1.insert(i1, sz2, ’a’);

s1.erase(i1); // eliminar
s1.erase(i1, sz1);

s1.replace(i1, sz1, s2); // reemplazar

s1.replace(i1, sz1, s2, i2);
s1.replace(i1, sz1, s2, i2, sz2);
s1.replace(i1, sz1, "pepe");
s1.replace(i1, sz1, "pepe", sz2);
s1.replace(i1, sz1, sz2, ’a’);

s1.resize(sz); // cambiar el tama~no

s1.resize(sz, ’a’);

int c = s1.compare(s2); // comparar. devuelve < == > que 0

int c = s1.compare(i1, sz1, s2);
int c = s1.compare(i1, sz1, s2, i2);
int c = s1.compare(i1, sz1, s2, i2, sz2);
int c = s1.compare("pepe");
int c = s1.compare(i1, sz1, "pepe");
int c = s1.compare(i1, sz1, "pepe", sz2);

s1.reserve(tamano); // reserva de la memoria interna

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 6.3. REGISTROS O ESTRUCTURAS 1

string::size_type mx = s1.capacity(); // capacidad de la reserva

Obtener la secuencia de caracteres como un cadena de caracteres al estilo-C (terminado en

’\0’), para compatibilidad con subprogramas y bibliotecas que necesitan las cadenas de caracteres
en dicho estilo (aquellas con prototipos const char* xx y const char xx[]):
const char* cad_c = s1.c_str();

char dest_c[MAX];
s1.copy(dest_c, sz1, i1 = 0); // sz1 <= MAX ; no pone ’\0’

En las siguientes bu´squedas, el patr´on a buscar puede ser un string, cadena de caracteres
constante o un car´acter. Si la posici´on indicada est ´a fuera de los l´ımites del string,
entonces se lanza una excepci´on out_of_range.
unsigned i1 = s1.find(’a’, i1=0); // buscar el patr´on exacto
unsigned i1 = s1.find(s2, i1=0);
unsigned i1 = s1.find("cd", i1=0);
unsigned i1 = s1.find("cd", i1, sz2);

unsigned i1 = s1.rfind(’a’, i1=npos); // buscar el patr´on exacto

unsigned i1 = s1.rfind(s2, i1=npos);
unsigned i1 = s1.rfind("cd", i1=npos);
unsigned i1 = s1.rfind("cd", i1, sz2);

unsigned i1 = s1.find_first_of(’a’, i1=0); // buscar cualquier car´acter del patr´on

unsigned i1 = s1.find_first_of(s2, i1=0);
unsigned i1 = s1.find_first_of("cd", i1=0);
unsigned i1 = s1.find_first_of("cd", i1, sz2);

unsigned i1 = s1.find_first_not_of(’a’, i1=0);

unsigned i1 = s1.find_first_not_of(s2, i1=0);
unsigned i1 = s1.find_first_not_of("cd", i1=0);
unsigned i1 = s1.find_first_not_of("cd", i1, sz2);

unsigned i1 = s1.find_last_of(’a’, i1=npos);

unsigned i1 = s1.find_last_of(s2, i1=npos);
unsigned i1 = s1.find_last_of("cd", i1=npos);
unsigned i1 = s1.find_last_of("cd", i1, sz2);

unsigned i1 = s1.find_last_not_of(’a’, i1=npos);

unsigned i1 = s1.find_last_not_of(s2, i1=npos);
unsigned i1 = s1.find_last_not_of("cd", i1=npos);
unsigned i1 = s1.find_last_not_of("cd", i1, sz2);

string::npos -> valor devuelto si no encontrado

6.3. Registros o Estructuras

El tipo registro se utiliza para la definici´on de un nuevo tipo mediante la composici´on de
un nu´mero determinado de elementos que pueden ser de distintos tipos (simples y compuestos).
Un tipo registro se especifica enumerando los elementos (campos) que lo componen, indicando
su tipo y su identificador con el que referenciarlo. Una vez definido el tipo, podremos utilizar la
entidad (constante o variable) de dicho tipo como un todo o acceder a los diferentes elementos
que lo componen. Por ejemplo, dado el tipo Meses definido en el Cap´ıtulo 2, podemos definir un
nuevo
tipo que represente el concepto de Fecha como composici´on de d´ı a, mes y an˜ o.
struct Fecha {
unsigned dia;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 6. TIPOS COMPUESTOS

Meses mes;
unsigned anyo;
};

y posteriormente utilizarlo para definir constantes:

const Fecha f_nac = { 20 , Febrero, 2001} ;

o utilizarlo para definir variables:

Fecha f_nac;

Los valores del tipo Fecha se componen de tres elementos concretos (el d´ıa de tipo unsigned,
el mes de tipo Meses y el a n˜ o de tipo unsigned). Los identificadores dia, mes y anyo
representan los nombres de sus elementos componentes, denominados campos, y su ´ambito
de visibilidad se restringe a la propia definici´on del registro. Los campos de un registro pueden ser
de cualquier tipo de datos, simple o estructurado. Por ejemplo:
// Tipos
struct Empleado
{ unsigned codigo;
unsigned sueldo;
Fecha fecha_ingreso;
};
enum Palo {
Oros, Copas, Espadas, Bastos
};
struct Carta
{ Palo palo;
unsigned valor;
};
struct Tiempo
{ unsigned
hor; unsigned
min; unsigned
seg;
};
// -- Principal --------
int main ()
{
Empleado e;
Carta c;
Tiempo t1, t2;
// ...
}

Una vez declarada una entidad (constante o variable) de tipo registro, por ejemplo la variable
f nac, podemos referirnos a ella en su globalidad (realizando asignaciones y pasos de par
´ametros) o acceder a sus componentes (campos) especific´andolos tras el operador punto (.),
donde un determinado componente podr´a utilizarse en cualquier lugar en que resulten v
´alidas las variables de su mismo tipo.

int main ()
{ dia: 18 dia: 18
Fecha f_nac, hoy; mes: Octubre mes: Octubre
f_nac.dia = 18; anyo: 2001 anyo: 2001
f_nac.mes = Octubre;
f_nac.anyo = 2001; f nac hoy

hoy = f_nac;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.3. REGISTROS O ESTRUCTURAS 3

Ejemplo
#include <iostream>
#include <string>
using namespace std;
// -- Constantes -------
const unsigned SEGMIN = 60;
const unsigned MINHOR = 60;
const unsigned MAXHOR = 24;
const unsigned SEGHOR = SEGMIN * MINHOR;
// Tipos
struct Tiempo
{ unsigned horas;
unsigned minutos;
unsigned segundos;
};
// -- Subalgoritmos ----
unsigned leer_rango (unsigned inf, unsigned sup)
{
unsigned num;
do {
cin >> num;
} while ( ! ((num >= inf ) && (num < sup)));
return num;
}
void leer_tiempo (Tiempo& t)
{
t.horas = leer_rango(0, MAXHOR);
t.minutos = leer_rango(0, MINHOR);
t.segundos = leer_rango(0, SEGMIN);
}
void escribir_tiempo (const Tiempo& t)
{
cout << t.horas << ":" << t.minutos << ":" << t.segundos;
}
unsigned tiempo_a_seg (const Tiempo& t)
{
return (t.horas * SEGHOR) + (t.minutos * SEGMIN) + (t.segundos);
}
void seg_a_tiempo (unsigned sg, Tiempo& t)
{
t.horas = sg / SEGHOR;
t.minutos = (sg % SEGHOR) / SEGMIN;
t.segundos = (sg % SEGHOR) % SEGMIN;
}
void diferencia (const Tiempo& t1, const Tiempo& t2, Tiempo& dif)
{
seg_a_tiempo(tiempo_a_seg(t2) - tiempo_a_seg(t1), dif);
}
// -- Principal --------
int main ()
{
Tiempo t1, t2, dif;
leer_tiempo(t1);
leer_tiempo(t2);
diferencia(t1, t2, dif );
escribir_tiempo(dif);
cout << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 4 CAP´ITULO 6. TIPOS COMPUESTOS

A Sobrecarga de Operadores para Estructuras

En caso de ser necesario, es posible definir los operadores relacionales para registros:
inline bool operator == (const Tiempo& t1, const Tiempo& t2)
{
return (t1.hor == t2.hor) && (t1.min == t2.min) && (t1.seg == t2.seg);
}
inline bool operator != (const Tiempo& t1, const Tiempo& t2)
{
return ! (t1 == t2);
}
inline bool operator < (const Tiempo& t1, const Tiempo& t2)
{
return ((t1.hor < t2.hor)
|| ((t1.hor == t2.hor) && ((t1.min < t2.min)
|| ((t1.min == t2.min) && (t1.seg < t2.seg)))));
}
inline bool operator > (const Tiempo& t1, const Tiempo& t2)
{
return (t2 < t1);
}
inline bool operator <= (const Tiempo& t1, const Tiempo& t2)
{
return ! (t2 < t1);
}
inline bool operator >= (const Tiempo& t1, const Tiempo& t2)
{
return ! (t1 < t2);
}

As´ı como tambi´en es posible definir los operadores de entrada y salida para registros:
inline ostream& operator << (ostream& out, const Tiempo& t)
{
return out << t.hor << " " << t.min << " " << t.seg ;
}
inline istream& operator >> (istream& in, Tiempo& t)
{
return in >> t.hor >> t.min >> t.seg ;
}
int main()
{
Tiempo t1, t2;
cin >> t1 >> t2;
if (t1 < t2) {
cout << t1 << endl;
} else {
cout << t2 << endl;
}
}

N´otese como en la definici´on de los operadores de entrada y salida para registros, estos
mismos retornan un valor de tipo referencia, el cual es un concepto complejo que s er ´a
explicado m ´a s adelante (v´ease 13).

6.4. Agregados: el Tipo Array

El tipo array se utiliza para la definici´on de un nuevo tipo mediante la agregaci´on de
entidades menores del mismo tipo, es decir, se define como una colecci´on de un nu´mero
determinado (definido
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
6.4. AGREGADOS: EL TIPO ARRAY 1

en tiempo de compilaci´on) de elementos de un mismo tipo de datos, de tal forma que se puede
acceder a cada elemento individual de la colecci´on de forma parametrizada mediante ´ındices.
Los arrays son u´tiles en todas aquellas circunstancias en que necesitamos tener
almacenados una colecci´on de valores (un nu´mero fijo predeterminado en tiempo de
compilaci´on) a los cuales pretendemos acceder de forma parametrizada, normalmente para
aplicar un proceso iterativo.
Es posible utilizar el tipo array de la biblioteca TR1 para definir agregados. Para ello, se
debe incluir la biblioteca <tr1/array>, as´ı como utilizar el espacio de nombres de std::tr1.
La definici´on de agregados de este tipo permite definir agregados mas robustos y con mejores
caracter´ısticas que los agregados predefinidos explicados en el cap´ıtulo 8.
Un tipo agregado se especifica declarando el tipo base de los elementos que lo componen y
el nu´mero de elementos (constante especificada en tiempo de compilaci´on) de que consta dicha
agre- gaci´on. As´ı, por ejemplo, podemos definir un nuevo tipo Vector como un agregado de 5
elementos, cada uno del tipo int, y definir variables y constantes de dicho tipo (n´otese que los
elementos constantes del tipo array se especifican entre llaves dobles):
#include <tr1/array>
using namespace std::tr1;
// -- Constantes -------
const unsigned NELMS = 5;
// Tipos
typedef array<int, NELMS> Vector;
// -- Constantes -------
const Vector PRIMOS = {{ 2, 3, 5, 7, 11 }}; PRIMOS: 2 3 5 7 11
// -- Principal -------- 0 1 2 3 4
int main ()
{
Vector v; v: ? ? ? ? ?
} 0 1 2 3 4

El tipo base (de los elementos) del array puede ser de tipo simple o compuesto, as´ı, por
ejemplo, podemos definir un nuevo tipo Citas como un agregado de 4 elementos, cada uno del
tipo Fecha, y definir variables y constantes de dicho tipo:
#include <tr1/array>
using namespace std::tr1;
struct Fecha {
unsigned dia;
unsigned mes;
unsigned anyo;
};
const int N_CITAS = 4;
typedef array<Fecha, N_CITAS> Citas;
const Citas CUMPLEANYOS = {{
CUMPLEANYOS:
{ 1, 1, 2001 },
{ 2, 2, 2002 }, 1 2 3 4
{ 3, 3, 2003 }, 1 2 3 4
{ 4, 4, 2004 } 2001 2002 2003 2004
}}; 0 1 2 3
int main()
{
Citas cit;
// ...
cit = CUMPLEANYOS;
}

Un agregado de tipo array<...> acepta la asignaci´on (=) entre variables de dicho tipo. Tambi
´en se le pueden aplicar los operadores relacionales (==, !=, >, >=, <, <=) a entidades del mismo
tipo array<...> siempre y cuando a los elementos del agregado (del tipo base del array) se le
puedan aplicar dichos operadores.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 6. TIPOS COMPUESTOS

Para conocer el nu´mero de elementos que componen un determinado agregado, la operaci´on

cit.size() proporciona dicho valor, que en este ejemplo es 4.
Para acceder a un elemento concreto del agregado, especificaremos entre corchetes ([ y ])
el ´ındice de la posici´on que ocupa el mismo, teniendo en cuenta que el primer elemento
ocupa la posici´on 0 (cero) y el u´ltimo elemento ocupa la posici´on a.size()-1. Por ejemplo
cit[0] y cit[cit.size()-1] aluden al primer y u´ltimo elemento del agregado respectivamente.
Un deter- minado elemento puede utilizarse en cualquier lugar donde sea v´alido una variable
de su mismo
tipo base.
El lenguaje de programaci´on C++ no comprueba que los accesos a los elementos de un agregado
sean correctos y se encuentren dentro de los l´ımites v´alidos del array, por lo que ser´a
responsabilidad del programador comprobar que as´ı sea.
Tambi´en es posible acceder a un determinado elemento mediante la operaci´on at(i), de
tal forma que si el valor del ´ındice i est´a fuera del rango v´alido, entonces se lanzar´a una
excepci´on out_of_range. Se puede tanto utilizar como modificar el valor de este elemento.
#include <tr1/array>
using namespace std::tr1;
struct Fecha {
unsigned dia;
unsigned mes;
unsigned anyo;
};
const int N_CITAS = 4;
typedef array<Fecha, N_CITAS> Citas;
int main()
{
Citas cit;
cit[0].dia = 18;
cit[0].mes = 10;
cit[0].anyo = 2001;
for (int i = 0; i < cit.size(); ++i)
{ cit[i].dia = 1;
cit[i].mes = 1;
cit[i].anyo = 2002;
}
cit[N_CITAS] = { 1, 1, 2002 }; // ERROR. Acceso fuera de los l´ımites
cit.at(N_CITAS) = { 1, 1, 2002 }; // ERROR. Lanza excepci´on out_of_range
// ...
}

Ejemplo 1
#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned NELMS = 5;
// Tipos
typedef array<int, NELMS> Vector;
// -- Subalgoritmos ----
void leer (Vector& v)
{
for (unsigned i = 0; i < v.size(); ++i)
{ cin >> v[i];
}
}
unsigned sumar (const Vector& v)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.4. AGREGADOS: EL TIPO ARRAY 3

{
int suma = 0;
for (unsigned i = 0; i < v.size(); ++i) {
suma += v[i];
}
return suma;
}
// -- Principal --------
int main ()
{
Vector v1, v2;
leer(v1);
leer(v2);
if (sumar(v1) == sumar(v2)) {
cout << "Misma suma" << endl;
}
if (v1 < v2) {
cout << "Vector Menor" << endl;
}
v1 = v2; // Asignaci´on
if (v1 == v2) {
cout << "Vectores Iguales" << endl;
}
}

Ejemplo 2
Programa que lee las ventas de cada “agente” e imprime su sueldo que se calcula como una
cantidad fija (1000 C) m ´a s un incentivo que s er´a un 10 % de las ventas que ha realizado.
Dicho incentivo s´olo ser´a aplicable a aquellos agentes cuyas ventas superen los 2/3 de la media
de ventas del total de los agentes.

#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned NAGENTES = 20;
const double SUELDO_FIJO = 1000.0;
const double INCENTIVO = 10.0;
const double PROMEDIO = 2.0 / 3.0;
// Tipos
typedef array<double, NAGENTES> Ventas;
// -- Subalgoritmos ----
double calc_media (const Ventas& v)
{
double suma = 0.0;
for (unsigned i = 0; i < v.size(); ++i) {
suma += v[i];
}
return suma / double(v.size());
}
inline double porcentaje (double p, double valor)
{
return (p * valor) / 100.0;
}
void leer_ventas (Ventas& v)
{
for (unsigned i = 0; i < v.size(); ++i) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 6. TIPOS COMPUESTOS

cout << "Introduzca ventas del Agente " << i << ": ";
cin >> v[i];
}
}
void imprimir_sueldos (const Ventas& v)
{
double umbral = PROMEDIO * calc_media(ventas);
for (unsigned i = 0; i < v.size(); ++i) {
double sueldo = SUELDO_FIJO;
if (v[i] >= umbral) {
sueldo += porcentaje(INCENTIVO, v[i]);
}
cout << "Agente: " << i << " Sueldo: " << sueldo << endl;
}
}
// -- Principal --------
int main ()
{
Ventas ventas;
leer_ventas(ventas);
imprimir_sueldos(ventas);
}

Agregados Incompletos
Hay situaciones donde un array se define en tiempo de compilaci´on con un taman˜o mayor
que el nu´mero de elementos actuales v´alidos que contendr´a durante el Tiempo de Ejecuci
´on.
Gestionar el array con huecos durante la ejecuci´on del programa suele ser, en la mayor´ıa de los casos,
complejo e ineficiente.
Mantener los elementos actuales v´alidos consecutivos al comienzo del array suele ser m´as adecuado:
• Marcar la separacion entre los elementos actuales v´alidos de los elementos vac´ıos con algu´n
valor de adecuado suele ser, en la mayor´ıa de los casos, complejo e ineficiente.
• Definir un registro que contenga tanto el array, como el nu´mero de elementos actuales v
´alidos consecutivos que contiene suele ser m´as adecuado.

Ejemplo
#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned MAX_AGENTES = 20;
const double SUELDO_FIJO = 1000.0;
const double INCENTIVO = 10.0;
const double PROMEDIO = 2.0 / 3.0;
// Tipos
typedef array<double, MAX_AGENTES> Datos;
struct Ventas {
unsigned nelms;
Datos elm;
};
// -- Subalgoritmos ----
double calc_media (const Ventas& v)
{
double suma = 0.0;
for (unsigned i = 0; i < v.nelms; ++i) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.4. AGREGADOS: EL TIPO ARRAY 5

suma += v.elm[i];
}
return suma / double(v.nelms);
}
inline double porcentaje (double p, double valor)
{
return (p * valor) / 100.0;
}
void leer_ventas_ag (unsigned i, double& v)
{
cout << "Introduzca ventas Agente " << i << ": ";
cin >> v;
}
//
// Dos m´etodos diferentes de leer un
// vector incompleto:
//
// M´etodo-1: cuando se conoce a priori el n´umero
// de elementos que lo componen
//
void leer_ventas_2 (Ventas& v)
{
unsigned nag;
cout << "Introduzca total de agentes: ";
cin >> nag;
if (nag > v.elm.size())
{ v.nelms = 0;
cout << "Error" << endl;
} else {
v.nelms = nag;
for (unsigned i = 0; i < v.nelms; ++i)
{ leer_ventas_ag(i, v.elm[i]);
}
}
}
//
// M´etodo-2: cuando NO se conoce a priori el n´umero
// de elementos que lo componen, y este
// n´umero depende de la propia lectura de
// los datos
//
void leer_ventas_1 (Ventas& v)
{
double vent_ag;
v.nelms = 0;
leer_ventas_ag(v.nelms+1, vent_ag);
while ((v.nelms < v.elm.size())&&(vent_ag > 0))
{ v.elm[v.nelms] = vent_ag;
++v.nelms;
leer_ventas_ag(v.nelms+1, vent_ag);
}
}
//
void imprimir_sueldos (const Ventas& v)
{
double umbral = PROMEDIO * calc_media(ventas);
for (unsigned i = 0; i < v.nelms; ++i) {
double sueldo = SUELDO_FIJO;
if (v.elm[i] >= umbral) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 6. TIPOS COMPUESTOS

sueldo += porcentaje(INCENTIVO, v.elm[i]);

}
cout << "Agente: " << i << " Sueldo: " << sueldo << endl;
}
}
// -- Principal --------
int main ()
{
Ventas ventas;
leer_ventas(ventas);
imprimir_sueldos(ventas);
}

Agregados Multidimensionales
El tipo Base de un array puede ser tanto simple como compuesto, por lo tanto puede ser
otro array, dando lugar a arrays con mu´ltiples dimensiones . As´ı, cada elemento de un array
puede ser a su vez otro array.
Los agregados anteriormente vistos se denominan de una dimensi´on. As´ı mismo, es
posible declarar agregados de varias dimensiones. Un ejemplo de un agregado de dos
dimensiones:
#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned NFILAS = 3;
const unsigned NCOLUMNAS = 5;
// Tipos
typedef array<unsigned, NCOLUMNAS> Fila;
typedef array<Fila, NFILAS> Matriz;
// -- Principal --------
int main ()
{ m:
Matriz m; 0 00 01 02 03 04
for (unsigned f = 0; f < m.size(); ++f ) { 1 10 11 12 13 14
for (unsigned c = 0; c < m[f ].size(); ++c) { 2 20 21 22 23 24
m[f][c] = (f * 10) + c; 0 1 2 3 4
}
}
Matriz mx = m; // asigna a mx los valores de la Matriz m
Fila fil = m[0]; // asigna a fil el array con valores {{ 00, 01, 02, 03, 04 }}
unsigned n = m[2][4]; // asigna a n el valor 24
}
Donde m hace referencia a una variable de tipo Matriz, m[f] hace referencia a la fila f de la matriz
m (que es de tipo Fila), y m[f][c] hace referencia al elemento c de la fila f de la matriz m (que
es de tipo unsigned). Del mismo modo, el nu´mero de filas de la matriz m es igual a
m.size(), y el nu´mero de elementos de la fila f de la matriz m es igual a m[f].size().

Ejemplo 1
Disen˜ar un programa que lea una matriz de ×
3 5 de nu´meros enteros (fila a fila), almacen
´andolos en un array bidimensional, finalmente imprima la matriz segu´ n el siguiente formato:

a a a a a b
a a a a a b
a a a a a b
c c c c c

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.4. AGREGADOS: EL TIPO ARRAY 7

donde a representa los elementos de la matriz le´ıda desde el teclado, b representa el resultado
de sumar todos los elementos de la fila correspondiente, y c representa el resultado de sumar todos
los elementos de la columna donde se encuentran. N´otese en el ejemplo como es posible pasar
como par´ametro una u´nica fila, y sin embargo no es posible pasar como par´ametro una u
´nica columna.

#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned NFILAS = 3;
const unsigned NCOLUMNAS = 5;
// Tipos
typedef array<int, NCOLUMNAS> Fila;
typedef array<Fila, NFILAS> Matriz;
// -- Subalgoritmos ----
int sumar_fila (const Fila& fil)
{
int suma = 0;
for (unsigned c = 0; c < fil.size(); ++c) {
suma += fil[c];
}
return suma;
}
int sumar_columna (const Matriz& m, unsigned c)
{
int suma = 0;
for (unsigned f = 0; f < m.size(); ++f ) {
suma += m[f ][c];
}
return suma;
}
void escribir_fila (const Fila& fil)
{
for (unsigned c = 0; c < fil.size(); ++c)
{ cout << fil[c] << " ";
}
}
void escribir_matriz_formato (const Matriz& m)
{
for (unsigned f = 0; f < m.size(); ++f ) {
escribir_fila(m[f]);
cout << sumar_fila(m[f]);
cout << endl;
}
for (unsigned c = 0; c < m[0].size(); ++c)
{ cout << sumar_columna(m, c) << " ";
}
cout << endl;
}
void leer_matriz (Matriz& m)
{
cout << "Escribe fila a fila" << endl;
for (unsigned f = 0; f < m.size(); ++f) {
for (unsigned c = 0; c < m[f].size(); ++c)
{ cin >> m[f][c];
}
}
}
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
8 CAP´ITULO 6. TIPOS COMPUESTOS

// -- Principal --------
int main ()
{
Matriz m;
leer_matriz(m);
escribir_matriz_formato(m);
}

Ejemplo 2
Disen˜e un programa que realice el producto de 2 matrices de m´aximo 10 × 10 elementos:
#include <iostream>
#include <cassert>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned MAX = 10;
// Tipos
typedef array<double, MAX> Fila;
typedef array<Fila, MAX> Tabla;
struct Matriz {
unsigned n_fil;
unsigned n_col;
Tabla datos;
};
// -- Subalgoritmos ----
void leer_matriz (Matriz& m)
{
cout << "Dimensiones?: ";
cin >> m.n_fil >> m.n_col;
assert(m.n_fil <= m.datos.size() && m.n_col <= m.datos[0].size());
cout << "Escribe valores fila a fila:" << endl;
for (unsigned f = 0; f < m.n_fil; ++f) {
for (unsigned c = 0; c < m.n_col; ++c)
{ cin >> m.datos[f][c];
}
}
}
void escribir_matriz (const Matriz& m)
{
for (unsigned f = 0; f < m.n_fil; ++f) {
for (unsigned c = 0; c < m.n_col; ++c)
{ cout << m.datos[f][c] << " ";
}
cout << endl;
}
}
double suma_fila_por_col (const Matriz& x, const Matriz& y, unsigned f, unsigned c)
{
assert(x.n_col == y.n_fil); // PRE-COND
double suma = 0.0;
for (unsigned k = 0; k < x.n_col; ++k)
{ suma += x.datos[f][k] * y.datos[k][c];
}
return suma;
}
void mult_matriz (Matriz& m, const Matriz& a, const Matriz& b)
{

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 6.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 1
COMPUESTOS
assert(a.n_col == b.n_fil); // PRE-COND
m.n_fil = a.n_fil;
m.n_col = b.n_col;
for (unsigned f = 0; f < m.n_fil; ++f) {
for (unsigned c = 0; c < m.n_col; ++c) { m.datos[f ]
[c] = suma_fil_por_col(a, b, f, c);
}
}
}
// -- Principal --------
int main ()
{
Matriz a,b,c;
leer_matriz(a);
leer_matriz(b);
if (a.n_col != b.n_fil) {
cout << "No se puede multiplicar." << endl;
} else {
mult_matriz(c, a, b);
escribir_matriz(c);
}
}

6.5. Resoluci´on de Problemas Utilizando Tipos Compuestos

Disen˜ e un programa para gestionar una agenda personal que contenga la siguiente
informa- ci´on: Nombre, Tel´efono, Direcci´on, Calle, Nu´mero, Piso, C´odigo Postal y Ciudad,
y las siguientes operaciones:
An˜adir los datos de una persona.
Acceder a los datos de una persona a partir de su nombre.
Borrar una persona a partir de su nombre.
Modificar los datos de una persona a partir de su nombre.
Listar el contenido completo de la agenda.

#include <iostream>
#include <string>
#include <cassert>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned MAX_PERSONAS = 50;
// Tipos
struct Direccion {
unsigned num;
string calle;
string piso;
string cp;
string ciudad;
};
struct Persona {
string nombre;
string tel;
Direccion direccion;
};
// Tipos

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 6. TIPOS COMPUESTOS

typedef array<Persona, MAX_PERSONAS> Personas;

struct Agenda {
unsigned n_pers;
Personas pers;
};
enum Cod_Error {
OK, AG_LLENA, NO_ENCONTRADO, YA_EXISTE
};
// -- Subalgoritmos ----
void Inicializar (Agenda& ag)
{
ag.n_pers = 0;
}
//---------------------------
void Leer_Direccion (Direccion& dir)
{
cin >> dir.calle;
cin >> dir.num;
cin >> dir.piso;
cin >> dir.cp;
cin >> dir.ciudad;
}
//---------------------------
void Escribir_Direccion (const Direccion& dir)
{
cout << dir.calle << " ";
cout << dir.num << " ";
cout << dir.piso << " ";
cout << dir.cp << " ";
cout << dir.ciudad << " ";
}
//---------------------------
void Leer_Persona (Persona& per)
{
cin >> per.nombre;
cin >> per.tel;
Leer_Direccion(per.direccion);
}
//---------------------------
void Escribir_Persona (const Persona& per)
{
cout << per.nombre << " ";
cout << per.tel << " ";
Escribir_Direccion(per.direccion);
cout << endl;
}
//---------------------------
// Busca una Persona en la Agenda
// Devuelve su posici´on si se encuentra, o bien >= ag.n_pers en otro caso
unsigned Buscar_Persona (const string& nombre, const Agenda& ag)
{
unsigned i = 0;
while ((i < ag.n_pers) && (nombre != ag.pers[i].nombre)) {
++i;
}
return i;
}
//---------------------------
void Anyadir (Agenda& ag, const Persona& per)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 3
COMPUESTOS
{
assert(ag.n_pers < ag.pers.size());
ag.pers[ag.n_pers] = per;
++ag.n_pers;
}
//---------------------------
void Eliminar (Agenda& ag, unsigned pos)
{
assert(pos < ag.n_pers);
if (pos < ag.npers-1) {
ag.pers[pos] = ag.pers[ag.n_pers - 1];
}
--ag.n_pers;
}
//---------------------------
void Anyadir_Persona (const Persona& per, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(per.nombre, ag);
if (i < ag.n_pers) {
ok = YA_EXISTE;
} else if (ag.n_pers >= ag.pers.size()) {
ok = AG_LLENA;
} else {
ok = OK;
Anyadir(ag, per);
}
}
//---------------------------
void Borrar_Persona (const string& nombre, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Eliminar(ag, i);
}
}
//---------------------------
void Modificar_Persona (const string& nombre, const Persona& nuevo, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
Eliminar(ag, i);
Anyadir_Persona(nuevo, ag, ok);
}
}
//---------------------------
void Imprimir_Persona (const string& nombre, const Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Escribir_Persona(ag.pers[i]);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 6. TIPOS COMPUESTOS

}
//---------------------------
void Imprimir_Agenda (const Agenda& ag, Cod_Error& ok)
{
for (unsigned i = 0; i < ag.n_pers; ++i) {
Escribir_Persona(ag.pers[i]);
}
ok = OK;
}
//---------------------------
char Menu ()
{
char opcion;
cout << endl;
cout << "a. - A~nadir Persona" << endl;
cout << "b. - Buscar Persona" << endl;
cout << "c. - Borrar Persona" << endl;
cout << "d. - Modificar Persona" << endl;
cout << "e. - Imprimir Agenda" << endl;
cout << "x. - Salir" << endl;
do {
cout << "Introduzca Opci´on: ";
cin >> opcion;
} while ( ! (((opcion >= ’a’) && (opcion <= ’e’)) || (opcion == ’x’)));
return opcion;
}
//---------------------------
void Escribir_Cod_Error (Cod_Error cod)
{
switch (cod)
{ case OK:
cout << "Operaci´on correcta" << endl;
break;
case AG_LLENA:
cout << "Agenda llena" << endl;
break;
case NO_ENCONTRADO:
cout << "La persona no se encuentra en la agenda" << endl;
break;
case YA_EXISTE:
cout << "La persona ya se encuentra en la agenda" << endl;
break;
}
}
// -- Principal --------
int main ()
{
Agenda ag;
char opcion;
Persona per;
string nombre;
Cod_Error ok;
Inicializar(ag);
do {
opcion = Menu();
switch (opcion)
{ case ’a’:
cout << "Introduzca los datos de la Persona" << endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 5
COMPUESTOS
Leer_Persona(per);
Anyadir_Persona(per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’b’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
Imprimir_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’c’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
Borrar_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’d’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
cout << "Nuevos datos de la Persona" << endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;
Leer_Persona(per);
Modificar_Persona(nombre, per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’e’:
Imprimir_Agenda(ag, ok);
Escribir_Cod_Error(ok);
break;
}
} while (opcion != ’x’ );
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 6. TIPOS COMPUESTOS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 7

Bu´squeda y Ordenaci´on

Los algoritmos de bu´squeda de un elemento en una colecci´on de datos, as´ı como los
algoritmos de ordenaci´on, son muy utilizados comu´nmente, por lo que merecen un estudio expl
´ıcito. En el caso de los algoritmos de bu´squeda, ´estos normalmente retornan la posici´on,
dentro de la colecci´on de datos, del elemento buscado, y en caso de no ser encontrado, retornan
una posici´on no v´alida. Por otra parte, los algoritmos de ordenaci´on organizan una colecci
´on de datos de acuerdo con algu´n criterio de ordenaci´on. Los algoritmos de ordenaci´on
que se ver´an en este cap´ıtulo son los m ´a s f´aciles de programar, pero sin embargo son los m
´a s ineficientes.

7.1. Bu´squeda Lineal (Secuencial)

La bu´squeda lineal es adecuada como mecanismo de bu´squeda general en colecciones de
datos sin organizaci´on conocida. Consiste en ir recorriendo secuencialmente la colecci´on de
datos hasta encontrar el elemento buscado, o en u´ltima instancia recorrer toda la colecci´on
completa, en cuyo caso el elemento buscado no habr´a sido encontrado. En los siguientes
ejemplos se presentan los algoritmos b´asicos, los cuales pueden ser adaptados segu´n las
circunstancias.
//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
// busca la posici´on del primer elemento == x
// si no encontrado, retorna v.size()
//-------------
unsigned buscar(int x, const Vector& v)
{
unsigned i = 0;
while ((i < v.size())&&(x != v[i])) {
++i;
}
return i;
}
//----------------------------
// busca la posici´on del primer elemento >= x
//-------------
unsigned buscar_mayig(int x, const Vector& v)
{
unsigned i = 0;
while ((i < v.size())&&(x > v[i])) {
++i;
}
return i;
}
//----------------------------

77
 1 CAP´ITULO 7. BU´ SQUEDA Y ORDENACIO
´N
// busca la posici´on del primer elemento > x
//-------------
unsigned buscar_may(int x, const Vector& v)
{
unsigned i = 0;
while ((i < v.size())&&(x >= v[i])) {
++i;
}
return i;
}
//--------------------------------

7.2. Bu´squeda Binaria

La bu´squeda binaria es adecuada como mecanismo de bu´squeda cuando las colecciones de
datos se encuentran ordenadas por algu´ n criterio. Consiste en comprobar si el elemento buscado
es igual, menor o mayor que el elemento que ocupa la posici´on central de la colecci´on de
datos, en caso de ser mayor o menor que dicho elemento, se descartan los elementos no adecuados
de la colecci´on de datos, y se repite el proceso hasta encontrar el elemento o hasta que no queden
elementos adecuados en la colecci´on, en cuyo caso el elemento no habr´a sido encontrado. En
los siguientes ejemplos se presentan los algoritmos b´asicos, los cuales pueden ser adaptados
segu´n las circunstancias.
//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
// busca la posici´on del primer elemento == x
// si no encontrado, retorna v.size()
//-------------
unsigned buscar_bin(int x, const Vector& v)
{
unsigned i = 0;
unsigned f = v.size();
unsigned res = v.size();
while (i < f) {
unsigned m = (i + f ) / 2;
if (x == v[m]) {
res = i = f = m;
} else if (x < v[m]) {
f = m;
} else {
i = m + 1;
}
}
return res;
}
//----------------------------
// busca la posici´on del primer elemento >= x
//-------------
unsigned buscar_bin_mayig(int x, const Vector& v)
{
unsigned i = 0;
unsigned f = v.size();
while (i < f ) {
unsigned m = (i + f ) / 2;
if (x <= v[m]) {
f = m;
} else {
i = m + 1;
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 7.3. ORDENACIO´ N POR INTERCAMBIO (BURBUJA) 79

}
}
return i;
}
//----------------------------
// busca la posici´on del primer elemento > x
//-------------
unsigned buscar_bin_may(int x, const Vector& v)
{
unsigned i = 0;
unsigned f = v.size();
while (i < f ) {
unsigned m = (i + f ) / 2;
if (x < v[m]) {
f = m;
} else {
i = m + 1;
}
}
return i;
}
//--------------------------------

7.3. Ordenaci´on por Intercambio (Burbuja)

Se hacen mu´ltiples recorridos sobre la zona no ordenada del array, ordenando los
elementos consecutivos, trasladando en cada uno de ellos al elemento m ´a s pequen˜o hasta el
inicio de dicha zona.

//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
inline void intercambio(int& x, int& y)
{
int a = x;
x = y;
y = a;
}
//--------------------------------
void subir_menor(Vector& v, unsigned pos)
{
for (unsigned i = v.size()-1; i > pos; --i) {
if (v[i] < v[i-1]) {
intercambio(v[i], v[i-1]);
}
}
}
//--------------------------------
void burbuja(Vector& v)
{
for (unsigned pos = 0; pos < v.size()-1; ++pos)
{ subir_menor(v, pos);
}
}
//--------------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 7. BU´ SQUEDA Y ORDENACIO
´N
7.4. Ordenaci´on por Seleccio´n
Se busca el elemento m ´a s pequen˜o de la zona no ordenada del array, y se traslada al
inicio dicha zona, repitiendo el proceso hasta ordenar completamente el array.
//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
inline void intercambio(int& x, int& y)
{
int a = x;
x = y;
y = a;
}
//--------------------------------
unsigned posicion_menor(const Vector& v, unsigned pos)
{
unsigned pos_menor = pos;
for (unsigned i = pos_menor+1; i < v.size(); ++i) {
if (v[i] < v[pos_menor]) {
pos_menor = i;
}
}
return pos_menor;
}
//--------------------------------
inline void subir_menor(Vector& v, unsigned pos)
{
unsigned pos_menor = posicion_menor(v, pos);
if (pos != pos_menor) {
intercambio(v[pos], v[pos_menor]);
}
}
//--------------------------------
void seleccion(Vector& v)
{
for (unsigned pos = 0; pos < v.size()-1; ++pos)
{ subir_menor(v, pos);
}
}
//--------------------------------

7.5. Ordenaci´on por Inserci´on

Se toma el primer elemento de la zona no ordenada del array, y se inserta en la posici´on
adecuada de la zona ordenada del array, repitiendo el proceso hasta ordenar completamente el
array.
//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
unsigned buscar_posicion(const Vector& v, unsigned posicion)
{
unsigned i = 0;
while (/*(i < posicion)&&*/ (v[posicion] > v[i])) {
++i;
}
return i;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 7.6. ORDENACIO´ N POR INSERCIO´ N BINARIA 81

//--------------------------------
void abrir_hueco(Vector& v, unsigned p_hueco, unsigned p_elm)
{
for (unsigned i = p_elm; i > p_hueco; --i)
{ v[i] = v[i-1];
}
}
//--------------------------------
void insercion(Vector& v)
{
for (unsigned pos = 1; pos < v.size(); ++pos)
{ unsigned p_hueco = buscar_posicion(v,
pos); if (p_hueco != pos) {
int aux = v[pos];
abrir_hueco(v, p_hueco, pos);
v[p_hueco] = aux;
}
}
}
//--------------------------------

7.6. Ordenaci´on por Inserci´on Binaria

Es igual que el algoritmo de ordenaci´on por inserci´on, pero la posici´on del elemento a
insertar se realiza mediante una bu´squeda binaria.
//--------------------------------
typedef array<int, MAXIMO> Vector;
//--------------------------------
unsigned buscar_posicion_bin(const Vector& v, unsigned nelms,
int x)
{
unsigned izq = 0;
unsigned der = nelms;
while (izq < der) {
unsigned med = (izq + der) / 2;
if (x < v[med]) {
der = med;
} else {
izq = med + 1;
}
}
return izq;
}
//--------------------------------
void abrir_hueco(Vector& v, unsigned p_hueco, unsigned p_elm)
{
for (unsigned i = p_elm; i > p_hueco; --i)
{ v[i] = v[i-1];
}
}
//--------------------------------
void insercion_bin(Vector& v)
{
for (unsigned pos = 1; pos < v.size(); ++pos) {
unsigned p_hueco = buscar_posicion_bin(v, pos, v[pos]);
if (p_hueco != pos) {
int aux = v[pos];
abrir_hueco(v, p_hueco, pos);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 7.7. APLICACIO´ N DE LOS ALGORITMOS DE BU´ SQUEDA Y 1
ORDENACIO´ N
v[p_hueco] = aux;
}
}
}
//--------------------------------

7.7. Aplicaci´on de los Algoritmos de Bu´squeda y Ordenaci´on

Disen˜ e un programa para gestionar una agenda personal ordenada que contenga la
siguiente informaci´on: Nombre, Tel´efono, Direcci´on, Calle, Nu´mero, Piso, C´odigo Postal
y Ciudad, y las siguientes operaciones:
An˜adir los datos de una persona.
Acceder a los datos de una persona a partir de su nombre.
Borrar una persona a partir de su nombre.
Modificar los datos de una persona a partir de su nombre.
Listar el contenido completo de la agenda.

#include <iostream>
#include <string>
#include <cassert>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
// -- Constantes -------
const unsigned MAX_PERSONAS = 50;
// Tipos
struct Direccion {
unsigned num;
string calle;
string piso;
string cp;
string ciudad;
};
struct Persona {
string nombre;
string tel;
Direccion direccion;
};
// Tipos
typedef array<Persona, MAX_PERSONAS> Personas;
struct Agenda {
unsigned n_pers;
Personas pers;
};
enum Cod_Error {
OK, AG_LLENA, NO_ENCONTRADO, YA_EXISTE
};
// -- Subalgoritmos ----
void Inicializar (Agenda& ag)
{
ag.n_pers = 0;
}
//---------------------------
void Leer_Direccion (Direccion& dir)
{
cin >> dir.calle;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 7. BU´ SQUEDA Y ORDENACIO
´N
cin >> dir.num;
cin >> dir.piso;
cin >> dir.cp;
cin >> dir.ciudad;
}
//---------------------------
void Escribir_Direccion (const Direccion& dir)
{
cout << dir.calle << " ";
cout << dir.num << " ";
cout << dir.piso << " ";
cout << dir.cp << " ";
cout << dir.ciudad << " ";
}
//---------------------------
void Leer_Persona (Persona& per)
{
cin >> per.nombre;
cin >> per.tel;
Leer_Direccion(per.direccion);
}
//---------------------------
void Escribir_Persona (const Persona& per)
{
cout << per.nombre << " ";
cout << per.tel << " ";
Escribir_Direccion(per.direccion);
cout << endl;
}
//---------------------------
// Busca una Persona en la Agenda Ordenada
// Devuelve su posici´on si se encuentra, o bien >= ag.n_pers en otro caso
unsigned Buscar_Persona (const string& nombre, const Agenda& ag)
{
unsigned i = 0;
unsigned f = ag.n_pers;
unsigned res = ag.n_pers;
while (i < f) {
unsigned m = (i + f) / 2;
int cmp = nombre.compare(ag.pers[m].nombre);
if (cmp == 0) {
res = i = f = m;
} else if (cmp < 0) {
f = m;
} else {
i = m + 1;
}
}
return res;
}
//---------------------------
unsigned Buscar_Posicion (const string& nombre, const Agenda& ag)
{
unsigned i = 0;
while ((i < ag.n_pers) && (nombre > ag.pers[i].nombre)) {
++i;
}
return i;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

7.7. APLICACIO´ N DE LOS ALGORITMOS DE BU´ SQUEDA Y 3
ORDENACIO´ N
//---------------------------
void Anyadir_Ord (Agenda& ag, unsigned pos, const Persona& per)
{
for (unsigned i = ag.n_pers; i > pos; --i)
{ ag.pers[i] = ag.pers[i - 1];
}
ag.pers[pos] = per;
++ag.n_pers;
}
//---------------------------
void Eliminar_Ord (Agenda& ag, unsigned pos)
{
--ag.n_pers;
for (unsigned i = pos; i < ag.n_pers; ++i)
{ ag.pers[i] = ag.pers[i + 1];
}
}
//---------------------------
void Anyadir_Persona (const Persona& per, Agenda& ag, Cod_Error& ok)
{
unsigned pos = Buscar_Posicion(per.nombre, ag);
if ((pos < ag.n_pers) && (per.nombre == ag.pers[pos].nombre))
{ ok = YA_EXISTE;
} else if (ag.n_pers >= ag.pers.size()) {
ok = AG_LLENA;
} else {
ok = OK;
Anyadir_Ord(ag, pos, per);
}
}
//---------------------------
void Borrar_Persona (const string& nombre, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Eliminar_Ord(ag, i);
}
}
//---------------------------
void Modificar_Persona (const string& nombre, const Persona& nuevo, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Eliminar_Ord(ag, i);
Anyadir_Persona(nuevo, ag, ok);
}
}
//---------------------------
void Imprimir_Persona (const string& nombre, const Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 7. BU´ SQUEDA Y ORDENACIO
´N
} else {
ok = OK;
Escribir_Persona(ag.pers[i]);
}
}
//---------------------------
void Imprimir_Agenda (const Agenda& ag, Cod_Error& ok)
{
for (unsigned i = 0; i < ag.n_pers; ++i) {
Escribir_Persona(ag.pers[i]);
}
ok = OK;
}
//---------------------------
char Menu ()
{
char opcion;
cout << endl;
cout << "a. - A~nadir Persona" << endl;
cout << "b. - Buscar Persona" << endl;
cout << "c. - Borrar Persona" << endl;
cout << "d. - Modificar Persona" << endl;
cout << "e. - Imprimir Agenda" << endl;
cout << "x. - Salir" << endl;
do {
cout << "Introduzca Opci´on: ";
cin >> opcion;
} while ( ! (((opcion >= ’a’) && (opcion <= ’e’)) || (opcion == ’x’)));
return opcion;
}
//---------------------------
void Escribir_Cod_Error (Cod_Error cod)
{
switch (cod)
{ case OK:
cout << "Operaci´on correcta" << endl;
break;
case AG_LLENA:
cout << "Agenda llena" << endl;
break;
case NO_ENCONTRADO:
cout << "La persona no se encuentra en la agenda" << endl;
break;
case YA_EXISTE:
cout << "La persona ya se encuentra en la agenda" << endl;
break;
}
}
// -- Principal --------
int main ()
{
Agenda ag;
char opcion;
Persona per;
string nombre;
Cod_Error ok;
Inicializar(ag);
do {
opcion = Menu();

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

7.7. APLICACIO´ N DE LOS ALGORITMOS DE BU´ SQUEDA Y 5
ORDENACIO´ N
switch (opcion) {
case ’a’:
cout << "Introduzca los datos de la Persona"<<endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;
Leer_Persona(per);
Anyadir_Persona(per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’b’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
Imprimir_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’c’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
Borrar_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’d’:
cout << "Introduzca Nombre" << endl;
cin >> nombre;
cout << "Nuevos datos de la Persona" << endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;
Leer_Persona(per);
Modificar_Persona(nombre, per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’e’:
Imprimir_Agenda(ag, ok);
Escribir_Cod_Error(ok);
break;
}
} while (opcion != ’x’ );
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 8

Otros Tipos Compuestos en C

OBS

Este cap´ıtulo muestra la utilizaci´on de otros tipos de datos compuestos usualmente

utilizados en el lenguaje de programaci´on C. Aunque se muestran aqu´ı por completitud, no se
recomienda el uso de agregados (o arrays) predefinidos ni de las cadenas de caracteres al estilo-
C en programas escritos en C++, ya que C++ tiene tipos definidos para representar estas
estructuras de datos de forma m ´a s robusta y conveniente, como se ha visto en el cap´ıtulo 6.

8.1. Agregados o Arrays Predefinidos OBS

El tipo predefinido array se utiliza para la definici´on de un nuevo tipo mediante la agregaci
´on de entidades menores del mismo tipo, es decir, se define como una colecci´on de un nu
´mero deter- minado (definido en tiempo de compilaci´on) de elementos de un mismo tipo de
datos, de tal forma que se puede acceder a cada elemento individual de la colecci´on de forma
parametrizada mediante
´ındices.
Los arrays son u´tiles en todas aquellas circunstancias en que necesitamos tener
almacenados una colecci´on de valores (un nu´mero fijo predeterminado en tiempo de
compilaci´on) a los cuales pretendemos acceder de forma parametrizada, normalmente para
aplicar un proceso iterativo.
Un tipo agregado se especifica declarando el tipo base de los elementos que lo componen y
el nu´mero de elementos (constante especificada en tiempo de compilaci´on) de que consta dicha
agre- gaci´on. As´ı, por ejemplo, podemos definir un nuevo tipo Vector como un agregado de 5
elementos, cada uno del tipo int, y definir variables y constantes de dicho tipo (n´otese que los
elementos constantes del tipo array se especifican entre llaves simples):

// -- Constantes -------
const unsigned NELMS = 5;
// Tipos
typedef int Vector[NELMS];
// -- Constantes -------
const Vector PRIMOS = { 2, 3, 5, 7, 11 }; PRIMOS: 2 3 5 7 11
// -- Principal -------- 0 1 2 3 4
int main ()
{
Vector v; v: ? ? ? ? ?
} 0 1 2 3 4

El tipo base (de los elementos) del array puede ser de tipo simple o compuesto, as´ı, por
ejemplo, podemos definir un nuevo tipo Citas como un agregado de 4 elementos, cada uno del
tipo Fecha, y definir variables y constantes de dicho tipo:

87
8.1. AGREGADOS O ARRAYS PREDEFINIDOS 1

struct Fecha
{ unsigned dia;
unsigned mes;
unsigned anyo;
};
const int N_CITAS = 4;
typedef Fecha Citas[N_CITAS];
const Citas CUMPLEANYOS = {
{ 1, 1, 2001 }, CUMPLEANYOS:
{ 2, 2, 2002 }, 1 2 3 4
{ 3, 3, 2003 }, 1 2 3 4
{ 4, 4, 2004 } 2001 2002 2003 2004
};
0 1 2 3
int main()
{
Citas cit;
}
No es posible asignar variables de tipo array predefinido. Del mismo modo, tampoco se le pueden
aplicar los operadores relacionales (==, !=, >, >=, <, <=) a entidades de tipo array predefinido.
Para acceder a un elemento concreto del agregado, especificaremos entre corchetes ([ y ]) el
´ındice de la posici´on que ocupa el mismo, teniendo en cuenta que el primer elemento ocupa
la posici´on 0 (cero) y el u´ltimo elemento ocupa la posici´on del nu´mero de elementos
menos 1. Por ejemplo cit[0] y cit[N_CITAS-1] aluden al primer y u´ltimo elemento del
agregado respectiva- mente. Un determinado elemento puede utilizarse en cualquier lugar donde
sea v´alido una variable de su mismo tipo base.
El lenguaje de programaci´on C no comprueba que los accesos a los elementos de un
agrega- do son correctos y se encuentran dentro de los l´ımites v´alidos del array predefinido,
por lo que ser´a responsabilidad del programador comprobar que as´ı sea.
struct Fecha
{ unsigned dia;
unsigned mes;
unsigned anyo;
};
const int N_CITAS = 4;
typedef Fecha Citas[N_CITAS];
int main()
{
Citas cit;
cit[0].dia = 18;
cit[0].mes = 10;
cit[0].anyo = 2001;
for (int i = 0; i < N_CITAS; ++i)
{ cit[i].dia = 1;
cit[i].mes = 1;
cit[i].anyo = 2002;
}
cit[N_CITAS] = { 1, 1, 2002 }; // ERROR. Acceso fuera de los l´ımites
// ...
}

Ejemplo 1
#include <iostream>
using namespace std;
// -- Constantes -------
const unsigned NELMS = 5;
// Tipos

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

typedef int Vector[NELMS];

// -- Subalgoritmos ----
void leer (Vector& v)
{
for (unsigned i = 0; i < NELMS; ++i) {
cin >> v[i];
}
}
int sumar (const Vector& v)
{
int suma = 0;
for (unsigned i = 0; i < NELMS; ++i) {
suma += v[i];
}
return suma;
}
// -- Principal --------
int main ()
{
Vector v1, v2;
leer(v1);
leer(v2);
if (sumar(v1) == sumar(v2)) {
cout << "Misma suma" << endl;
}
}

Ejemplo 2
Programa que lee las ventas de cada “agente” e imprime su sueldo que se calcula como una
cantidad fija (1000 C) m ´a s un incentivo que s er´a un 10 % de las ventas que ha realizado.
Dicho incentivo s´olo ser´a aplicable a aquellos agentes cuyas ventas superen los 2/3 de la media
de ventas del total de los agentes.

#include <iostream>
using namespace std;
// -- Constantes -------
const unsigned NAGENTES = 20;
const double SUELDO_FIJO = 1000.0;
const double INCENTIVO = 10.0;
const double PROMEDIO = 2.0 / 3.0;
// Tipos
typedef double Ventas[NAGENTES];
// -- Subalgoritmos ----
double calc_media (const Ventas& v)
{
double suma = 0.0;
for (unsigned i = 0; i < NAGENTES; ++i) {
suma += v[i];
}
return suma / double(NAGENTES);
}
inline double porcentaje (double p, double valor)
{
return (p * valor) / 100.0;
}
void leer_ventas (Ventas& v)
{
for (unsigned i = 0; i < NAGENTES; ++i) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.1. AGREGADOS O ARRAYS PREDEFINIDOS 3

cout << "Introduzca ventas del Agente " << i << ": ";
cin >> v[i];
}
}
void imprimir_sueldos (const Ventas& v)
{
double umbral = PROMEDIO * calc_media(ventas);
for (unsigned i = 0; i < NAGENTES; ++i) {
double sueldo = SUELDO_FIJO;
if (v[i] >= umbral) {
sueldo += porcentaje(INCENTIVO, v[i]);
}
cout << "Agente: " << i << " Sueldo: " << sueldo << endl;
}
}
// -- Principal --------
int main ()
{
Ventas ventas;
leer_ventas(ventas);
imprimir_sueldos(ventas);
}

Agregados Incompletos
Hay situaciones donde un array se define en tiempo de compilaci´on con un taman˜o mayor
que el nu´mero de elementos actuales v´alidos que contendr´a durante el Tiempo de Ejecuci
´on.
Gestionar el array con huecos durante la ejecuci´on del programa suele ser, en la mayor´ıa de los casos,
complejo e ineficiente.
Mantener los elementos actuales v´alidos consecutivos al comienzo del array suele ser m´as adecuado:
• Marcar la separacion entre los elementos actuales v´alidos de los elementos vac´ıos con algu´n
valor de adecuado suele ser, en la mayor´ıa de los casos, complejo e ineficiente.
• Definir un registro que contenga tanto el array, como el nu´mero de elementos actuales v
´alidos consecutivos que contiene suele ser m´as adecuado.

Ejemplo
#include <iostream>
using namespace std;
// -- Constantes -------
const unsigned MAX_AGENTES = 20;
const double SUELDO_FIJO = 1000.0;
const double INCENTIVO = 10.0;
const double PROMEDIO = 2.0 / 3.0;
// Tipos
typedef double Datos[MAX_AGENTES];
struct Ventas {
unsigned nelms;
Datos elm;
};
// -- Subalgoritmos ----
double calc_media (const Ventas& v)
{
double suma = 0.0;
for (unsigned i = 0; i < v.nelms; ++i) {
suma += v.elm[i];
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

return suma / double(v.nelms);

}
inline double porcentaje (double p, double valor)
{
return (p * valor) / 100.0;
}
void leer_ventas_ag (unsigned i, double& v)
{
cout << "Introduzca ventas Agente " << i << ": ";
cin >> v;
}
//
// Dos m´etodos diferentes de leer un
// vector incompleto:
//
// M´etodo-1: cuando se conoce a priori el n´umero
// de elementos que lo componen
//
void leer_ventas_2 (Ventas& v)
{
unsigned nag;
cout << "Introduzca total de agentes: ";
cin >> nag;
if (nag > MAX_AGENTES)
{ v.nelms = 0;
cout << "Error" << endl;
} else {
v.nelms = nag;
for (unsigned i = 0; i < v.nelms; ++i)
{ leer_ventas_ag(i, v.elm[i]);
}
}
}
//
// M´etodo-2: cuando NO se conoce a priori el n´umero
// de elementos que lo componen, y este
// n´umero depende de la propia lectura de
// los datos
//
void leer_ventas_1 (Ventas& v)
{
double vent_ag;
v.nelms = 0;
leer_ventas_ag(v.nelms+1, vent_ag);
while ((v.nelms < MAX_AGENTES)&&(vent_ag > 0)) {
v.elm[v.nelms] = vent_ag;
++v.nelms;
leer_ventas_ag(v.nelms+1, vent_ag);
}
}
//
void imprimir_sueldos (const Ventas& v)
{
double umbral = PROMEDIO * calc_media(ventas);
for (unsigned i = 0; i < v.nelms; ++i) {
double sueldo = SUELDO_FIJO;
if (v.elm[i] >= umbral) {
sueldo += porcentaje(INCENTIVO, v.elm[i]);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.1. AGREGADOS O ARRAYS PREDEFINIDOS 5

cout << "Agente: " << i << " Sueldo: " << sueldo << endl;
}
}
// -- Principal --------
int main ()
{
Ventas ventas;
leer_ventas(ventas);
imprimir_sueldos(ventas);
}

Agregados Multidimensionales
El tipo Base de un array puede ser tanto simple como compuesto, por lo tanto puede ser
otro array, dando lugar a arrays con mu´ltiples dimensiones . As´ı, cada elemento de un array
puede ser a su vez otro array.
Los agregados anteriormente vistos se denominan de una dimensi´on. As´ı mismo, es
posible declarar agregados de varias dimensiones. Un ejemplo de un agregado de dos
dimensiones:
#include <iostream>
using namespace std;
// -- Constantes -------
const unsigned NFILAS = 3;
const unsigned NCOLUMNAS = 5;
// Tipos
typedef unsigned Fila[NCOLUMNAS];
typedef Fila Matriz[NFILAS];
// -- Principal --------
int main ()
{ m:
Matriz m; 0 00 01 02 03 04
for (unsigned f = 0; f < NFILAS; ++f ) { 1 10 11 12 13 14
for (unsigned c = 0; c < NCOLUMNAS; ++c) { 2 20 21 22 23 24
m[f][c] = (f * 10) + c; 0 1 2 3 4
}
}
}
Donde m hace referencia a una variable de tipo Matriz, m[f] hace referencia a la fila f de la matriz
m (que es de tipo Fila), y m[f][c] hace referencia al elemento c de la fila f de la matriz m (que
es de tipo unsigned).

Ejemplo 1
Disen˜ar un programa que lea una matriz de ×
3 5 de nu´meros enteros (fila a fila), almacen
´andolos en un array bidimensional, finalmente imprima la matriz segu´ n el siguiente formato:
a a a a a b
a a a a a b
a a a a a b
c c c c c
donde a representa los elementos de la matriz le´ıda desde el teclado, b representa el resultado
de sumar todos los elementos de la fila correspondiente, y c representa el resultado de sumar todos
los elementos de la columna donde se encuentran. N´otese en el ejemplo como es posible pasar
como par´ametro una u´nica fila, y sin embargo no es posible pasar como par´ametro una u
´nica columna.
#include <iostream>
using namespace std;
// -- Constantes -------
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
6 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

const unsigned NFILAS = 3;

const unsigned NCOLUMNAS = 5;
// Tipos
typedef int Fila[NCOLUMNAS];
typedef Fila Matriz[NFILAS];
// -- Subalgoritmos ----
int sumar_fila (const Fila& fil)
{
int suma = 0;
for (unsigned c = 0; c < NCOLUMNAS; ++c) {
suma += fil[c];
}
return suma;
}
int sumar_columna (const Matriz& m, unsigned c)
{
int suma = 0;
for (unsigned f = 0; f < NFILAS; ++f ) {
suma += m[f ][c];
}
return suma;
}
void escribir_fila (const Fila& fil)
{
for (unsigned c = 0; c < NCOLUMNAS; ++c) {
cout << fil[c] << " ";
}
}
void escribir_matriz_formato (const Matriz& m)
{
for (unsigned f = 0; f < NFILAS; ++f ) {
escribir_fila(m[f ]);
cout << sumar_fila(m[f]);
cout << endl;
}
for (unsigned c = 0; c < NCOLUMNAS; ++c) {
cout << sumar_columna(m, c) << " ";
}
cout << endl;
}
void leer_matriz (Matriz& m)
{
cout << "Escribe fila a fila" << endl;
for (unsigned f = 0; f < NFILAS; ++f) {
for (unsigned c = 0; c < NFILAS; ++c)
{ cin >> m[f][c];
}
}
}
// -- Principal --------
int main ()
{
Matriz m;
leer_matriz(m);
escribir_matriz_formato(m);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.1. AGREGADOS O ARRAYS PREDEFINIDOS 7

Ejemplo 2
Disen˜e un programa que realice el producto de 2 matrices de m´aximo 10 × 10 elementos:
#include <iostream>
#include <cassert>
using namespace std;
// -- Constantes -------
const unsigned MAX = 10;
// Tipos
typedef double Fila[MAX];
typedef Fila Tabla[MAX];
struct Matriz {
unsigned n_fil;
unsigned n_col;
Tabla datos;
};
// -- Subalgoritmos ----
void leer_matriz (Matriz& m)
{
cout << "Dimensiones?: ";
cin >> m.n_fil >> m.n_col;
assert(m.n_fil <= MAX && m.n_col <= MAX);
cout << "Escribe valores fila a fila:" << endl;
for (unsigned f = 0; f < m.n_fil; ++f ) {
for (unsigned c = 0; c < m.n_col; ++c)
{ cin >> m.datos[f][c];
}
}
}
void escribir_matriz (const Matriz& m)
{
for (unsigned f = 0; f < m.n_fil; ++f) {
for (unsigned c = 0; c < m.n_col; ++c)
{ cout << m.datos[f][c] << " ";
}
cout << endl;
}
}
double suma_fila_por_col (const Matriz& x, const Matriz& y, unsigned f, unsigned c)
{
assert(x.n_col == y.n_fil); // PRE-COND
double suma = 0.0;
for (unsigned k = 0; k < x.n_col; ++k)
{ suma += x.datos[f][k] * y.datos[k][c];
}
return suma;
}
void mult_matriz (Matriz& m, const Matriz& a, const Matriz& b)
{
assert(a.n_col == b.n_fil); // PRE-COND
m.n_fil = a.n_fil;
m.n_col = b.n_col;
for (unsigned f = 0; f < m.n_fil; ++f) {
for (unsigned c = 0; c < m.n_col; ++c) { m.datos[f ]
[c] = suma_fil_por_col(a, b, f, c);
}
}
}
// -- Principal --------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

int main ()
{
Matriz a,b,c;
leer_matriz(a);
leer_matriz(b);
if (a.n_col != b.n_fil) {
cout << "No se puede multiplicar." << endl;
} else {
mult_matriz(c, a, b);
escribir_matriz(c);
}
}

Paso de Par´ametros de Arrays Predefinidos

Con respecto al paso de agregados “predefinidos”como par´ametros, tanto el paso por valor
como el paso por referencia actu´an de igual forma: por referencia, por lo que no es posible
pasarlos por valor. Por ello, los par´ametros de entrada de tipo array predefinido se realizar
´an mediante paso por referencia constante y los par´ametros de salida y de entrada/salida
de tipo array predefinido se realizar´an mediante paso por referencia. Por ejemplo:

const unsigned NELMS = 9;

typedef int Vector[NELMS];
void copiar(Vector& destino, const Vector& origen)
{
for (unsigned i = 0; i < NELMS; ++i)
{ destino[i] = origen[i];
}
}
int main()
{
Vector v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Vector v2;
copiar(v2, v1);
}

Hay que tener en cuenta que si se utiliza la sintaxis del paso por valor, se pasar´an realmente
por referencia, pero de este modo ser´a m ´a s propenso a errores, ya que en este caso no se
comprueban que los par´ametros sean del mismo tipo, siendo posible pasar un array de un
taman˜o diferente al especificado, con los errores que ello conlleva. Por ejemplo:

const unsigned NELMS_1 = 9;

const unsigned NELMS_2 = 5;
typedef int Vector_1[NELMS_1];
typedef int Vector_2[NELMS_2];
void copiar(Vector_1 destino, const Vector_1 origen)
{
for (unsigned i = 0; i < NELMS_1; ++i)
{ destino[i] = origen[i];
}
}
int main()
{
Vector_1 v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Vector_2 v2;
copiar(v2, v1); // Error al pasar una variable de tipo Vector_2
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.1. AGREGADOS O ARRAYS PREDEFINIDOS 9

Paso de Par´ametros de Arrays Predefinidos de Taman˜ o Variable

Hay situaciones en las cuales es conveniente que un subprograma trabaje con agregados de
un taman˜o que dependa de la invocaci´on del mismo. Para ello se declara el par´ametro
mediante el tipo base, el identificador del par´ametro y el indicativo ([]) de que es un agregado
sin taman˜o especificado (depender´a de la invocaci´on al subprograma).
S´olo es posible pasar agregados de una dimensi´on sin especificar su taman˜o. Adem´as,
la in- formaci´on sobre el taman˜o del agregado se pierde al pasarlo como agregado abierto,
por lo que normalmente dicho taman˜o se deber´a tambi´en pasar como par´ametro.
Adem´as, el paso se realiza siempre por referencia sin necesidad de especificar el s´ımbolo
&, y para asegurar que no sea modificado en caso de informaci´on de entrada, se realizar´a el
paso de par´ametros constante. Ejemplo:
#include <iostream>
using namespace std;
const unsigned MAX = 20;
const unsigned NDATOS = 10;
typedef int Numeros[MAX];
typedef int Datos[NDATOS];
void imprimir(unsigned n, const int vct[])
{
for (unsigned i = 0; i < n; ++i)
{ cout << vct[i] << " " ;
}
cout << endl;
}
void asignar_valores(unsigned n, int vct[])
{
for (unsigned i = 0; i < n; ++i) {
vct[i] = i;
}
}
int main()
{
Numeros nm;
Datos dt;
asignar_valores(MAX, nm);
imprimir(MAX, nm);
asignar_valores(NDATOS, dt);
imprimir(NDATOS, dt);
}

Nota: S´o lo es v´alido declarar agregados abiertos como par´ametros. No es posible declarar
variables como agregados abiertos.

Comparaci´on de Arrays Predefinidos Respecto al Tipo Array de la Bib-

lioteca Est´andar
El tratamiento de los arrays predefinidos en el lenguaje C no es consistente con el
tratamiento de los otros tipos de datos, y presenta adem´as algunas anomal´ıas. Por ejemplo:
No es posible la asignacion directa de variables de tipo array predefinido, sin embargo, si el array
predefinido se encuentra dentro de un registro, el registro si se puede asignar.
No existe el constructor de copia para el tipo array predefinido, a diferencia de todos los otros tipos.
Este hecho tiene ademas consecuencias cuando se define el constructor de copia para class.
El tipo array predefinido no puede ser el tipo de retorno de una funci´on.
Si se aplican los operadores relacionales (==, !=, >, >=, <, <=) a variables de tipo array
predefinido, el comportamiento y los resultados producidos no son los esperados.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

El paso de par´ametros de arrays predefinidos sin el s´ımbolo ampersand (&) es propenso a errores
no detectables en tiempo de compilaci´on.
En caso de paso de par´ametros de arrays predefinidos sin el s´ımbolo ampersand (&), dentro del
sub- programa se pueden utilizar los operadores de asignaci´on (=) y relacionales, pero su
comportamiento y los resultados producidos no son los esperados.
Los arrays predefinidos tienen una conversi´on autom´atica al tipo puntero, que es indeseable
en muchos casos.
#include <iostream>
using namespace std;
const unsigned NELMS_1 = 9;
const unsigned NELMS_2 = 5;
typedef int Vector_1[NELMS_1];
typedef int Vector_2[NELMS_2];
void escribir(const Vector_1 v)
{
for (unsigned i = 0; i < NELMS_1; ++i) {
cout << v[i] << " ";
}
cout << endl;
}
void copiar(Vector_1 destino, Vector_1 origen)
{
destino = origen; // Error: comportamiento inesperado
}
bool es_menor(const Vector_1 v1, const Vector_1 v2)
{
return v1 < v2; // Error: comportamiento inesperado
}
int main()
{
Vector_2 v2;
Vector_1 vx;
Vector_1 v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//-----
// vx = v1; // Error de Compilaci´on
// v2 = v1; // Error de Compilaci´on
if (v1 < vx) {
cout << "v1 < vx" << endl;
}
if (v1 < v2) {
cout << "v1 < v2" << endl;
}
//-----
copiar(vx, v1);
copiar(v2, v1); // Error al pasar una variable de tipo Vector_2
//-----
if (es_menor(v1, vx)) {
cout << "v1 es menor que vx" << endl;
}
if (es_menor(v1, v2)) {
cout << "v1 es menor que v2" << endl;
}
//-----
escribir(v1);
escribir(vx);
escribir(v2); // Error al pasar una variable de tipo Vector_2
}
Cuya ejecuci´on produce el siguiente resultado:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 8.1. AGREGADOS O ARRAYS PREDEFINIDOS 11

v1 < vx
v1 < v2
v1 es menor que vx
v1 es menor que v2
1 2 3 4 5 6 7 8 9
134519591 1 65535 3221154088 134524397 3076926329 134530372 3221154104 134519004
3077695113 134530372 3221154136 134524297 3078529616 3221154144 3221154232 3075855445 134524272

Por otra parte, el tratamiento del tipo array de la biblioteca est´andar es consistente con los
otros tipos de datos. Es posible la asignaci´on (=) de variables de dicho tipo, y los operadores
relacionales tienen el comportamiento esperado, as´ı como es posible su devoluci´on desde una
funci´on, y el paso de par´ametros, tanto por valor como por referencia y referencia constante,
es seguro y mantiene su sem´antica previamente establecida. Adem´as, es posible acceder al nu
´mero de elementos que lo componen mediante el operador size(), 1 as´ı como tambi´en es
posible acceder a un determinado elemento con comprobaci´on de rango (at(i)).

8.2. Cadenas de Caracteres al Estilo-C OBS

Las cadenas de caracteres al estilo-C se definen como un array predefinido de caracteres (tipo
char) de un determinado taman˜o especificado en tiempo de compilaci´on, donde la cadena de
caracteres en s´ı e st ´a formada por los caracteres comprendidos entre el principio del array y
un car´acter especial que marca el final de la cadena. Este car´acter es el ’\0’. Esto sucede
tanto con cadenas de caracteres constantes como con las variables. Por ejemplo:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
int main() nombre: P e p e \0 ? ? ? ? ?
{ 0 1 2 3 4 5 6 7 8 9
Cadena nombre = "Pepe"; apellidos: ? ? ? ? ? ? ? ? ? ?
Cadena apellidos; 0 1 2 3 4 5 6 7 8 9
}
No es posible asignar variables de tipo array predefinido, salvo en la inicializaci´on con una ca-
dena literal constante entre comillas dobles. Del mismo modo, tampoco se le pueden aplicar
los operadores relacionales (==, !=, >, >=, <, <=) a entidades de tipo array predefinido.
Para acceder a un car´acter concreto de la cadena de caracteres, especificaremos entre corchetes
([ y ]) el ´ındice de la posici´on que ocupa el mismo, teniendo en cuenta que el primer
elemento ocupa la posici´on 0 (cero) y el u´ltimo elemento ocupa la posici´on del nu´mero de
elementos menos 1. Por ejemplo nombre[0] y nombre[MAX_CADENA-1] aluden al primer y u´ltimo
elemento del agregado respectivamente. Un determinado elemento puede utilizarse en cualquier
lugar donde sea v´alido una variable de su mismo tipo base.
Hay que tener en cuenta que la secuencia de caracteres se almacena en el array predefinido desde
la primera posici´on, y consecutivamente hasta el car´acter terminador (’\0’). Por lo tanto,
siempre se debe reservar espacio en toda cadena de caracteres para contener este car´acter
terminador adem´as de los caracteres que componen la secuencia.
El lenguaje de programaci´on C no comprueba que los accesos a los elementos de un
agrega- do son correctos y se encuentran dentro de los l´ımites v´alidos del array predefinido,
por lo que ser´a responsabilidad del programador comprobar que as´ı sea.
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
1
La utilizaci´on del operador size() en vez de la constante disminuye el acoplamiento en el programa respecto a
un valor constante global, y hace que el programa sea m´as robusto.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.2. CADENAS DE CARACTERES AL ESTILO-C 1

int main()
{
Cadena nombre = "Pepe";
for (unsigned i = 0; nombre[i] != ’\0’; ++i)
{ cout << nombre[i];
}
cout << endl;
}

Paso de Par´ametros de Cadenas de Caracteres al Estilo-C

Las cadenas de caracteres al estilo-C se definen como arrays predefinidos de tipo base char,
por lo que le son aplicables todo lo mencionado en dicha secci´on. Sin embargo, las cadenas de
caracteres al estilo-C tienen algunas peculiaridades que hace que sea m ´a s adecuado pasarlas
para par´ametros como arrays abiertos, ya que puede haber diversos arrays con distintos
taman˜os que representen cadenas de caracteres, siendo su procesamiento equivalente, e
independiente de dicho taman˜o. As´ı mismo, las cadenas de caracteres literales constantes
tienen el taman˜o dependiente del nu´mero de caracteres que la componen. Es importante que
en el caso del paso de cadenas de caracteres como arrays abiertos, en caso de que la cadena sea
modificable, es conveniente pasar tambi´en el taman˜o m´aximo que la cadena puede
alcanzar, para evitar acceder m ´a s al l´a de sus l´ımites. Sin embargo, si el par´ametro es un
array abierto constante entonces no es necesario pasar el taman˜o del array, ya que el final de la
cadena viene marcado por el car´acter terminador.
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
void escribir(const char cad[])
{
for (unsigned i = 0; cad[i] != ’\0’; ++i)
{ cout << cad[i] ;
}
}
unsigned longitud(const char cad[])
{
unsigned i = 0;
while (cad[i] != ’\0’) {
++i;
}
return i;
}
void copiar(char destino[], const char origen[], unsigned sz)
{
unsigned i;
for (i = 0; (i < sz-1)&&(origen[i] != ’\0’); ++i)
{ destino[i] = origen[i];
}
destino[i] = ’\0’;
}
int main()
{
Cadena c1 = "Pepe";
Cadena c2;
unsigned l = longitud(c1);
copiar(c2, c1, MAX_CADENA);
escribir(c2);
copiar(c2, "Luis", MAX_CADENA);
escribir(c2);
}
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

Nota: tambi´en es posible realizar el paso de par´ametros de cadenas de caracteres como char*
y const char* con la misma sem´antica que la especificada anteriormente, sin embargo la
sintaxis con los corchetes ([]) representa mejor el significado de este paso de par´ametros en
estas circun- stancias, por lo que se desaconseja la siguiente sintaxis para el paso de cadenas
de caracteres como par´ametros:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
void escribir(const char* cad)
{
for (unsigned i = 0; cad[i] != ’\0’; ++i)
{ cout << cad[i] ;
}
}
unsigned longitud(const char* cad)
{
unsigned i = 0;
while (cad[i] != ’\0’) {
++i;
}
return i;
}
void copiar(char* destino, const char* origen, unsigned sz)
{
unsigned i;
for (i = 0; (i < sz-1)&&(origen[i] != ’\0’); ++i)
{ destino[i] = origen[i];
}
destino[i] = ’\0’;
}
int main()
{
Cadena c1 = "Pepe";
Cadena c2;
unsigned l = longitud(c1);
copiar(c2, c1, MAX_CADENA);
escribir(c2);
copiar(c2, "Luis", MAX_CADENA);
escribir(c2);
}

Entrada y Salida de Cadenas de Caracteres

El operador << aplicado a un flujo de salida (cout para el flujo de salida est´andar,
usualmente el terminal) permite mostrar el contenido de las cadenas de caracteres, tanto
constantes como variables. Por ejemplo:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
const Cadena AUTOR = "Jos´e Luis";
int main()
{
Cadena nombre = "Pepe";
cout << "Nombre: " << nombre << " " << AUTOR << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 8.2. CADENAS DE CARACTERES AL ESTILO-C 3

El operador >> aplicado a un flujo de entrada (cin para el flujo de entrada est´andar,
usualmente el teclado) permite leer secuencias de caracteres y almacenarlas en variables del tipo
cadena de caracteres. Sin embargo, para evitar sobrepasar el l´ımite del array predefinido
durante la lectura, es conveniente utilizar el manipulador setw. Por ejemplo:
#include <iostream>
#include <iomanip>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
int main()
{
cout << "Introduzca el nombre: ";
Cadena nombre;
cin >> setw(MAX_CADENA) >> nombre;
cout << "Nombre: "<< nombre << endl;
}

Este operador de entrada (>>) se comporta (como se especific´o en el cap´ıtulo 3.2 dedicado a la
Entrada y Salida b´asica) de la siguiente forma: elimina los espacios en blanco que hubiera al
principio de la entrada de datos, y lee dicha entrada hasta que lea tantos caracteres como se
especifica en setw, o hasta que encuentre algu´n car´acter de espacio en blanco, que no ser´a le´ıdo
y permanecer´a en el buffer de entrada (v´ease 3.3) hasta la pr´oxima operaci´on de entrada. En
caso de que durante la entrada surja alguna situaci´on de error, dicha entrada se detiene y el
flujo de entrada se pondr´a en un estado err´oneo. Se consideran espacios en blanco los siguientes
caracteres: espacio en blanco, tabuladores, retorno de carro y nueva l´ınea (’ ’, ’\t’, ’\v’, ’\f’, ’\
r’, ’\n’). Tambi´en es posible leer una l´ınea completa, hasta leer el fin de l´ınea, desde el flujo
de entrada,
sin eliminar los espacios iniciales:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
int main()
{
cout << "Introduzca el nombre: ";
Cadena nombre;
cin.getline(nombre, MAX_CADENA);
cout << "Nombre: " << nombre << endl;
}

Tambi´en es posible leer una l´ınea completa, hasta leer un delimitador especificado, desde
el flujo de entrada, sin eliminar los espacios iniciales:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
const char DELIMITADOR = ’.’; int
main()
{
cout << "Introduzca el nombre: ";
Cadena nombre;
cin.getline(nombre, MAX_CADENA, DELIMITADOR);
cout << "Nombre: " << nombre << endl;
}

N´otese que realizar una operaci´on getline despu´es de una operaci´on con >> puede tener
compli- caciones, ya que >> dejara los espacios en blanco (y fin de l´ınea) en el buffer, que ser´an
le´ıdos por getline. Por ejemplo:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
int main()
{
cout << "Introduzca n´umero: ";
int n;
cin >> n;
cout << "Introduzca el nombre: ";
Cadena nombre;
cin.getline(nombre, MAX_CADENA);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

Para evitar este problema, el siguiente subprograma leer´a una cadena que sea distinta de la vac´ıa:
#include <iostream>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
inline void leer_linea_no_vacia(istream& ent, char linea[], unsigned sz)
{
ent >> ws; // salta los espacios en blanco y fin de l´ınea
ent.getline(linea, sz); // leer´a la primera l´ınea no vac´ıa
}
int main()
{
cout << "Introduzca n´umero: ";
int n;
cin >> n;
cout << "Introduzca el nombre (NO puede ser vac´ıo): ";
Cadena nombre;
leer_linea_no_vacia(cin, nombre, MAX_CADENA);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

Por el contrario, en caso de que la cadena vac´ıa sea una entrada v´alida, ser´a necesario
eliminar el resto de caracteres (incluyendo los espacios en blanco y fin de l´ınea) del buffer de
entrada, despu´es de leer un dato con >>, de tal forma que el buffer est´e limpio antes de realizar
la entrada de la cadena de caracteres con getline. Por ejemplo, el subprograma leer_int elimina
los caracteres del buffer despu´es de leer un dato de tipo int:
#include <iostream>
#include <limits>
using namespace std;
const int MAX_CADENA = 10;
typedef char Cadena[MAX_CADENA];
inline void leer_int(istream& ent, int& dato)
{
ent >> dato; // lee el dato
ent.ignore(numeric_limits<streamsize>::max(), ’\n’); // elimina los caracteres del buffer
// ent.ignore(10000, ’\n’); // otra posibilidad de eliminar los caracteres del buffer
}
int main()
{
cout << "Introduzca n´umero: ";
int n;
leer_int(cin, n);
cout << "Introduzca el nombre (puede ser vac´ıo): ";

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.2. CADENAS DE CARACTERES AL ESTILO-C 5

Cadena nombre;
cin.getline(nombre, MAX_CADENA);
cout << "N´umero: " << n << " Nombre: " << nombre << endl;
}

T´engase en cuenta que para utilizar numeric_limits<...>, es necesario incluir la biblioteca est
´andar <limits>.

Operaciones con Cadenas de Caracteres al Estilo-C

La biblioteca cstring proporciona una serie de subprogramas adecuados para el tratamiento
m ´a s comu´ n de las cadenas de caracteres al estilo-C. Para utilizarla se debe incluir dicha
biblioteca, as´ı como utilizar el espacio de nombres std.
#include <cstring>
using namespace std;

unsigned strlen(const char s1[]);

// devuelve la longitud de la cadena s1

char* strcpy(char dest[], const char orig[]);

char* strncpy(char dest[], const char orig[], unsigned n);
// Copia la cadena orig a dest (incluyendo el terminador ’\0’).
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// (si alcanza el l´ımite, no incluye el terminador ’\0’)

char* strcat(char dest[], const char orig[]);

char* strncat(char dest[], const char orig[], unsigned n);
// Concatena la cadena orig a la cadena dest.
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// (si alcanza el l´ımite, no incluye el terminador ’\0’)

int strcmp(const char s1[], const char s2[]);

int strncmp(const char s1[], const char s2[], unsigned n);
// Compara lexicogr´aficamente las cadenas s1 y s2.
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// devuelve <0 si s1<s2, ==0 si s1==s2, >0 si s1>s2

const char* strchr(const char s1[], char ch);

// devuelve un puntero a la primera ocurrencia de ch en s1
// NULL si no se encuentra
const char* strrchr(const char s1[], char ch);
// devuelve un puntero a la ´ultima ocurrencia de ch en s1
// NULL si no se encuentra

unsigned strspn(const char s1[], const char s2[]);

// devuelve la longitud del prefijo de s1 de caracteres
// que se encuentran en s2
unsigned strcspn(const char s1[], const char s2[]);
// devuelve la longitud del prefijo de s1 de caracteres
// que NO se encuentran en s2

const char* strpbrk(const char s1[], const char s2[]);

// devuelve un puntero a la primera ocurrencia en s1
// de cualquier car´acter de s2. NULL si no se encuentra

const char* strstr(const char s1[], const char s2[]);

// devuelve un puntero a la primera ocurrencia en s1
// de la cadena s2. NULL si no se encuentra

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 6 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

Comparaci´on del Tipo String y de Cadenas de Caracteres al Estilo-C

El tratamiento de las cadenas de caracteres al estilo-C no es consistente con el tratamiento de
los otros tipos de datos, y presenta adem´as algunas anomal´ıas, algunas debidas a la utilizaci
´on de arrays predefinidos como soporte para su implementaci´on. Por ejemplo:
No es posible la asignacion directa de variables, sin embargo, si la cadena se encuentra dentro
de un registro, el registro si se puede asignar. As´ı mismo, tambi´en es posible asignar una
cadena de caracteres constante literal (entre comillas dobles).
El tipo array predefinido no puede ser el tipo de retorno de una funci´on, se debe retornar un
puntero a caracter.
Si se aplican los operadores relacionales (==, !=, >, >=, <, <=) a cadenas de caracteres, el
compor- tamiento y los resultados producidos no son los esperados.
El paso de par´ametros debe realizarse mediante arrays abiertos. En este caso, dentro del subprograma
se pueden utilizar los operadores de asignaci´on (=) y relacionales, pero su comportamiento y
los resultados producidos no son los esperados. As´ı mismo, en numerosas ocasiones se debe tambi
´en pasar como par´ametro el taman˜o del array, para evitar desbordamientos.
Las cadenas de caracteres tienen una conversi´on autom´atica al tipo puntero a car´acter, que
es indeseable en muchos casos.
Las cadenas de caracteres tambi´en presentan otros problemas adicionales con respecto al tipo
string de la biblioteca est´andar. Por ejemplo:
Es necesario especificar a priori un taman˜o l´ımite para la cadena de caracteres, siendo
necesario definir mu´ltiples tipos con diferentes taman˜os para representar conceptos diferentes.
Al definir los taman˜os, hay que considerar el caracter terminador (’\0’).
El procesamiento de las cadenas de caracteres es m´as complicado, ya que requiere un
procesamiento secuencial hasta encontrar el terminador.
El procesamiento de las cadenas de caracteres es propenso a errores de desbordamiento, especialmente
al an˜adir caracteres y concatenar cadenas.
La entrada de datos simple (cin >> cadena;) es susceptible a errores de desbordamiento. Es
nece- sario especificar el l´ımite de la lectura (cin >> setw(MAX) >> cadena;).
Por otra parte, el tratamiento del tipo string de la biblioteca est´andar es consistente con
los otros tipos de datos. No requiere la especificaci´on a priori de un l´ımite en tiempo de
compilaci´on, es posible la asignaci´on (=) de variables de dicho tipo, y los operadores
relacionales tienen el comportamiento esperado, as´ı como es posible su devoluci´on desde una
funci´on, y el paso de par´ametros, tanto por valor como por referencia y referencia constante,
es seguro y mantiene su sem´antica previamente establecida. Adem´as, es posible acceder al
nu´mero de elementos que lo componen mediante el operador size(), as´ı como tambi´en es
posible acceder a un determinado elemento con comprobaci´on de rango (at(i)). Es robusto
ante errores de desbordamiento y posee un amplio conjunto de operaciones u´tiles predefinidas.

8.3. Uniones
Otra construcci´on u´ til, aunque no muy utilizada, son las uniones, y sirven para
compactar varias entidades de diferentes tipos en la misma zona de memoria. Es decir, todos las
entidades definidas dentro de una uni´on compartir´an la misma zona de memoria, y por lo tanto
su utilizaci´on ser ´a excluyente. Se utilizan dentro de las estructuras:
#include <iostream>
using namespace std;

enum Tipo {
COCHE,
MOTOCICLETA,
BICICLETA

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 8.4. CAMPOS DE BITS 105

};
struct Vehiculo
{ Tipo vh;
union {
double capacidad;// para el caso de tipo COCHE
int cilindrada; // para el caso de tipo MOTOCICLETA
int talla; // para el caso de tipo BICICLETA
};
};
int main()
{
Vehiculo xx;
Vehiculo yy;

xx.vh = COCHE;
xx.capacidad = 1340.25;
yy.vh = MOTOCICLETA;
yy.cilindrada = 600;
}

obviamente, los tipos de los campos de la uni´on pueden ser tanto simples como compuestos.
Es responsabilidad del programador utilizar los campos adecuados en funci´on del tipo que se
est´e al- macenando.

8.4. Campos de Bits

Permiten empaquetar secuencias de bits dentro de un determinado tipo, y acceder a ellas
mediante su identificador.
struct PPN {
unsigned PFN : 22; // 22 bits sin signo
unsigned : 3; // 3 bits sin signo [unused]
unsigned CCA : 3; // 3 bits sin signo
bool dirty : 1; // 1 bit booleano
};

8.5. Resoluci´on de Problemas Utilizando Tipos Compuestos

Disen˜ e un programa para gestionar una agenda personal que contenga la siguiente
informa- ci´on: Nombre, Tel´efono, Direcci´on, Calle, Nu´mero, Piso, C´odigo Postal y Ciudad,
y las siguientes operaciones:
An˜adir los datos de una persona.
Acceder a los datos de una persona a partir de su nombre.
Borrar una persona a partir de su nombre.
Modificar los datos de una persona a partir de su nombre.
Listar el contenido completo de la agenda.

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cassert>
using namespace std;
// -- Constantes -------
const unsigned MAX_CADENA = 60;
const unsigned MAX_PERSONAS = 50;
// Tipos

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 1
COMPUESTOS
typedef char Cadena[MAX_CADENA];
struct Direccion {
unsigned num;
Cadena calle;
Cadena piso;
Cadena cp;
Cadena ciudad;
};
struct Persona {
Cadena nombre;
Cadena tel;
Direccion direccion;
};
// Tipos
typedef Persona Personas[MAX_PERSONAS];
struct Agenda {
unsigned n_pers;
Personas pers;
};
enum Cod_Error {
OK, AG_LLENA, NO_ENCONTRADO, YA_EXISTE
};
// -- Subalgoritmos ----
void Inicializar (Agenda& ag)
{
ag.n_pers = 0;
}
//---------------------------
void Leer_Direccion (Direccion& dir)
{
cin >> setw(MAX_CADENA) >> dir.calle;
cin >> dir.num;
cin >> setw(MAX_CADENA) >> dir.piso;
cin >> setw(MAX_CADENA) >> dir.cp;
cin >> setw(MAX_CADENA) >> dir.ciudad;
}
//---------------------------
void Escribir_Direccion (const Direccion& dir)
{
cout << dir.calle << " ";
cout << dir.num << " ";
cout << dir.piso << " ";
cout << dir.cp << " ";
cout << dir.ciudad << " ";
}
//---------------------------
void Leer_Persona (Persona& per)
{
cin >> setw(MAX_CADENA) >> per.nombre;
cin >> setw(MAX_CADENA) >> per.tel;
Leer_Direccion(per.direccion);
}
//---------------------------
void Escribir_Persona (const Persona& per)
{
cout << per.nombre << " ";
cout << per.tel << " ";
Escribir_Direccion(per.direccion);
cout << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

}
//---------------------------
// Busca una Persona en la Agenda
// Devuelve su posici´on si se encuentra, o bien >= ag.n_pers en otro caso
unsigned Buscar_Persona (const char nombre[], const Agenda& ag)
{
unsigned i = 0;
while ((i < ag.n_pers) && (strcmp(nombre, ag.pers[i].nombre) != 0)) {
++i;
}
return i;
}
//---------------------------
void Anyadir (Agenda& ag, const Persona& per)
{
assert(ag.n_pers < MAX_PERSONAS);
ag.pers[ag.n_pers] = per;
++ag.n_pers;
}
//---------------------------
void Eliminar (Agenda& ag, unsigned pos)
{
assert(pos < ag.n_pers);
if (pos < ag.npers-1) {
ag.pers[pos] = ag.pers[ag.n_pers - 1];
}
--ag.n_pers;
}
//---------------------------
void Anyadir_Persona (const Persona& per, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(per.nombre, ag);
if (i < ag.n_pers) {
ok = YA_EXISTE;
} else if (ag.n_pers == MAX_PERSONAS) {
ok = AG_LLENA;
} else {
ok = OK;
Anyadir(ag, per);
}
}
//---------------------------
void Borrar_Persona (const char nombre[], Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Eliminar(ag, i);
}
}
//---------------------------
void Modificar_Persona (const char nombre[], const Persona& nuevo, Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 3
COMPUESTOS
Eliminar(ag, i);
Anyadir_Persona(nuevo, ag, ok);
}
}
//---------------------------
void Imprimir_Persona (const char nombre[], const Agenda& ag, Cod_Error& ok)
{
unsigned i = Buscar_Persona(nombre, ag);
if (i >= ag.n_pers) {
ok = NO_ENCONTRADO;
} else {
ok = OK;
Escribir_Persona(ag.pers[i]);
}
}
//---------------------------
void Imprimir_Agenda (const Agenda& ag, Cod_Error& ok)
{
for (unsigned i = 0; i < ag.n_pers; ++i) {
Escribir_Persona(ag.pers[i]);
}
ok = OK;
}
//---------------------------
char Menu ()
{
char opcion;
cout << endl;
cout << "a. - A~nadir Persona" << endl;
cout << "b. - Buscar Persona" << endl;
cout << "c. - Borrar Persona" << endl;
cout << "d. - Modificar Persona" << endl;
cout << "e. - Imprimir Agenda" << endl;
cout << "x. - Salir" << endl;
do {
cout << "Introduzca Opci´on: ";
cin >> opcion;
} while ( ! (((opcion >= ’a’) && (opcion <= ’e’)) || (opcion == ’x’)));
return opcion;
}
//---------------------------
void Escribir_Cod_Error (Cod_Error cod)
{
switch (cod)
{ case OK:
cout << "Operaci´on correcta" << endl;
break;
case AG_LLENA:
cout << "Agenda llena" << endl;
break;
case NO_ENCONTRADO:
cout << "La persona no se encuentra en la agenda" << endl;
break;
case YA_EXISTE:
cout << "La persona ya se encuentra en la agenda" << endl;
break;
}
}
// -- Principal --------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 8. OTROS TIPOS COMPUESTOS EN C

int main ()
{
Agenda ag;
char opcion;
Persona per;
Cadena nombre;
Cod_Error ok;
Inicializar(ag);
do {
opcion = Menu();
switch (opcion)
{ case ’a’:
cout << "Introduzca los datos de la Persona" << endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;
Leer_Persona(per);
Anyadir_Persona(per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’b’:
cout << "Introduzca Nombre" << endl;
cin >> setw(MAX_CADENA) >> nombre;
Imprimir_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’c’:
cout << "Introduzca Nombre" << endl;
cin >> setw(MAX_CADENA) >> nombre;
Borrar_Persona(nombre, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’d’:
cout << "Introduzca Nombre" << endl;
cin >> setw(MAX_CADENA) >> nombre;
cout << "Nuevos datos de la Persona" << endl;
cout << "(nombre, tel, calle, num, piso, cod_postal, ciudad)" << endl;
Leer_Persona(per);
Modificar_Persona(nombre, per, ag, ok);
Escribir_Cod_Error(ok);
break;
case ’e’:
Imprimir_Agenda(ag, ok);
Escribir_Cod_Error(ok);
break;
}
} while (opcion != ’x’ );
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8.5. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO TIPOS 5
COMPUESTOS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo
9
Algunas Bibliotecas U´ tiles

En este cap´ıtulo se muestra superficialmente algunas funciones b´asicas de la biblioteca est´andar.

cmath
La biblioteca <cmath> proporciona principalmente algunas funciones matem´aticas u´tiles:

#include <cmath>
using namespace std;

double sin(double r); seno, sin r (en radianes)

double cos(double r); coseno, cos r (en radianes)
double tan(double r); tangente, tan r (en radianes)
double asin(double x); arco seno, arcsin x, x ∈ [−1, 1]
double acos(double x); arco coseno, arc cos x, x ∈ [−1, 1]
double atan(double x); arco tangente, arctan x
double atan2(double y, double x); arco tangente, arctan y/x
double sinh(double r); seno hiperb´olico, sinh r
double cosh(double r); coseno hiperb´olico, cosh r
double tanh(double r); tangente
√ hiperb´olica, tanh r
double sqrt(double x); x, x 0
double pow(double x, double y); xdouble exp(double x); edouble log(double x); logaritmo
≥
neperiano, ln x, x > 0
double log10(double x); logaritmo decimal, log x, x > 0
double ceil(double x); menor entero ≥ x, dxe
double floor(double x); mayor entero ≤ x, bxc
double fabs(double x); valor absoluto de x, |x|
double ldexp(double x, int n); x2n
double frexp(double x, int* exp); inversa de ldexp
double modf(double x, double* ip); parte entera y fraccionaria
double fmod(double x, double y); resto de x/y

cctype
La biblioteca <cctype> proporciona principalmente caracter´ısticas sobre los valores de tipo
char:

#include <cctype>
using namespace std;

1
112 CAP´ITULO 9. ALGUNAS BIBLIOTECAS U´ TILES

bool isalnum(char ch); (isalpha(ch) || isdigit(ch))

bool isalpha(char ch); (isupper(ch) || islower(ch))
bool iscntrl(char ch); caracteres de control
bool isdigit(char ch); d´ıgito decimal
bool isgraph(char ch); caracteres imprimibles excepto espacio
bool islower(char ch); letra minu´scula
bool isprint(char ch); caracteres imprimibles incluyendo espacio
bool ispunct(char ch); carac. impr. excepto espacio, letra o d
´ıgito bool isspace(char ch); espacio, ’\r’, ’\n’, ’\t’, ’\v’, ’\f ’
bool isupper(char ch); letra mayu´scula
bool isxdigit(char ch); d´ıgito hexadecimal
char tolower(char ch); retorna la letra minu´scula correspondiente a
ch char toupper(char ch); retorna la letra mayu´scula correspondiente a
ch

cstdlib
La biblioteca <cstdlib> proporciona principalmente algunas funciones generales u´tiles:
#include <cstdlib>
using namespace std;

int system(const char orden[]); orden a ejecutar por el sistema operativo

int abs(int n); retorna el valor absoluto del nu´mero int n
long labs(long n); retorna el valor absoluto del nu´mero long
n void srand(unsigned semilla); inicializa el generador de nu´meros
aleatorios
int rand(); retorna un aleatorio entre 0 y RAND_MAX (ambos inclusive)

#include <cstdlib>
#include <ctime>
using namespace std;
//
// inicializa el generador de n´umeros aleatorios
inline unsigned ini_aleatorio()
{
srand(time(0));
}
//
// Devuelve un n´umero aleatorio entre 0 y max (exclusive)
inline unsigned aleatorio(unsigned max)
{
return unsigned(max*double(rand())/(RAND_MAX+1.0));
}
//
// Devuelve un n´umero aleatorio entre min y max (ambos inclusive)
inline unsigned aleatorio(unsigned min, unsigned max)
{
return min + aleatorio(max-min+1);
}
//

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Parte II

Programacio´n Intermedia

1
Cap´ıtulo
10
Almacenamiento en Memoria
Secundaria: Ficheros

Los programas de ordenador usualmente trabajan con datos almacenados en la memoria prin-
cipal (RAM). Esta memoria principal tiene como principales caracter´ısticas que tiene un
tiempo de acceso (para lectura y escritura) muy eficiente, sin embargo este tipo de memoria es
vol´atil, en el sentido de que los datos almacenados en ella desaparecen cuando termina la
ejecuci´on del programa o se apaga el ordenador. Los ordenadores normalmente almacenan su
informaci´on de manera permanente en dispositivos de almacenamiento de memoria
secundaria, tales como dispos- itivos magn´eticos (discos duros, cintas), discos ´opticos
(CDROM, DVD), memorias permanentes de estado s´olido (memorias flash USB), etc.
Estos dispositivos suelen disponer de gran capacidad de almacenamiento, por lo que es nece-
sario alguna organizaci´on que permita gestionar y acceder a la informaci´on all´ı
almacenada. A esta organizaci´on se la denomina el sistema de ficheros, y suele estar organizado
jer´arquicamente en directorios (a veces denominados tambi´en carpetas) y ficheros (a veces
denominados tambi´en archivos), donde los directorios permiten organizar jer´arquicamente y
acceder a los ficheros, y estos u´ltimos almacenan de forma permanente la informaci´on, que
puede ser tanto programas (software) como datos que ser´an utilizados por los programas. As´ı,
los programas acceden y almacenan la informaci´on de manera permanente por medio de los
ficheros, que son gestionados por el Sistema Operativo dentro de la jerarqu´ıa del sistema de
ficheros.

Tipos de Ficheros
Los ficheros se pueden clasificar de mu´ltiples formas dependiendo de los criterios
seleccionados. En nuestro caso, nos centraremos en la clasificaci´on por la codificaci´on o
formato en el que al- macenan la informaci´on que contienen. As´ı, podemos distinguir los
ficheros de texto y los ficheros binarios. En los ficheros de texto, la informaci´on se almacena
utilizando una codificaci´on y formato adecuados para que puedan ser procesados (y le´ıdos),
adem´as de por un programa de ordenador, por un ser humano. Por lo tanto, los ficheros de
texto almacenan la informaci´on utilizando una codificaci´on textual como secuencia de
caracteres (usualmente basada en la codificaci´on ASCII, UTF-8, etc), y en un formato que
permita su legibilidad y procesamiento. Por otra parte, los ficheros binarios son procesados
autom´aticamente por la ejecuci´on de programas, sin la interven- c i´on humana, por lo que
no necesitan representar la informaci´on en un formato legible para el ser humano. Por ello,
suelen codificar la informaci´on en un formato orientado a ser procesado efi- cientemente por
los ordenadores, y en ese caso utilizan la representaci´on en el c´odigo binario que utilizan
internamente los ordenadores para representar los datos. En este caso, pueden surgir prob- lemas de
compatibilidad en aquellos casos en los que estos ficheros son procesados por programas ejecut
´andose en ordenadores que utilizan distintas representaciones internas de los datos.
As´ı por ejemplo, un fichero de texto denominado fechas.txt podr´ıa estar almacenado en
1
2 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

una determinada posici´on en la jerarqu´ıa del sistema de ficheros

(/home/alumno/documentos/fechas.txt)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 y contener informaci´on sobre las fechas de nacimiento de determinadas personas segu´ n el siguiente
formato, donde cada l´ınea se encuentra terminada por un car´acter terminador de fin de l´ınea:y
x

Juan L´opez 12 3 1992

Cap´ıtulo Lola Mart´ınez 23 7 1987

Pepe Jim´enez 17 8 1996

10
T´engase en cuenta que el ordenador almacena los nu´meros internamente en formato binario,
y que ´estos han sido convertidos a su representaci´on textual como secuencia de caracteres
cuando fueron escritos al fichero de texto, y que la conversi´on inversa se produce cuando se
leen desde el fichero de texto para su procesamiento. Por ejemplo, el nu´mero 1992 se almacena
en una vari- able de tipo unsigned y se representa internamente como el siguiente nu´mero
binario de 32 bits (00000000000000000000011111001000), sin embargo, su representaci´on textual en el
fichero de texto se compone de la siguiente secuencia de cuatro caracteres: ’1’ ’9’ ’9’ ’2’.
El contenido de un fichero de texto, adem´as de ser procesado por un programa espec´ıfico,
disen˜ado para su procesamiento considerando su formato, tambi´en puede ser visualizado y
editado mediante un programa de edici´on de textos de prop´osito general, tales como gedit,
kate, gvim, emacs, etc. en Linux, textedit en MacOS-X y notepad en Windows, entre otros.
En el caso del software, los programas en c´odigo fuente codificados en un lenguaje de
progra- maci´on suelen ser almacenados como ficheros de texto. Sin embargo, el resultado de
compilar estos programas fuente a programas ejecutables se almacenan en ficheros binarios
(ejecutables por el Sistema Operativo). As´ı mismo, los ficheros que contienen im´agenes, v´ıdeo y
mu´sica suelen estar, en su mayor´ıa, almacenados en formato binario.

10.1. Flujos de Entrada y Salida Asociados a Ficheros

En el cap´ıtulo 3 se explic´o que un programa codificado en C++ realiza la entrada y salida
de informaci´on (con el entorno exterior del programa) a trav´es de los flujos (stream en ingl´es)
de entrada y salida respectivamente.
En dicho cap´ıtulo se muestra como se realiza la entrada y salida de datos a trav´es de los
flujos est´andares de entrada y salida respectivamente (cin y cout), usualmente conectados con
el teclado y la pantalla de la consola. Todo lo explicado anteriormente respecto a la entrada y
salida b´asica con los flujos est´andares (cap 3), flujos de entrada y salida como par´ametros
(cap 5.10) entrada y salida de cadenas de caracteres (cap 6.2 y cap 8.2) es tambi´en aplicable a
los flujos de entrada y salida vinculados a ficheros que veremos en este cap´ıtulo.
Un flujo de entrada de datos en modo texto actu´ a como una fuente que proporciona una
secuencia de caracteres (usualmente a trav´es de un buffer de almacenamiento intermedio) desde
el que se extraen los caracteres que representan a los datos de entrada, que posteriormente ser
´an convertidos a la representaci´on interna adecuada.

Juan L´opez 12 3 1992 ←- Lola Mart´ınez 23 7 1987

←- Pepe
←- Jim´enez 17 8 1996

Por el contrario, un flujo de salida de datos en modo texto actu´ a como un sumidero que
recibe una secuencia de caracteres (usualmente a trav´es de un buffer de almacenamiento
intermedio) a la que se env´ıan los caracteres que representan a los datos de salida, que
previamente han sido convertidos al formato de texto adecuado.
En el caso de entrada y salida a ficheros, el lenguaje de programaci´on C++ posee
mecanismos para asociar y vincular estos flujos con ficheros almacenados en memoria secundaria
en la jerarqu´ıa del sistema de ficheros. As´ı, toda la entrada y salida de informaci´on se realiza a
trav´es de estos flujos vinculados a ficheros, denominados manejadores de ficheros. De este modo,
cuando un programa quiere realizar una entrada o salida de datos con un determinado fichero, debe
realizar las siguientes acciones:
1
El car´acter terminador de fin de l´ınea no es visible, aunque se aprecian sus efectos al mostrarse los
3
4 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS
siguientes caracteres en la siguiente l´ınea.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 10.2. ENTRADA DE DATOS DESDE FICHEROS DE TEXTO 117

1. Incluir la biblioteca <fstream> donde se definen los tipos correspondientes, y utilizar el espacio
de nombres std.
2. Declarar variables del tipo de flujo adecuado (para entrada, salida, o ambos) para que actu´en como
manejadores de fichero.
3. Abrir el flujo de datos vinculando la variable correspondiente con el fichero especificado. Esta
op- eraci´on establece un v´ınculo entre la variable (manejador de fichero) definida en nuestro
programa con el fichero gestionado por el sistema operativo, de tal forma que toda transferencia de
informa- ci´on que el programa realice con el fichero, se realizar´a a trav´es de la variable manejador
de fichero vinculada con el mismo.
4. Comprobar que la apertura del fichero del paso previo se realiz´o correctamente. Si la vinculaci´on
con el fichero especificado no pudo realizarse por algu´ n motivo (por ejemplo, el fichero no
existe, en el caso de entrada de datos, o no es posible crear el fichero, en el caso de salida de datos),
entonces la operaci´on de apertura fallar´ıa (v´ease 3.5).
5. Realizar la transferencia de informaci´on (de entrada o de salida) con el fichero a trav´es de la
variable de flujo vinculada al fichero. Para esta transferencia de informaci´on (entrada y salida)
se pueden utilizar los mecanismos vistos en los cap´ıtulos anteriores (3, 5.10, 6.2, 8.2). En el caso
de salida de datos, ´estos deber´an escribirse siguiendo un formato adecuado que permita su
posterior lectura, por ejemplo escribiendo los separadores adecuados para ello entre los diferentes
valores almacenados.
Normalmente, tanto la entrada como la salida de datos implican un proceso iterativo, que en el caso
de entrada se suele realizar hasta leer y procesar todo el contenido del fichero.
6. Comprobar que el procesamiento del fichero del paso previo se realiz´o correctamente, de tal
forma que si el procesamiento consist´ıa en entrada de datos, el estado de la variable vinculada
al fichero se encuentre en un estado indicando que se ha alcanzado el final del fichero, y si el
procesamiento era de salida, el estado de la variable vinculada al fichero se deber´a encontrar en un
estado correcto (v´ease 3.5).
7. Finalmente cerrar el flujo liberando la variable de su vinculaci´on con el fichero. Si no se cierra
el flujo de fichero, cuando termine el a´mbito de vida de la variable vinculada, el flujo ser´a
cerrado automaticamente, y su vinculaci´on liberada.

Cuando sea necesario, una variable de tipo flujo, tanto de entrada, salida o ambos, puede ser
pasada como par´ametro por referencia (no constante) a cualquier subprograma.
Nota: si se va a abrir un fichero utilizando la misma variable que ya ha sido previamente
utilizada para procesar otro fichero (pero posteriormente desvinculada tras cerrar el flujo), se
deber´a uti- lizar el m´etodo clear() para limpiar los flags de estado (v´ease 3.5). Aunque esta
pr´actica de utilizar la misma variable para procesar distintos ficheros est ´a totalmente
desaconsejada, siendo una t´ecnica mejor definir y vincular variables diferentes, en distintos
subprogramas que representen adecuadamente la abstracci´on del programa.

10.2. Entrada de Datos desde Ficheros de Texto

Para realizar la entrada de datos desde un fichero de texto, el programa debe:
1. Incluir la biblioteca <fstream> donde se definen los tipos correspondientes, y utilizar el espacio
de nombres std.
#include <fstream>
using namespace std;
2. Definir una variable manejador de fichero del tipo de flujo de entrada (ifstream –input file stream).
ifstream f_ent;
3. Abrir el flujo vinculando la variable correspondiente con el fichero especificado.
f_ent.open(nombre_fichero.c_str());
4. Comprobar que la apertura del fichero se realiz´o correctamente.
if (f_ent.fail()) {..........}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

5. Realizar la entrada de datos con los operadores y subprogramas correspondientes, as´ı como
procesar la informacion le´ıda.
f_ent >> nombre >> apellidos >> dia >> mes >> anyo;
f_ent.ignore(1000, ’\n’);
f_ent >> ws;
getline(f_ent, linea);
f_ent.get(c);
Usualmente es un proceso iterativo que se realiza hasta que la operaci´on de entrada de datos falla,
usualmente debido a haber alcanzado el final del fichero. Este proceso iterativo usualmente consiste
en la iteracion del siguiente proceso:

Lectura de datos
Si la lectura no ha sido correcta, entonces terminar el proceso iterativo.
En otro caso, procesamiento de los datos le´ıdos, y vuelta al proceso iterativo, leyendo
nuevos datos

{
...
f_ent >> datos;
while (! f_ent.fail() ... )
{ procesar(datos, ...);
f_ent >> datos;
}
}

6. Comprobar que el procesamiento del fichero se realiz´o correctamente, es decir, el fichero se ley´o com-
pletamente hasta el final de mismo (eof representa end-of-file).
if (f_ent.eof()) { ... }
7. Finalmente cerrar el flujo liberando la variable de su vinculaci´on.
f_ent.close();

Por ejemplo, un programa que lee nu´meros desde un fichero de texto y los procesa (en este caso
simplemente los muestra por pantalla):
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
enum Codigo {
OK, ERROR_APERTURA, ERROR_FORMATO
};
void procesar(int num)
{
cout << num << endl;
}
void leer_fich(const string& nombre_fichero, Codigo& ok)
{
ifstream f_ent;
f_ent.open(nombre_fichero.c_str());
if (f_ent.fail()) {
ok = ERROR_APERTURA;
} else {
int numero;
f_ent >> numero;
while (! f_ent.fail()) {
procesar(numero);
f_ent >> numero;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 10.3. SALIDA DE DATOS A FICHEROS DE TEXTO 119

}
if (f_ent.eof()) {
ok = OK;
} else {
ok = ERROR_FORMATO;
}
f_ent.close();
}
}
void codigo_error(Codigo ok)
{
switch (ok)
{ case OK:
cout << "Fichero procesado correctamente" << endl;
break;
case ERROR_APERTURA:
cout << "Error en la apertura del fichero" << endl;
break;
case ERROR_FORMATO:
cout << "Error de formato en la lectura del fichero" << endl;
break;
}
}
int main()
{
Codigo ok;
string nombre_fichero;
cout << "Introduzca el nombre del fichero: ";
cin >> nombre_fichero;
leer_fich(nombre_fichero, ok);
codigo_error(ok);
}

10.3. Salida de Datos a Ficheros de Texto

Para realizar la salida de datos a un fichero de texto, el programa debe:
1. Incluir la biblioteca <fstream> donde se definen los tipos correspondientes, y utilizar el espacio
de nombres std.
#include <fstream>
using namespace std;
2. Definir una variable manejador de fichero del tipo de flujo de salida (ofstream –output file stream).
ofstream f_sal;
3. Abrir el flujo vinculando la variable correspondiente con el fichero especificado.
f_sal.open(nombre_fichero.c_str());
4. Comprobar que la apertura del fichero se realiz´o correctamente.
if (f_sal.fail()) { ... }
5. Realizar la salida de datos con los operadores y subprogramas correspondientes, teniendo en cuenta
los separadores que se deben escribir para que puedan ser le´ıdos adecuadamente.
f_sal << nombre << " " << apellidos << " " << dia << " " << mes << " " << anyo << endl;
Usualmente ´este es un proceso iterativo que se realiza hasta que se escriben en el fichero todos los
datos apropiados y mientras el estado del flujo sea correcto.
while ( ... f_sal.good() ) { ... }

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10.4. EJEMPLOS 1

6. Comprobar que el procesamiento del fichero se realiz´o correctamente, es decir, el fichero se encuentra
en buen estado.
if (f_sal.good()) { ... }

7. Finalmente cerrar el flujo liberando la variable de su vinculaci´on.

f_sal.close();

Por ejemplo, un programa que lee nu´meros de teclado (hasta introducir un cero) y los
escribe a un fichero de texto:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
enum Codigo {
OK, ERROR_APERTURA, ERROR_FORMATO
};
void escribir_fich(const string& nombre_fichero, Codigo& ok)
{
ofstream f_sal;
f_sal.open(nombre_fichero.c_str());
if (f_sal.fail()) {
ok = ERROR_APERTURA;
} else {
int numero;
cin >> numero
while ((numero > 0) && ! cin.fail() && f_sal.good())
{ f_sal << numero << endl;
cin >> numero
}
if (f_sal.good()) {
ok = OK;
} else {
ok = ERROR_FORMATO;
}
f_sal.close();
}
}
void codigo_error(Codigo ok)
{
switch (ok)
{ case OK:
cout << "Fichero guardado correctamente" << endl;
break;
case ERROR_APERTURA:
cout << "Error en la apertura del fichero" << endl;
break;
case ERROR_FORMATO:
cout << "Error de formato al escribir al fichero" << endl;
break;
}
}
int main()
{
Codigo ok;
string nombre_fichero;
cout << "Introduzca el nombre del fichero: ";
cin >> nombre_fichero;
escribir_fich(nombre_fichero, ok);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 2 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

codigo_error(ok);
}

10.4. Ejemplos
Ejemplo 1
Ejemplo de un programa que copia el contenido de un fichero a otro, car´acter a car´acter:
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
enum Codigo {
OK, ERROR_APERTURA_ENT, ERROR_APERTURA_SAL, ERROR_FORMATO
};
void copiar_fichero(const string& salida, const string& entrada, Codigo& ok)
{
ifstream f_ent;
f_ent.open(entrada.c_str());
if (f_ent.fail()) {
ok = ERROR_APERTURA_ENT;
} else {
ofstream f_sal;
f_sal.open(salida.c_str());
if (f_sal.fail()) {
ok = ERROR_APERTURA_SAL;
} else {
char ch;
f_ent.get(ch);
while (! f_ent.fail() && f_sal.good()) {
f_sal.put(ch);
f_ent.get(ch);
}
if (f_ent.eof() && f_sal.good()) {
ok = OK;
} else {
ok = ERROR_FORMATO;
}
f_sal.close(); // no es necesario
}
f_ent.close(); // no es necesario
}
}
void codigo_error(Codigo ok)
{
switch (ok)
{ case OK:
cout << "Fichero procesado correctamente" << endl;
break;
case ERROR_APERTURA_ENT:
cout << "Error en la apertura del fichero de entrada" << endl;
break;
case ERROR_APERTURA_SAL:
cout << "Error en la apertura del fichero de salida" << endl;
break;
case ERROR_FORMATO:
cout << "Error de formato en la lectura del fichero" << endl;
break;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10.4. EJEMPLOS 3

}
}
int main()
{
Codigo ok;
string entrada, salida;
cout << "Introduzca el nombre del fichero de entrada: ";
cin >> entrada;
cout << "Introduzca el nombre del fichero de salida: ";
cin >> salida;
copiar_fichero(salida, entrada, ok);
codigo_error(ok);
}

Ejemplo 2
Ejemplo de un programa que crea, guarda y carga una agenda personal.
//-------------------------------------------------------------------------
#include <iostream>
#include <fstream>
#include <string>
#include <tr1/array>
#include <cctype>
using namespace std;
using namespace std::tr1;
//-------------------------------------------------------------------------
struct Fecha
{ unsigned dia;
unsigned mes;
unsigned anyo;
};
struct Persona {
string nombre;
string tfn;
Fecha fnac;
};
const unsigned MAX = 100;
typedef array<Persona, MAX> APers;
struct Agenda {
unsigned nelms;
APers elm;
};
//-------------------------------------------------------------------------
void inic_agenda(Agenda& ag)
{
ag.nelms = 0;
}
void anyadir_persona(Agenda& ag, const Persona& p, bool& ok)
{
if (ag.nelms < ag.elm.size())
{ ag.elm[ag.nelms] = p;
++ag.nelms;
ok = true;
} else {
ok = false;
}
}
//------------------------------------------------------------------------ -
void leer_fecha(Fecha& f)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

{
cout << "Introduza fecha de nacimiento (dia mes a~no): ";
cin >> f.dia >> f.mes >> f.anyo;
}
void leer_persona(Persona& p)
{
cout << "Introduza nombre: ";
cin >> ws;
getline(cin, p.nombre);
cout << "Introduza tel´efono: ";
cin >> p.tfn;
leer_fecha(p.fnac);
}
void nueva_persona(Agenda& ag)
{
bool ok;
Persona p;
leer_persona(p);
if (! cin.fail()) {
anyadir_persona(ag, p, ok);
if (!ok) {
cout << "Error al introducir la nueva persona" << endl;
}
} else {
cout << "Error al leer los datos de la nueva persona" << endl;
cin.clear();
cin.ignore(1000, ’\n’);
}
}
//------------------------------------------------------------------------ -
void escribir_fecha(const Fecha& f)
{
cout << f.dia << ’/’ << f.mes << ’/’ << f.anyo;
}
void escribir_persona(const Persona& p)
{
cout << "Nombre: " << p.nombre << endl;
cout << "Tel´efono: " << p.tfn << endl;
cout << "Fecha nac: ";
escribir_fecha(p.fnac);
cout << endl;
}
void escribir_agenda(const Agenda& ag)
{
for (unsigned i = 0; i < ag.nelms; ++i) {
cout << "----------------------------------------" << endl;
escribir_persona(ag.elm[i]);
}
cout << "----------------------------------------" << endl;
}
//------------------------------------------------------------------------ -
// FORMATO DEL FICHERO DE ENTRADA:
//
// <nombre> <RC>
// <tel´efono> <dia> <mes> <a~no> <RC>
// <nombre> <RC>
// <tel´efono> <dia> <mes> <a~no> <RC>
// ...
//------------------------------------------------------------------------ -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10.4. EJEMPLOS 5

void leer_fecha(ifstream& fich, Fecha& f)

{
fich >> f.dia >> f.mes >> f.anyo;
}
void leer_persona(ifstream& fich, Persona& p)
{
fich >> ws;
getline(fich, p.nombre);
fich >> p.tfn;
leer_fecha(fich, p.fnac);
}
//--------------------------------------------- -
// Otra posible implementaci´on
// void leer_persona(ifstream& fich, Persona& p)
// {
// getline(fich, p.nombre);
// fich >> p.tfn;
// leer_fecha(fich, p.fnac);
// fich.ignore(1000, ’\n’);
// }
//--------------------------------------------- -
void leer_agenda(const string& nombre_fich, Agenda& ag, bool& ok)
{
ifstream fich;
Persona p;

fich.open(nombre_fich.c_str());
if (fich.fail()) {
ok = false;
} else {
ok = true;
inic_agenda(ag);
leer_persona(fich, p);
while (!fich.fail() && ok)
{ anyadir_persona(ag, p, ok);
leer_persona(fich, p);
}
ok = ok && fich.eof();
fich.close();
}
}
void cargar_agenda(Agenda& ag)
{
bool ok;
string nombre_fich;
cout << "Introduce el nombre del fichero: ";
cin >> nombre_fich;
leer_agenda(nombre_fich, ag, ok);
if (!ok) {
cout << "Error al cargar el fichero" << endl;
}
}
//------------------------------------------------------------------------ -
// FORMATO DEL FICHERO DE SALIDA:
//
// <nombre> <RC>
// <tel´efono> <dia> <mes> <a~no> <RC>
// <nombre> <RC>
// <tel´efono> <dia> <mes> <a~no> <RC>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

// ...
//-------------------------------------------------------------------------
void escribir_fecha(ofstream& fich, const Fecha& f)
{
fich << f.dia << ’ ’ << f.mes << ’ ’ << f.anyo;
}
void escribir_persona(ofstream& fich, const Persona& p)
{
fich << p.nombre << endl;
fich << p.tfn << ’ ’;
escribir_fecha(fich, p.fnac);
fich << endl;
}
void escribir_agenda(const string& nombre_fich, const Agenda& ag, bool& ok)
{
ofstream fich;

fich.open(nombre_fich.c_str());
if (fich.fail()) {
ok = false;
} else {
unsigned i = 0;
while ((i < ag.nelms) && (fich.good()))
{ escribir_persona(fich, ag.elm[i]);
++i;
}
ok = fich.good();
fich.close();
}
}
void guardar_agenda(const Agenda& ag)
{
bool ok;
string nombre_fich;
cout << "Introduce el nombre del fichero: ";
cin >> nombre_fich;
escribir_agenda(nombre_fich, ag, ok);
if (!ok) {
cout << "Error al guardar el fichero" << endl;
}
}
//------------------------------------------------------------------------ -
char menu()
{
char op;
cout << endl;
cout << "C. Cargar Agenda" << endl;
cout << "M. Mostrar Agenda" << endl;
cout << "N. Nueva Persona" << endl;
cout << "G. Guardar Agenda" << endl;
cout << "X. Fin" << endl;
do {
cout << endl << " Opci´on: ";
cin >> op;
op = char(toupper(op));
} while (!((op == ’C’)||(op == ’M’)||(op == ’N’)||(op == ’G’)||(op == ’X’)));
cout << endl;
return op;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 10.4. EJEMPLOS 7

//-------------------------------------------------------------------------
int main()
{
Agenda ag;
char op;
inic_agenda(ag);
do {
op = menu();
switch (op)
{ case ’C’:
cargar_agenda(ag);
break;
case ’M’:
escribir_agenda(ag);
break;
case ’N’:
nueva_persona(ag);
break;
case ’G’:
guardar_agenda(ag);
break;
}
} while (op != ’X’);
}
//------------------------------------------------------------------------ -

10.5. Otros Tipos de Flujos de Ficheros A

10.5.1. Ficheros Binarios A

Como se mostr´o al inicio del cap´ıtulo, los ficheros binarios permiten almacenar la informaci
´on utilizando una codificaci´on basada en la representaci´on interna de los datos en la memoria
principal por el procesador, el c´odigo binario. Cuando queremos trabajar con un fichero codificado
en formato binario, tanto para entrada como para salida de datos, al realizar la operaci´on de
apertura para vincular la variable manipulador del fichero con el fichero, se deber´a especificar
que el fichero es t ´a en modo binario mediante el s´ımbolo ios::binary en dicha operaci´on.

Salida Binaria de Datos

La salida binaria de variables de tipos simples (o variables de tipo array de tipos simples) se
realiza como se indica a continuaci´on. Para ello es necesario abrir el fichero en modo binario,
y utilizar los m´etodos adecuados:
ofstream f_sal; Definir variable flujo de salida
f_sal.open(nombre_fich.c_str(), ios::binary); Vincular el flujo con un fichero en modo binario
f_sal.write((const char*)&x, sizeof(x)); Escribe en modo binario el contenido de una vari-
able x de tipo simple, o array de tipo simple
long n = f_sal.pcount(); Retorna el nu´mero de caracteres (bytes) le
´ıdos en la u´ltima operaci´on de escritura
f_sal.flush(); Fuerza el volcado del flujo de salida al
dispositivo de almacenamiento
El formato binario de las cadenas de caracteres coincide con su representaci´on textual, por
lo que utilizaremos el mismo mecanismo que para la salida textual de cadenas de caracteres,
pero deberemos ahora incluir un delimitador al final de la cadena adecuado para el formato
binario tal como ’\0’.
f_sal << nombre << ’\0’;
La salida de variables de tipo estructurado (registros, clases y arrays de registros y clases) debe
realizarse componente a componente.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 10.5. OTROS TIPOS DE FLUJOS DE FICHEROS 1

Entrada Binaria de Datos

La entrada binaria de variables de tipos simples (o variables de tipo array de tipos simples)
se realiza como se indica a continuaci´on. Para ello es necesario abrir el fichero en modo
binario, y utilizar los m´etodos adecuados:
ifstream f_ent; Definir variable flujo de entrada
f_ent.open(nombre_fich.c_str(), ios::binary); Vincular el flujo con un fichero en modo binario
f_ent.read((char*)&x, sizeof(x)); Lee en modo binario el contenido de una variable
x de tipo simple, o array de tipo simple
long n = f_ent.gcount(); Retorna el nu´mero de caracteres (bytes) le
´ıdos en la u´ltima operaci´on de lectura

El formato binario de las cadenas de caracteres coincide con su representaci´on textual, por
lo que utilizaremos el mismo mecanismo que para la entrada textual de cadenas de caracteres,
pero considerando que el final de la cadena de caracteres est´a marcado por la inclusi´on en el
fichero de un determinado delimitador segu´ n se realiz´o el proceso de almacenamiento en el
fichero (’\0’).
getline(f_ent, nombre, ’\0’);

La entrada de variables de tipo estructurado (registros, clases y arrays de registros y clases) debe
realizarse componente a componente.

A Entrada y Salida Binaria Avanzada

La entrada y salida binaria de datos utiliza la representaci´on interna (en memoria principal)
de los datos para su almacenamiento en memoria secundaria, y esta representaci´on interna
depende de como el hardware (el procesador) representa dicha informaci´on internamente. Por
este motivo, la entrada y salida binaria de datos puede dar lugar a diversos errores de
compatibilidad cuando se realiza con ordenadores que utilizan diferentes representaciones
internas de los datos (big-endian y little-endian).
Valor num´erico Representaci´on interna
Decimal Hexadecimal Binario (bytes) byte order
987654321 0x3ade68b1 00111010:11011110:01101000:10110001 big-endian (xdr, network-byte-order )
987654321 0x3ade68b1 10110001:01101000:11011110:00111010 little-endian (Intel )

Por ello, y para evitar este tipo de problemas, en determinadas circunstancias se puede optar
por realizar la entrada y salida binaria en una determinada representaci´on independiente de la
representaci´on interna utilizada por el procesador (big-endian o little-endian). Por ejemplo,
para entrada y salida de un dato de tipo int (es v´alida para los tipos simples integrales):
#include <fstream>
#include <climits>
using namespace std;
//------------------------------------
typedef int Tipo;
//------------------------------------
void escribir_big_endian(ostream& out, Tipo x)
{
unsigned char memoria[sizeof(x)];
for (int i = sizeof(x)-1; i >= 0; --i) {
memoria[i] = (unsigned char)(x & ((1U<<CHAR_BIT)-1U));
x = Tipo(x >> CHAR_BIT);
}
out.write((const char*)memoria, sizeof(x));
}
void leer_big_endian(istream& in, Tipo& x)
{
unsigned char memoria[sizeof(x)];
in.read((char*)memoria, sizeof(x));

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

x = 0;
for (unsigned i = 0; i < sizeof(x); ++i) {
x = Tipo((x << CHAR_BIT) | unsigned(memoria[i]));
}
}
//------------------------------------
void escribir_little_endian(ostream& out, Tipo x)
{
unsigned char memoria[sizeof(x)];
for (unsigned i = 0; i < sizeof(x); ++i) {
memoria[i] = (unsigned char)(x & ((1U<<CHAR_BIT)-1U));
x = Tipo(x >> CHAR_BIT);
}
out.write((const char*)memoria, sizeof(x));
}
void leer_little_endian(istream& in, Tipo& x)
{
unsigned char memoria[sizeof(x)];
in.read((char*)memoria, sizeof(x));
x = 0;
for (int i = sizeof(x)-1; i >= 0; --i) {
x = Tipo((x << CHAR_BIT) | unsigned(memoria[i]));
}
}
//------------------------------------

Para entrada y salida de cadenas de caracteres en un formato m ´a s avanzado, se a n˜ a d i r ´a

al principio el nu´mero de caracteres de la cadena en formato binario, y se incluir´a un
delimitador al final de la cadena adecuado para el formato binario tal como ’\0’:

//------------------------------------
void escribir_big_endian(ostream& out, const string& x)
{
escribir_big_endian(out, x.size());
out << nombre << ’\0’;
}
void leer_big_endian(istream& in, string& x)
{
unsigned sz;
leer_big_endian(in, sz);
x.reserve(sz);
getline(f_ent, x, ’\0’);
assert(sz == x.size());
}
//------------------------------------
void escribir_little_endian(ostream& out, const string& x)
{
escribir_little_endian(out, x.size());
out << nombre << ’\0’;
}
void leer_little_endian(istream& in, string& x)
{
unsigned sz;
leer_little_endian(in, sz);
x.reserve(sz);
getline(f_ent, x, ’\0’);
assert(sz == x.size());
}
//------------------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10.5. OTROS TIPOS DE FLUJOS DE FICHEROS 3

As´ı, almacenar el nu´mero de caracteres permite poder alojar el espacio en memoria suficiente
para almacenar la secuencia de caracteres que vaya a ser le´ıda, aunque ´esto no es necesario si se
utiliza el tipo string de C++, no obstante es conveniente.
Nota: estos subprogramas son adecuados si la cadena de caracteres no contiene el car´acter ’\0’
como un elemento v´alido de la secuencia de caracteres.

10.5.2. Acceso Directo en Ficheros A

En muchas ocasiones el fichero sobre el que realizamos la entrada o salida de datos se encuentra
almacenado en un dispositivo de memoria secundaria con soporte para el acceso directo, tales como
discos magn´eticos, ´opticos, discos de memoria de estado s´olido, etc. Estos dispositivos
permiten acceder a determinadas posiciones del fichero directamente, sin necesidad de realizar
un acceso secuencial sobre todo el contenido del fichero (como podr´ıa suceder si el fichero se
encontrase almacenado en un dispositivo de cinta magn´etica. En estas circunstancias, el
lenguaje de progra- maci´on C++ ofrece una serie de operaciones para poder poner el ´ındice
de lectura o escritura en una determinada posici´on del fichero, de tal forma que la pr´oxima
operaci´on de lectura o de escritura se realice a partir de esa posici´on.

Acceso Directo en Flujos de Entrada

Las siguientes operaciones, cuando se aplican a un flujo de entrada de datos, permiten
acceder para conocer y modificar la posici´on donde se encuentra en ´ındice de lectura del flujo,
a partir del cual se realizar´a la pr´oxima operaci´on de lectura.
La operaci´on tellg() aplicada a un flujo de entrada permite obtener la posici´on donde se
encuentra en ´ındice de lectura:
n = cin.tellg();

La operaci´on seekg(pos) aplicada a un flujo de entrada permite poner la posici´on del ´ındice
de lectura, en una posici´on absoluta desde el inicio del fichero:
cin.seekg(pos);

La operaci´on seekg(offset, desde) aplicada a un flujo de entrada permite poner la posici´on del
´ındice de lectura, en una posici´on relativa como un desplazamiento desde una posici´on conocida
del fichero, el cual puede ser desde el inicio (ios::beg), desde el final (ios::end) o desde la posici
´on actual (ios::cur):
cin.seekg(offset, desde);

Es importante considerar que en el caso de flujos abiertos en modo de lectura y escritura

simult´anea, puede suceder que el ´ındice de lectura sea el mismo que el ´ındice de escritura,
por lo que cualquier operaci´on realizada sobre el ´ındice de lectura tambi´en afectar´a al ´ındice de
escritura, y viceversa.

Acceso Directo en Flujos de Salida

Las siguientes operaciones, cuando se aplican a un flujo de salida de datos, permiten acceder
para conocer y modificar la posici´on donde se encuentra en ´ındice de escritura del flujo, a
partir del cual se realizar´a la pr´oxima operaci´on de escritura.
La operaci´on tellp() aplicada a un flujo de salida permite obtener la posici´on donde se
en- cuentra en ´ındice de escritura:
n = cout.tellp();

La operaci´on seekp(pos) aplicada a un flujo de salida permite poner la posici´on del ´ındice
de escritura, en una posici´on absoluta desde el inicio del fichero:
cout.seekp(pos);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 4 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

La operaci´on seekp(offset, desde) aplicada a un flujo de salida permite poner la posici´on del
´ındice de lectura, en una posici´on relativa como un desplazamiento desde una posici´on conocida
del fichero, el cual puede ser desde el inicio (ios::beg), desde el final (ios::end) o desde la posici
´on actual (ios::cur):
cout.seekp(offset, desde);

Es importante considerar que en el caso de flujos abiertos en modo de lectura y escritura

simult´anea, puede suceder que el ´ındice de lectura sea el mismo que el ´ındice de escritura,
por lo que cualquier operaci´on realizada sobre el ´ındice de lectura tambi´en afectar´a al ´ındice de
escritura, y viceversa.

10.5.3. Flujos de Entrada y Salida A

Adem´as de tener flujos dedicados exclusivamente para realizar entrada de datos y salida de
datos de forma independiente, tambi´en es posible abrir un fichero para realizar sobre el mismo
tanto operaciones de entrada como operaciones de salida sobre el mismo flujo de datos.
Para trabajar con flujos de entrada y salida simult´anea, deberemos declarar las variables
manejadores de fichero del tipo fstream:
fstream fich_ent_sal;

posteriormente vincularemos la variable manejador del fichero con un determinado fichero

fich_ent_sal.open(nombre_fichero.c_str());

y podremos realizar tanto operaciones de entrada como de salida de datos sobre el mismo. Todo
lo explicado en los cap´ıtulos anteriores es aplicable a este tipo de flujos, especialmente las
operaciones de acceso directo para posicionar adecuadamente el ´ındice de lectura y el de
escritura.
Es importante considerar que en el caso de flujos abiertos en modo de lectura y escritura
simult´anea, puede suceder que el ´ındice de lectura sea el mismo que el ´ındice de escritura,
por lo que cualquier operaci´on realizada sobre el ´ındice de lectura tambi´en afectar´a al ´ındice de
escritura, y viceversa.

10.6. Flujos de Entrada y Salida Vinculados a Cadenas de

Caracteres A
Hemos visto como hay flujos vinculados con la entrada y salida est´andares, as´ı como
flujos vinculados a ficheros almacenados en memoria secundaria. El lenguaje de programaci
´on C++ tambi´en permite vincular flujos de entrada y salida con cadenas de caracteres (strings)
contenidos en memoria principal. Para ello, se deber´a incluir la biblioteca est´andar
<sstream>:
#include <sstream>

A Entrada de Datos desde Cadenas de Caracteres

Para utilizar un flujo de entrada de datos desde cadenas de caracteres, se declara una
variable de tipo istringstream sobre la que se puede realizar la entrada de datos como se
realiza de forma habitual con los flujos de entrada. El contenido del flujo desde el que se realizar´a
la entrada de datos se puede especificar durante la propia definici´on de la variable, o mediante el
operador str("..."). Por ejemplo:
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10.5. OTROS TIPOS DE FLUJOS DE FICHEROS 5
int main()

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 10.6. FLUJOS DE ENTRADA Y SALIDA VINCULADOS A CADENAS DE CARACTERES131

{
string datos = "123 456";
istringstream fent(datos);
int val;
fent >> val;
while (fent) {
cout << "Valor: " << val<<endl;
fent >> val;
}
bool ok = fent.eof();
cout << boolalpha << "Estado: " << ok << endl;
//--------------------------------
fent.clear();
fent.str(" 789 345 ");
fent >> val;
while (fent) {
cout << "Valor: " << val<<endl;
fent >> val;
}
cout << boolalpha << "Estado: " << fent.eof() << endl;
}

A Salida de Datos a Cadenas de Caracteres

Para utilizar un flujo de salida de datos a cadenas de caracteres, se declara una variable de
tipo ostringstream sobre la que se puede realizar la salida de datos como se realiza de forma
habitual con los flujos de salida. El operador str() permite obtener la cadena de caracteres
correspondiente a la salida de datos realizada. As´ı mismo, una llamada a str("") reinicializa el
flujo de salida de datos:
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

int main()
{
ostringstream fsal;
for (int i = 0; i < 10; ++i)
{ fsal << i << " ";
}
string salida = fsal.str();
cout << "Salida: " << salida << endl;
//--------------------------------
fsal.str("");
for (int i = 0; i < 10; ++i)
{ fsal << i << " ";
}
salida = fsal.str();
cout << "Salida: " << salida << endl;
}

A Entrada y Salida de Datos a Cadenas de Caracteres

Por u´ltimo, tambi´en es posible realizar entrada y salida de datos simult´aneamente

utilizando el tipo stringstream, y utilizando en operador str("...") para dar y el operador str()
para obtener valores de tipo cadena de caracteres. La entrada y salida de datos sobre el flujo se
realiza de forma habitual.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 10. ALMACENAMIENTO EN MEMORIA SECUNDARIA: FICHEROS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 11

M´odulos y Bibliotecas

Cuando se desarrollan programas de complejidad media/alta, el c´odigo fuente

normalmente no se encuentra en un u´nico fichero, sino que se encuentra distribuido entre
varios m´odulos. Una primera ventaja de la existencia de m´odulos es que permiten aumentar
la localidad y cohesi´on del c´odigo y aislarlo del exterior, es decir, poner todo el c´odigo
encargado de resolver un determinado problema en un m´odulo nos permite aislarlo del resto, con
lo que futuras modificaciones ser´an m ´a s f´aciles de realizar.
Otra ventaja adicional de los m´odulos es el hecho de que si se modifica algo interno en un
determinado m´odulo, s´olo ser´a necesario volver a compilar dicho m´odulo, y no todo el
programa completo, lo que se convierte en una ventaja indudable en caso de programas grandes
(compilaci´on separada).
Adem´as, esta divisi´on modular es una pieza fundamental para la reutilizaci´on del c´odigo,
ya que permite la utilizaci´on de bibliotecas del sistema, as´ı como la creaci´on y distribuci´on
de bibliotecas de utilidades que podr´an ser utilizadas por mu´ltiples programas. Esta
distribuci´on de bibliotecas se puede hacer en c´odigo objeto, por lo que no es necesario distribuir
el c´odigo fuente de la misma.
M1 Main M2
Programa
GUI Math MP3 JPG
Bbl. Utilidades
Mem File I/O Proc
APISckts
S.O.

Kernel S.O. S.O.

As´ı, vemos que en la figura un determinado programa se compone de varios m´odulos de

progra- ma (Main, M1 y M2) en los cuales est´a dividido la soluci´on principal del problema,
varios m´odulos de bibliotecas proporcionan utilidades gr´aficas, matem´aticas y tratamiento de
im´agenes; as´ı como varios m´odulos de biblioteca dan acceso a servicios de entrada/salida y
comunicaciones por Internet proporcionados por el sistema operativo.

11.1. Interfaz e Implementaci´on del M´odulo

En el lenguaje de programaci´on C++, normalmente un m´odulo se compone de dos
ficheros: uno donde aparece el c´odigo que resuelve un determinado problema o conjunto de
problemas (implementaci´on – parte privada), y un fichero que contiene las definiciones de
tipos, constantes y prototipos de subprogramas que el m´odulo ofrece (interfaz – parte pu
´blica). As´ı, se denomina la implementaci´on del m´odulo al fichero que contiene la parte
privada del m´odulo, y se denomina la interfaz del m´odulo al fichero que contiene la parte pu
´blica del mismo. A este fichero tambi´en se le denomina “fichero de encabezamiento” o “fichero
de cabecera” (header file en ingl´es).

133
 vector.cpp
vector.hpp main.cpp
(Implementaci´on)
(Interfaz)
(Principal)
#ifndef
#include
#includevector"vector.hpp"
"vector.hpp"
hpp
////implementaci´on
#define utilizaci´on
vector de vector
hppde int main()
vector
////{ interfaz
privadode vector
···
//· · · p´ublico
·· }·· ··
#endif
···
1 CAP´ITULO 11. MO´ DULOS Y
BIBLIOTECAS

Por lo tanto, un programa completo normalmente se compone de varios m´odulos, cada

uno con su fichero de encabezamiento (interfaz) y de implementaci´on, y de un m´odulo principal
donde reside la funci´on principal main. Para que un determinado m´odulo pueda hacer uso de
las util- idades que proporciona otro m´odulo, deber´a incluir el fichero de encabezamiento
(interfaz) del m´odulo que se vaya a utilizar, de tal forma que tenga acceso a las declaraciones pu
´blicas de ´este. As´ı mismo, el fichero de implementaci´on de un determinado m´odulo tambi´en
deber´a especificar al comienzo del mismo la inclusi´on del fichero de encabezamiento de su
propio m´odulo, con objeto de obtener y contrastar las definiciones all´ı especificadas, es decir, el
fichero de encabezamiento del propio m´odulo debe ser el primer fichero que se incluya en el
fichero de implementaci´on del mis- mo m´odulo. Normalmente los ficheros de implementaci´on
tendr´an una extensi´on “.cpp” (tambi´en suelen utilizarse otras extensiones como “.cxx” y “.cc”)
y los ficheros de encabezamiento tendr´an una extensi´on “.hpp” (tambi´en suelen utilizarse
otras extensiones como “.hxx”, “.hh” y “.h”). As´ı, para incluir el fichero de encabezamiento
(interfaz) de un m´odulo vector se utiliza la siguiente directiva:

#include "vector.hpp"

N´otese que cuando se incluyen ficheros de encabezamiento (interfaz) de la biblioteca est´andar

(o del sistema), el nombre del fichero se especifica entre <...>, pero cuando se incluyen ficheros
de encabezamiento de m´odulos y bibliotecas locales (no est´andares), entonces el nombre del
fichero se especifica entre "...". De esta forma, los ficheros de la biblioteca est´andar y del
sistema se buscan en directorios del sistema, pero los ficheros y bibliotecas locales se buscan en
el directorio local de trabajo.

Guardas en un Fichero de Encabezamiento

Las definiciones en los ficheros de encabezamiento (interfaz) ser´an especificadas entre las
guardas (directivas de compilaci´on condicional) para evitar la inclusi´on duplicada de las
definiciones all´ı con- tenidas. El nombre de la guarda usualmente se deriva del nombre del
fichero, como se indica en el siguiente ejemplo donde el m´odulo vector tendr´a los siguientes
ficheros de encabezamiento y de implementaci´on (en determinadas circunstancias, puede ser
conveniente que al nombre de la guarda se le an˜ada tambi´en el nombre del espacio de
nombres que se explicar´a en la siguiente secci´on):

Fichero: vector.hpp (Interfaz) Fichero: vector.cpp (Implementaci

´on)
// Guarda para evitar inclusi´on duplicada #include "vector.hpp"
#ifndef _vector_hpp_
#define _vector_hpp_

// Definiciones P´ublicas de: // Implementaciones Privadas de:

// * Constantes // * Constantes Privadas
// * Tipos (Enum, Registros, Clases) // * Tipos Privados
// * Prototipos de Subprogramas // * Subprogramas
// * Clases
#endif // Fin de guarda

Directrices para el Disen˜ o de Ficheros de Encabezamiento

Las siguientes directrices deben ser tenidas en cuenta con objeto de organizar adecuadamente
el disen˜o de los ficheros de encabezamiento de los m´odulos:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 11.2. COMPILACIO´ N SEPARADA Y ENLAZADO 135

Un fichero de encabezamiento s´olo deber´a contener definiciones de constantes,

definiciones de tipos y prototipos de subprogramas que exporta (parte pu´blica) el propio
m´odulo. No deber´a contener definiciones de variables globales, ni la implementaci´on de
c´odigo (de sub- programas y m´etodos). Esto u´ltimo salvo algunas excepciones, tales
como la definici´on de subprogramas “en l´ınea” (v´ease 5.6), la definici´on de clases
simples definidas “en l´ınea” (v´ease 13.1.1) y finalmente la definici´on de subprogramas y
clases gen´ericas (v´ease 14).
El mecanismo de inclusi´on de ficheros de encabezamiento debe ser robusto ante
posibles inclusiones duplicadas. Para ello siempre se utilizar´a el mecanismo de guardas
explicado anteriormente.
Un fichero de encabezamiento debe incluir todos los ficheros de encabezamiento de otros
m´odulos que necesite para su propia definici´on, de forma tal que el orden de inclusi´on
de los ficheros de encabezamiento no sea importante.
A Un cuidadoso disen˜o de los m´odulos normalmente evitar´a la inclusi´on y dependencias
circu- lares entre m´odulos, sin embargo excepcionalmente pueden surgir dichas
dependencias circu- lares, y en estas circunstancias una declaraci´on adelantada de un tipo
incompleto (v´ease 15.6) puede sustituir la inclusi´on de un fichero de encabezamiento y
evitar la dependencia circular.

11.2. Compilaci´on Separada y Enlazado

vector.hpp stack.hpp iostream string

Interfaz Interfaz + Implementación Interfaz Interfaz

Público C.Fuente C++
Público C.Fuente C++ Público C.Fuente C++Público C.Fuente C++

vector.cpp main.cpp bblstd.cpp

Implementación Programa Implementación

Privado C.Fuente C++ Principal C.Fuente C++ Privado C.Fuente C++

Compilación Compilación Compilación

vector.o main.o main

bblstd.o
Enlazado

Implementación Programa Implementación Programa

Público C.Objeto Principal C.Objeto Público C.Objeto Completo C.Ejecutable

Cuando se compila un m´odulo de forma independiente (compilaci´on separada), se

compila su fichero de implementaci´on, por ejemplo vector.cpp, y produce como resultado un
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
fichero en c´odigo objeto, por ejemplo vector.o, considerando que el c´odigo fuente en C++
compilado es el contenido del fichero de implementaci´on junto con el contenido de todos los
ficheros de encabezamiento incluidos durante el proceso de compilaci´on. Por ejemplo, mediante
el siguiente comando se compila un m´odulo de implementaci´on de c´odigo fuente en C++
utilizando el compilador GNU GCC para generar el correspondiente c´odigo objeto:
g++ -ansi -Wall -Werror -c vector.cpp g+
+ -ansi -Wall -Werror -c main.cpp

y el enlazado de los c´odigos objeto para generar el c´odigo ejecutable:

g++ -ansi -Wall -Werror -o main main.o vector.o

Aunque tambi´en es posible realizar la compilaci´on y enlazado en el mismo comando:

g++ -ansi -Wall -Werror -o main main.cpp vector.cpp

o incluso mezclar compilaci´on de c´odigo fuente y enlazado de c´odigo objeto:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 11.3. ESPACIOS DE NOMBRE 1

g++ -ansi -Wall -Werror -o main main.cpp vector.o

Hay que tener en cuenta que el compilador enlaza autom´aticamente el c´odigo generado
con las bibliotecas est´andares de C++, y por lo tanto no es necesario que ´estas se especifiquen
ex- pl´ıcitamente. Sin embargo, en caso de ser necesario, tambi´en es posible especificar el enlazado
con bibliotecas externas:

g++ -ansi -Wall -Werror -o main main.cpp vector.cpp -ljpeg

Estas bibliotecas no son m ´a s que una agregaci´on de m´odulos compilados a c´odigo objeto, y
orga- nizadas adecuadamente para que puedan ser reutilizados por muy diversos programas.
As´ı mismo, en sistemas Unix existe otro mecanismo (make y makefiles) que permite establecer
relaciones de dependencia entre diversos m´odulos, de tal forma que es capaz de discernir
cuando es necesario compilar los diferentes m´odulos dependiendo de si se produce algu´ n
cambio en los m´odulos de los que dependen (v´ease 11.4).

11.3. Espacios de Nombre

Cuando se trabaja con mu´ltiples m´odulos y bibliotecas, es posible que se produzcan
colisiones en la definici´on de entidades diferentes con los mismos identificadores proporcionadas
por diferentes m´odulos y bibliotecas. Este hecho no est´a permitido por el lenguaje de
programaci´on C++. Para evitar estas posibles colisiones existen los espacios de nombre
(namespace en ingl´es), que permiten agrupar bajo una misma denominaci´on un conjunto de
declaraciones y definiciones, de tal forma que dicha denominaci´on s er ´a necesaria para
identificar y diferenciar cada entidad declarada. Estos espacios de nombre pueden ser u´nicos
para un determinado m´odulo, o por el contrario pueden abarcar mu´ltiples m´odulos y
bibliotecas gestionados por el mismo proveedor, por ejemplo todas las entidades definidas en la
biblioteca est´andar se encuentran bajo el espacio de nombres std. As´ı, el nombre del espacio
de nombres puede ser derivado del propio nombre del fichero, puede incluir una denominaci´on
relativa al proveedor del m´odulo, o alguna otra denominaci´on m ´a s compleja que garantice que
no habr´a colisiones en el nombre del espacio de nombres.

main.cpp (Principal) vector.hpp (Interfaz) vector.cpp (Implementaci´on)

#include <iostream> #include "vector.hpp" using namespace std; using
#ifndef vectornamespace
hpp umalcc; #include "vector.hpp"
// utilizaci´on de vector int main() #define vector hpp #include <...otros...> #include <...otros...>
{ // interfaz de vector namespace umalcc { // implementaci´on de vector
··· namespace umalcc {
} ···
··· ···
··· ···
} ···
#endif }

N´otese que la inclusi´on de ficheros de encabezamiento se debe realizar externamente a la

defini- ci ´on de los espacios de nombre.

A Hay que tener en cuenta que un mismo espacio de nombres puede especificarse mu´ltiples
veces, desde diversos ficheros, para an˜adir nuevas entidades al mismo.

A Adicionalmente, tambi´en es posible definir espacios de nombre anidados, pudiendo, de

esta forma, definir jerarqu´ıas de espacios de nombre.

A As´ı mismo, tambi´en existen espacios de nombre an´onimos que permiten definir
entidades privadas internas a los m´odulos de implementaci´on, de tal forma que no puedan
producir col- isiones con las entidades pu´blicas del sistema completo. De esta forma,
cualquier declaraci´on y definici´on realizada dentro de un espacio de nombres an´onimo
ser´a u´nicamente visible en el m´odulo de implementaci´on donde se encuentre
(privada), pero no ser´a visible en el exterior del m´odulo.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 11. MO´ DULOS Y
BIBLIOTECAS
Utilizaci´on de Espacios de Nombre
Es posible utilizar las entidades (identificadores) definidas dentro de espacios de nombres de
varias formas, dependiendo de las circunstancias donde se produzca esta utilizaci´on, teniendo
en cuenta que todos los identificadores definidos dentro de un espacio de nombres determinado
son visibles y accesibles directamente dentro de ´el mismo.

En la implementaci´on de los m´odulos (ficheros de implementaci´on .cpp), mediante la

directiva using namespace se ponen disponibles (accesibles) todos los identificadores de
dicho espacio de nombres completo, que podr´an ser accedidos directamente, sin necesidad
de cualificaci´on expl´ıcita. Por ejemplo:

using namespace std;

using namespace umalcc;

Si se utilizan (mediante using namespace) varios espacios de nombre simult´aneamente

y ambos definen el mismo identificador, si dicho identificador no se utiliza entonces no se
produce colisi´on. Sin embargo en caso de que se utilice dicho identificador, entonces se
produce una colisi´on ya que el compilador no puede discernir a que entidad se refiere. En
este u´ltimo caso, el programador debe utilizar la cualificaci´on expl´ıcita (explicada a
continuaci´on) para este identificador y eliminar de esta forma la ambigu¨edad en su
utilizaci´on.
Sin embargo, no es adecuado aplicar la directiva using namespace dentro de ficheros de
encabezamiento, ya que si es utilizada en un fichero de encabezamiento que se incluye por
mu´ltiples m´odulos, entonces pondr´ıa disponible (accesible) todos los identificadores de
dicho espacio de nombres para todos los ficheros que incluyan (include) dicho fichero de
encabeza- miento, algo que podr´ıa provocar colisiones inesperadas, y esto ser´ıa un efecto
colateral no deseado para aquellos que utilizasen dicho m´odulo (incluyeran dicho fichero
de encabeza- miento). Por lo tanto, en ficheros de encabezamiento se deben utilizar los
siguientes m´etodos explicados a continuaci´on.

En los ficheros de encabezamiento (.hpp) cada identificador externo (perteneciente a otro

espacio de nombres) se debe utilizar cualificado con el espacio de nombres al que
pertenece (cualificaci´on expl´ıcita) utilizando para ello el nombre del espacio de
nombres, seguido por el operador :: y del nombre del identificador, como en el siguiente
ejemplo para utilizar el tipo array del espacio de nombres std::tr1:
namespace umalcc {
typedef std::tr1::array<int, 20> Vector;
}

Por conveniencia, existe un mecanismo intermedio entre los dos m´etodos generales
expli- cados anteriormente. El m´etodo consiste en utilizar la declaraci´on using seguido
por la cualificaci´on expl´ıcita del identificador, de tal forma que la utilizaci´on de dicho
identificador queda disponible para ser utilizada directamente sin cualificaci´on
(cualificaci´on impl´ıcita). Este mecanismo se puede utilizar en ficheros de implementaci
´on, y en el caso de ficheros de encabezamiento siempre se debe utilizar dentro de otro
espacio de nombres, para hacer pu´blico dicho identificador dentro de este nuevo espacio
de nombres. Por ejemplo:

namespace umalcc {
using std::tr1::array;
}

Finalmente, tambi´en es posible crear un alias para un espacio de nombres para facilitar la
cualificaci´on:

namespace lcc = umalcc;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
11.3. ESPACIOS DE NOMBRE 3

Ejemplo
M´odulo Vector

Ejemplo de un m´odulo vector, que implementa el concepto de array incompleto. Debido a

su simplicidad, toda la implementaci´on del m´odulo se proporciona como c´odigo en l´ınea,
por lo que no es necesario un fichero aparte que contenga la implementaci´on independiente. En
este ejemplo, se puede apreciar como se hace uso de una entidad definida en otro m´odulo
(espacio de nombres std::tr1) mediante cualificaci´on expl´ıcita:

//- fichero: vector.hpp

#ifndef _vector_hpp_
#define _vector_hpp_
#include <cassert>
#include <tr1/array>
namespace umalcc {
const unsigned MAX_ELMS = 30;
typedef std::tr1::array<int, MAX_ELMS> Datos;
struct Vector {
unsigned nelms;
Datos elm;
};
inline void inicializar(Vector& v)
{
v.nelms = 0;
}
inline bool vacio(const Vector& v)
{ return (v.nelms == 0);
}
inline bool lleno(const Vector& v) {
return (v.nelms >= v.elm.size());
}
inline unsigned nelms(const Vector& v)
{
return v.nelms;
}
inline void anyadir_elm(Vector& v, int e)
{
assert(! lleno(v)); // Pre-condici´on
v.elm[v.nelms] = e;
++v.nelms;
}
inline void eliminar_ultimo(Vector& v)
{
assert(! vacio(v)); // Pre-condici´on
--v.nelms;
}
inline int obtener_elm(const Vector& v, unsigned i)
{
assert(i < size(v)); // Pre-condici´on
return v.elm[i];
}
inline void asignar_elm(Vector& v, unsigned i, int e)
assert(i < size(v)); // Pre-condici´on
v.elm[i] = e;
}
}
#endif
//- fin: vector.hpp

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 11. MO´ DULOS Y
BIBLIOTECAS
Una posible utilizaci´on del m´odulo vector definido anteriormente podr´ıa ser:
//- fichero: main.cpp
#include "vector.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;
void anyadir(Vector& v)
{
for (int x = 0; x < 10; ++x) {
if (! lleno(v)) {
anyadir_elm(v, x);
}
}
}
void imprimir(const Vector& v)
{
for (unsigned i = 0; i < nelms(v); ++i)
{ cout << obtener_elm(v, i) << " ";
}
cout << endl;
}
void eliminar(Vector& v, unsigned i)
{
if (i < nelms(v)) {
asignar_elm(v, i, obtener_elm(v, nelms(v)-1));
eliminar_ultimo(v);
}
}
int main()
{
Vector v;
inicializar(v);
anyadir(v);
imprimir(v);
eliminar(v, 3);
}
//- fin: main.cpp

Su compilaci´on y enlazado en GNU GCC :

g++ -ansi -Wall -Werror -o main main.cpp

M´odulo Nu´meros Complejos

Otro ejemplo de m´odulo para operaciones con nu´meros complejos, donde el fichero de encabeza-
miento podr´ıa ser:
//- fichero: complejos.hpp
#ifndef _complejos_hpp_
#define _complejos_hpp_
/*
* Declaraciones p´ublicas del m´odulo
*/
namespace umalcc
{ struct Complejo
{
double real;
double imag;
};
void crear(Complejo& num, double real, double imag);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

11.3. ESPACIOS DE NOMBRE 5

void sumar(Complejo& res, const Complejo& x, const Complejo& y);

void mult(Complejo& res, const Complejo& x, const Complejo& y);
void escribir(const Complejo& c);
}
#endif
//- fin: complejos.hpp

La implementaci´on del m´odulo se realiza en un fichero independiente, donde adem´as se puede

apreciar la utilizaci´on de un espacio de nombres an´onimo:
//- fichero: complejos.cpp
#include "complejos.hpp"
#include <iostream>
#include <cmath>
using namespace std;
using namespace umalcc;
/*
* Implementaci´on privada del m´odulo (namespace an´onimo)
*/
namespace {
struct Polar
{ double rho;
double theta;
};
inline double sq(double x)
{
return x*x;
}
void cartesiana_a_polar(Polar& pol, const Complejo& cmp)
{
pol.rho = sqrt(sq(cmp.real) + sq(cmp.imag));
pol.theta = atan2(cmp.imag, cmp.real);
}
void polar_a_cartesiana(Complejo& cmp, const Polar& pol)
{
cmp.real = pol.rho * cos(pol.theta);
cmp.imag = pol.rho * sin(pol.theta);
}
}
/*
* Implementaci´on correspondiente a la parte p´ublica del m´odulo
*/
namespace umalcc {
void crear(Complejo& num, double real, double imag)
{
num.real = real;
num.imag = imag;
}
void sumar(Complejo& res, const Complejo& x, const Complejo& y)
{
res.real = x.real + y.real;
res.imag = x.imag + y.imag;
}
void mult(Complejo& res, const Complejo& x, const Complejo& y)
{
Polar pr, p1, p2;
cartesiana_a_polar(p1, x);
cartesiana_a_polar(p2, y);
pr.rho = p1.rho * p2.rho;
pr.theta = p1.theta + p2.theta;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

11.4. HERRAMIENTAS DE AYUDA A LA GESTIO´ N DE LA COMPILACIO´ N
SEPARADA1
polar_a_cartesiana(res, pr);
}
void escribir(const Complejo& c)
{
cout << c.real << (c.imag >= 0 ? " + ":" ") << c.imag << " i";
}
}
//- fin: complejos.cpp

Un ejemplo de utilizaci´on del m´odulo de nu´meros complejos podr´ıa ser:

//- fichero: main.cpp

#include <iostream>
#include "complejos.hpp"
using namespace std;
using namespace umalcc;
/*
* utilizaci´on de n´umeros complejos
*/
int main()
{
Complejo c1, c2, c3;
crear(c2, 2.5, 4.7);
crear(c3, 7.2, 6.3);
multiplicar(c1, c2, c3);
escribir(c1);
}
//- fin: main.cpp

Su compilaci´on separada y enlazado en GNU GCC :

g++ -ansi -Wall -Werror -c complejos.cpp

g++ -ansi -Wall -Werror -c main.cpp
g++ -ansi -Wall -Werror -o main main.o complejos.o

Alternativamente se puede realizar en dos pasos:

g++ -ansi -Wall -Werror -c complejos.cpp

g++ -ansi -Wall -Werror -o main main.cpp complejos.o

o incluso en un u´nico paso:

g++ -ansi -Wall -Werror -o main main.cpp complejos.cpp

11.4. Herramientas de Ayuda a la Gesti´on de la

Compi- laci´on Separada A

En los sistemas Unix (Linux, MacOS-X, etc.) existe una herramienta para la ayuda en la gesti
´on del proceso de compilaci´on separada. Esta herramienta es capaz de generar autom
´aticamente las dependencias de los ficheros (utilizando para ello makedepend), de tal forma que
cuando algu´ n fichero de encabezamiento cambia, la herramienta make invocar´a la compilaci
´on de s´olo aquellos m´odulos que se vean afectados por los cambios realizados desde la u
´ltima compilaci´on realizada. Por ejemplo, para los siguientes ficheros que componen un
programa completo:
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 11. MO´ DULOS Y
BIBLIOTECAS
//- fichero: vector.hpp //- fichero: stack.hpp
#ifndef _vector_hpp_ #ifndef _stack_hpp_
#define _vector_hpp_ #define _stack_hpp_
#include <tr1/array> #include "vector.hpp"
namespace umalcc { namespace umalcc {
// ... // ...
} }
#endif #endif

//- fichero: vector.cpp //- fichero: main.cpp

#include "vector.hpp" #include <iostream>
#include <iostream> #include <jpeglib.h>
namespace umalcc { #include "vector.hpp"
// ... #include "stack.hpp"
} int main()
{
// ...
}

Se define el siguiente fichero Makefile que contiene la enumeraci´on de los ficheros fuente (SRCS) que
componen el programa completo, as´ı como las librer´ıas externas necesarias (LIBS). Este ejemplo
sigue la sintaxis utilizada por GNU Make (donde el s representa el car´acter tabulador ):
7→
´ımbolo
#- Makefile
SRCS=main.cpp vector.cpp
LIBS=-ljpeg
#----------------------------------
PROGNAME=
#------------------------------------------------------------------ -
ifeq ($(strip $(PROGNAME)),)
PROGNAME=$(basename $(notdir $(firstword $(SRCS))))
endif
ifdef NDEBUG
CXXDBGFLAGS=-DNDEBUG -O2
else
CXXDBGFLAGS=-g
endif
#----------------------------------
CXXFLAGS=-ansi -Wall -Werror $(CXXDBGFLAGS)
ALLDEFINES=$(CXXFLAGS)
DEPENDFLAGS=-Y
DEPEND=makedepend
OBJS=$(SRCS:.cpp=.o)
#----------------------------------
all: $(PROGNAME)
ndebug:
7→ make NDEBUG=1
$(PROGNAME): $(OBJS)
7→ $(LINK.cc) -o $@ $(OBJS) $(LIBS)
depend:
7→ -@$(DEPEND) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- $(SRCS) >& /dev/null
#
# DO NOT DELETE THIS LINE -- make depend depends on it.

donde la siguiente invocaci´on a make desde un terminal (shell) de Unix:

$ make depend

an˜ade autom´aticamente las siguientes l´ıneas de dependencias al final del fichero Makefile:
main.o: stack.hpp vector.hpp
vector.o: vector.hpp

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

11.4. HERRAMIENTAS DE AYUDA A LA GESTIO´ N DE LA COMPILACIO´ N
SEPARADA3
La siguiente invocaci´on a make desde un terminal (shell) de Unix:
$ make

realiza la siguiente compilaci´on:

g++ -ansi -Wall -Werror -g -c -o main.o main.cpp
g++ -ansi -Wall -Werror -g -c -o vector.o vector.cpp
g++ -ansi -Wall -Werror -g -o main main.o vector.o -ljpeg

y la siguiente invocaci´on a make desde un terminal (shell) de Unix:

$ make ndebug

realiza la siguiente compilaci´on:

g++ -ansi -Wall -Werror -DNDEBUG -O2 -c -o main.o main.cpp
g++ -ansi -Wall -Werror -DNDEBUG -O2 -c -o vector.o vector.cpp
g++ -ansi -Wall -Werror -DNDEBUG -O2 -o main main.o vector.o -ljpeg

Posteriormente, algu´n cambio en los ficheros main.cpp o stack.hpp har´a que la invocaci´on a make
realice la siguiente compilaci´on:
g++ -ansi -Wall -Werror -g -c -o main.o main.cpp
g++ -ansi -Wall -Werror -g -o main main.o vector.o -ljpeg

Sin embargo, si se modifica el fichero vector.hpp, entonces se compilar´a todo de nuevo, ya que
vector.hpp es incluido por todos los m´odulos del programa.
g++ -ansi -Wall -Werror -g -c -o main.o main.cpp
g++ -ansi -Wall -Werror -g -c -o vector.o vector.cpp
g++ -ansi -Wall -Werror -g -o main main.o vector.o -ljpeg

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 11. MO´ DULOS Y
BIBLIOTECAS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 12

Manejo de Errores. Excepciones

Durante la ejecuci´on de un programa, ´este debe tratar con situaciones an´omalas que suelen
ser excepcionales, es decir, no forman parte del flujo de ejecuci´on normal del programa en
situaciones normales. Sin embargo, estas situaciones, a pesar de ser excepcionales, ocurren, y el
programa debe estar preparado para tratar con ellas.
Dentro de estas situaciones an´omalas, podr´ıamos diferenciar dos grandes grupos, por un
lado est´an aquellas situaciones que se producen debido a errores de programaci´on, que deben ser
evitadas mediante un adecuado disen˜o y programaci´on, y por otro lado est´an aquellas
producidas por situaciones an´omalas excepcionales, que no pueden ser anticipadas, evitadas o
tratadas hasta que dicha situaci´on sucede durante la ejecuci´on del programa.
Respecto a los errores de programaci´on, es algo que no deber´ıa suceder en un programa
bien disen˜ado, pero la realidad ensen˜a que el desarrollador de software debe convivir con
ellos. Por lo tanto, debe estar preparado para tratar con ellos, y disen˜ar estrategias que
minimicen los errores de programaci´on, as´ı como su influencia.

12.1. Errores de Programaci´on y Asertos

Los asertos constituyen una ayuda importante para la detecci´on de errores de programaci´on
du- rante la fase de desarrollo y depuraci´on del proyecto software. Los asertos comprueban que el
estado del programa sea consistente frente a errores de programaci´on. Hacen referencia a pre-
condiciones, post-condiciones, invariantes, etc. especificando, mediante expresiones l´ogicas,
que el estado del programa en un determinado punto de su ejecuci´on deber´ıa cumplir con unas
determinadas condi- ciones especificadas segu´n el correcto comportamiento te´orico del
programa (v´ease 5.11).
En caso de que las condiciones especificadas en los asertos no se cumplan, entonces reflejan
errores de programaci´on, por lo que el aserto que no se cumpla abortar´a la ejecuci´on del
programa indicando la situaci´on donde fall´o dicha comprobaci´on del estado.
Para poder utilizar asertos, hay que incluir la biblioteca est´andar <cassert>. As´ı, en el
siguiente ejemplo, el aserto que expresa la pre-condici´on del subprograma fallar´a si su invocaci
´on no respeta las restricciones especificadas por la definici´on del mismo. Por ello es necesario que
el programa que hace la invocaci´on implemente algu´n mecanismo (en este caso la sentencia
if (...) { ... }) que garantice que la llamada cumplir´a la restricci´on especificada por la pre-
condici´on. Por otra parte, si no se cumple el aserto que expresa la post-condici´on del
subprograma, entonces habr´a algu´ n error en su programaci´on que deber´a ser subsanado.

145
 12.3. GESTIO´ N DE ERRORES MEDIANTE 1
EXCEPCIONES
#include <iostream>
#include <cassert>
using namespace std;
//--------------------------------------------------- -
// retorna el cociente y resto resultado de dividir
// dividendo entre divisor
// Precond: (divisor != 0)
//--------------------------------------------------- -
void dividir(int dividendo, int divisor, int& cociente, int& resto)
{
assert(divisor != 0); // PRE-CONDICI
´ON cociente = dividendo / divisor;
resto = dividendo % divisor;
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}
//--------------------------------------------------- -
int main()
{
int dividendo, divisor, cociente, resto;
cout << "Introduzca Dividendo y Divisor ";
cin >> dividendo >> divisor;
if (divisor == 0) {
cout << "Error, divisi´on por cero no permitida" << endl;
} else {
dividir(dividendo, divisor, cociente, resto);
cout << "Dividendo: " << dividendo << endl;
cout << "Divisor: " << divisor << endl;
cout << " Cociente: " << cociente << endl;
cout << " Resto: " << resto << endl;
}
}
Los asertos son u´tiles durante el desarrollo y depuraci´on del programa, sin embargo se
suelen desactivar cuando se han corregido todos los errores de programaci´on y se implanta el
software desarrollado. En GNU GCC es posible desactivar la comprobaci´on de asertos mediante la
siguiente directiva de compilaci´on, que ser´a utilizada para la generaci´on del c´odigo final a
implantar:
g++ -DNDEBUG -ansi -Wall -Werror -o programa programa.cpp

12.2. Situaciones An´omalas Excepcionales

Hay situaciones en las cuales el error (o comportamiento an´omalo) no puede ser previsto y
evitado con antelaci´on, y debe ser gestionado adecuadamente por el programa en el momento en el
que ´este suceda, por ejemplo una entrada de datos err´onea desde el exterior, un fichero para
entrada de datos que no existe, un fichero para salida de datos que no puede ser creado,
agotamiento de la reserva de memoria din´amica en caso de ser necesaria, una entrada de
datos que excede de la capacidad de gesti´on del programa, etc.
Estas situaciones an´omalas usualmente impiden a una determinada parte del software cumplir
sus especificaciones y llevar a cabo sus tareas. As´ı, si el entorno del software donde se detecta la
situaci´on an´omala tiene informaci´on y capacidad suficiente para tratar y gestionar dicha
situaci´on, de tal forma que despu´es de dicho tratamiento le sea posible cumplir con sus
especificaciones y llevar a cabo su tarea, entonces el tratamiento de la situaci´on an´omala se
realizar´a en dicho lugar. Por otra parte, si el entorno del software donde se detecta la situaci
´on an´omala no tiene capaci- dad para su tratamiento, entonces deber´a informar al entorno
externo superior (normalmente el programa invocante) de que no pudo cumplir sus
especificaciones por la existencia de una determi- nada situaci´on an´omala, un error. Dadas estas
situaciones an´omalas donde una determinada pieza de software detecta una determinada situaci
´on de error, existen diversos enfoques para informar
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 12. MANEJO DE ERRORES. EXCEPCIONES
al entorno externo superior:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 12.3. GESTIO´ N DE ERRORES MEDIANTE 3
EXCEPCIONES
1. Informar del error mediante un c´odigo de retorno (retorno de funci´on o par´ametro de
salida). Este es el m´etodo usualmente utilizado en el lenguaje de programaci´on C, su librer
´ıa est´andar y API del sistema operativo.
Este m´etodo es quiz´as el m ´a s f´acil de gestionar “a priori”, donde el tratamiento de
las situaciones de error son tratadas dentro del propio flujo de ejecuci´on normal del
programa. Sin embargo, la utilizaci´on de este m´etodo puede dar lugar a errores de
programaci´on debidos a que el software minimice e incluso ignore y elimine la gesti´on y
tratamiento de determinados errores.
2. En caso de situaci´on err´onea, poner el estado de un determinado objeto en modo err
´oneo, de tal forma que el comportamiento del objeto refleje dicho estado. Este m´etodo
es el seguido por los flujos de entrada y salida de la biblioteca est´andar de C++.
Este m´etodo puede ser visto como una extensi´on del primer m´etodo anterior en un
escenario de abstracci´on de datos (tipos abstractos de datos y programaci´on orientada
a objetos). En este caso, como en el anterior, el tratamiento de errores se encuentra integrado
con el flujo de ejecuci´on normal del programa, y adem´as, tambi´en es vulnerable a errores
de programaci´on debidos a la posibilidad de que el software ignore el tratamiento de
estos errores.
3. En caso de situaci´on err´onea, lanzar una determinada excepci´on especificando el error,
inter- rumpiendo el flujo de ejecuci´on normal del programa, de tal forma que sea
capturada en un determinado entorno con capacidad e informaci´on suficiente para que
pueda ser gestionada adecuadamente.
Este m´etodo es adecuado para el tratamiento de situaciones an´omalas excepcionales,
cuyo tratamiento debe ser gestionado de forma ajena al flujo de ejecuci´on normal del
programa. Este m´etodo proporciona un sistema robusto para el manejo de situaciones
excepcionales, cuyo tratamiento no puede ser ignorado.
Estos m´etodos presentan diferentes enfoques para informar al entorno exterior de la existencia
de un determinado error, as´ı como diferentes enfoques para su tratamiento, el cual se puede
ges- tionar dentro del propio flujo de ejecuci´on normal del programa, o mediante un flujo
alternativo ajeno al flujo de ejecuci´on normal.
As´ı, integrar el tratamiento de errores dentro del flujo de ejecuci´on normal del programa
puede ser adecuado cuando la situaci´on an´omala se considera como parte integrada dentro
del com- portamiento normal del programa. Por otra parte, cuando la situaci´on an´omala es
excepcional y requiere de un tratamiento excepcional al comportamiento normal del programa,
entonces puede ser m ´as adecuado gestionar estas situaciones en un flujo de ejecuci´on diferente,
alternativo al flujo de ejecuci´on normal del programa. Este mecanismo, adem´as, presenta la
ventaja de que el soft- ware para el tratamiento de los errores est´a claramente diferenciado del
software para la ejecuci´on normal del programa.
Sin embargo, el desarrollo de software y la gesti´on de recursos en un entorno con presencia
de excepciones puede resultar m ´a s complicado, debido a la existencia, a veces invisible, de un
posible flujo de ejecuci´on alternativo al flujo de ejecuci´on normal del programa.1.

12.3. Gestio´n de Errores Mediante Excepciones

Las excepciones surgen como una forma de manejar situaciones de error excepcionales en
los programas, no son por lo tanto un mecanismo para controlar el flujo de ejecuci´on normal
del programa, ni son un mecanismo para gestionar un error de programaci´on. Son muy
adecuadas porque permiten diferenciar el c´odigo correspondiente a la resoluci´on del
problema del c´odigo encargado de manejar situaciones an´omalas.

Como norma general de disen˜o, un subprograma (o m´etodo) debe suponer que su pre-
condici´on se cumple a su invocaci´on, y as´ı, en este caso, si no es capaz de realizar su tarea
1
RAII (cap. 22.1) es una t´ecnica para la gesti´on autom´atica de los recursos en presencia de excepciones.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 12. MANEJO DE ERRORES. EXCEPCIONES

y cumplir con su post-condici´on, entonces deber´a lanzar una excepci´on. Normalmente

´esto sucede cuando hay una situaci´on excepcional de error que el subprograma no
tiene informaci´on suficiente para manejar (resolver), por lo que deber´a lanzar la
excepci´on para que sea manejada a otro nivel superior.

Para lanzar (tambi´en conocido como elevar) una excepci´on desde una determinada parte
del c´odigo, la siguiente sentencia lanza una excepci´on del tipo de valor, con el valor
especificado:
throw valor;

Cuando se lanza una excepci´on, el flujo de ejecuci´on se interrumpe y salta directamente al

mane- jador que es capaz de capturarla segu´n su tipo, retornando autom´aticamente de los
subprogramas anidados donde se encuentre, destruy´endose todas las variables que han sido
creadas en los ´ambitos y subprogramas de los que se salga, hasta llegar al manejador.
Por otra parte, el c´odigo disen˜ado para gestionar el tratamiento de excepciones debe
estar en un bloque try/catch, de tal forma que una excepci´on lanzada por un determinado c
´odigo dentro del bloque try ser ´a capturada por el bloque catch correspondiente, segu´ n el
tipo de la excepci´on lanzada. En caso de no existir un bloque catch del tipo adecuado, el
manejador de excepciones buscar´a un bloque catch de tipo adecuado en un nivel externo
superior. Si finalmente no se encontrase ningu´n bloque catch adecuado, el programa abortar
´ıa.
try {
// codigo que puede lanzar una excepci´on
} catch (const Error1& e) {
// codigo que maneja la excepci´on ’e’ de tipo Error1
} catch (const Error2& e) {
// codigo que maneja la excepci´on ’e’ de tipo Error2
} catch ( ... ) { // captura cualquier excepci´on
// codigo que maneja una excepci´on sin tipo especificado
}

Es as´ı mismo tambi´en posible, dentro de un bloque catch, relanzar la excepci´on que est´a siendo
manejada, para que pueda ser tratada en un nivel externo superior, de la siguiente forma:
} catch ( ... ) { // captura cualquier excepci´on
// codigo que maneja una excepci´on sin tipo especificado
throw; // relanza la excepci´on
}

El tipo de la excepci´on lanzada podr´a ser simple o compuesto. Por ejemplo:

#include <iostream>
#include <cassert>
using namespace std;
//--------------------------------------------------- -
enum Excepcion { // Tipo de la Excepci´on
DIVISION_POR_CERO
};
//--------------------------------------------------- -
// retorna el cociente y resto resultado de dividir
// dividendo entre divisor
// Lanza excep. DIVISION_POR_CERO si (divisor == 0)
//--------------------------------------------------- -
void dividir(int dividendo, int divisor, int& cociente, int& resto)
{
if (divisor == 0) {
throw DIVISION_POR_CERO;
}
cociente = dividendo / divisor;
resto = dividendo % divisor;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

12.3. GESTIO´ N DE ERRORES MEDIANTE 5
EXCEPCIONES
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}
//--------------------------------------------------- -
int main()
{
try {
int dividendo, divisor, cociente, resto;
cout << "Introduzca Dividendo y Divisor ";
cin >> dividendo >> divisor;
dividir(dividendo, divisor, cociente, resto);
cout << "Dividendo: " << dividendo << endl;
cout << "Divisor: " << divisor << endl;
cout << " Cociente: " << cociente << endl;
cout << " Resto: " << resto << endl;
} catch (const Excepcion& e)
{ switch (e) {
case DIVISION_POR_CERO:
cerr << "Error: Divisi´on por Cero" << endl;
break;
default:
cerr << "Error inesperado" << endl;
break;
}
} catch ( ... ) {
cerr << "Error inesperado" << endl;
}
}

Tambi´en es posible lanzar excepciones de tipos compuestos, los cuales podr´an ser sin campos
internos si s ´ol o interesa el tipo de la excepci´on. Por ejemplo:
#include <iostream>
#include <cassert>
using namespace std;
//--------------------------------------------------- -
struct Division_por_Cero {}; // Tipo de la Excepci´on
//--------------------------------------------------- -
// retorna el cociente y resto resultado de dividir
// dividendo entre divisor
// Lanza excep. Division_por_Cero si (divisor == 0)
//--------------------------------------------------- -
void dividir(int dividendo, int divisor, int& cociente, int& resto)
{
if (divisor == 0) {
throw Division_por_Cero();
}
cociente = dividendo / divisor;
resto = dividendo % divisor;
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}
//--------------------------------------------------- -
int main()
{
try {
int dividendo, divisor, cociente, resto;
cout << "Introduzca Dividendo y Divisor ";
cin >> dividendo >> divisor;
dividir(dividendo, divisor, cociente, resto);
cout << "Dividendo: " << dividendo << endl;
cout << "Divisor: " << divisor << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 12. MANEJO DE ERRORES. EXCEPCIONES

cout << " Cociente: " << cociente << endl;

cout << " Resto: " << resto << endl;
} catch (const Division_por_Cero& e) {
cerr << "Error: Divisi´on por Cero" << endl;
} catch ( ... ) {
cerr << "Error inesperado" << endl;
}
}

Sin embargo, tambi´en es posible que las excepciones de tipos compuestos contengan valores que
puedan informar al entorno superior de la naturaleza del error. Por ejemplo:

#include <iostream>
#include <cassert>
using namespace std;
//--------------------------------------------------- -
struct Division_por_Cero { // Tipo de la Excepci´on
int dividendo;
int divisor;
};
//--------------------------------------------------- -
// retorna el cociente y resto resultado de dividir
// dividendo entre divisor
// Lanza excep. Division_por_Cero si (divisor == 0)
//--------------------------------------------------- -
void dividir(int dividendo, int divisor, int& cociente, int& resto)
{
if (divisor == 0)
{ Division_por_Cero e;
e.dividendo = dividendo;
e.divisor = divisor;
throw e;
}
cociente = dividendo / divisor;
resto = dividendo % divisor;
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}
//--------------------------------------------------- -
int main()
{
try {
int dividendo, divisor, cociente, resto;
cout << "Introduzca Dividendo y Divisor ";
cin >> dividendo >> divisor;
dividir(dividendo, divisor, cociente, resto);
cout << "Dividendo: " << dividendo << endl;
cout << "Divisor: " << divisor << endl;
cout << " Cociente: " << cociente << endl;
cout << " Resto: " << resto << endl;
} catch (const Division_por_Cero& e)
{ cerr << "Error: Divisi´on por Cero: "
<< e.dividendo <<" / "<< e.divisor<< endl;
} catch ( ... ) {
cerr << "Error inesperado" << endl;
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 12.3. GESTIO´ N DE ERRORES MEDIANTE 7
EXCEPCIONES
A Directrices en el Disen˜o del Tratamiento de Errores

Considerando el disen˜o del software, es muy importante tomar una adecuada decisi´on
respecto a si una determinada circunstancia debe ser especificada mediante pre-condiciones (y
por lo tanto gestionada dentro del flujo normal de ejecuci´on del programa para evitar la
invocaci´on en dichas situaciones), o por el contrario no especificar la pre-condici´on y lanzar
una excepci´on en el caso de que surja la situaci´on. Normalmente, si la situaci´on es
excepcional dentro de las circunstancias de ejecuci´on del programa, y requiere un tratamiento
excepcional, entonces puede ser m ´a s ade- cuado considerar su tratamiento mediante
excepciones. Sin embargo, si la situaci´on es bastante usual dentro de las circunstancias de
ejecuci´on del programa, entonces probablemente requiera un tratamiento dentro del flujo de
ejecuci´on normal del programa. Una t´ecnica usual de programaci´on robusta respecto a la gesti
´on de recursos en un entorno con excepciones es RAII (v´ease 22.1).
N´otese que es normalmente un s´ıntoma de mal disen˜o el hecho de que el c´odigo del
progra- ma est´e repleto de bloques try/catch, ya que en ese caso mostrar´ıa una situaci´on
donde dichas excepciones no son tan excepcionales, sino que forman parte del flujo normal de
ejecuci´on. No ser´ıa natural que cada llamada a un subprograma tuviera un bloque
try/catch para capturar las excepciones lanzadas por ´este, ya que normalmente dichas
excepciones ser´an excepcionales y normalmente ser´an tratadas a otro nivel.
Por ejemplo, en el disen˜o de una estructura de datos stack (pila), es una situaci´on usual
com- probar si la pila e st ´a vac´ıa, y en caso contrario, sacar un elemento de ella para su
procesamiento. Por lo tanto, el caso de que la pila est´e vac´ıa es una situaci´on normal, y se
deber´a tratar en el flujo de ejecuci´on normal del programa. Sin embargo, es inusual el hecho
de que la pila se llene, ya que normalmente se dimensiona lo suficientemente amplia para poder
resolver un determinado problema. En el caso excepcional de que la pila se llene, este hecho ser
´a un escollo para resolver el problema, por lo que se puede indicar mediante una excepci´on.
//- fichero: stack.hpp
#ifndef _stack_hpp_
#define _stack_hpp_
#include <cassert>
#include <tr1/array>
namespace umalcc {
const unsigned MAX_ELMS = 30;
std::tr1::array<int, MAX_ELMS> Datos;
struct Stack {
unsigned nelms;
Datos elm;
};
//------------------------------------------------
struct Stack_Full {}; // Tipo de la Excepci´on
//------------------------------------------------
inline void init(Stack& s)
{
s.nelms = 0;
}
inline bool empty(const Stack& s)
{ return (s.nelms == 0);
}
inline void push(Stack& s, int e)
{
if (s.nelms >= s.elm.size()) {
throw Stack_Full();
}
s.elm[s.nelms] = e;
++s.nelms;
}
inline int pop(Stack& s)
{
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 8 CAP´ITULO 12. MANEJO DE ERRORES. EXCEPCIONES

assert(! empty(s)); // Pre-condici´on

--s.nelms;
return s.elm[s.nelms];
}
}
#endif
//- fin: stack.hpp

Una posible utilizaci´on del m´odulo stack definido anteriormente podr´ıa ser:
#include "stack.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;
void almacenar_datos(Stack& s)
{
for (int x = 0; x < 10; ++x)
{ push(s, x);
}
}
void imprimir(Stack& s)
{
while (! empty(s)) {
cout << pop(s) << " ";
}
cout << endl;
}
int main()
{
Stack s;
try {
init(s);
almacenar_datos(s);
imprimir(s);
} catch (const Stack_Full& e) {
cout << "Error: Pila Llena"<< endl;
} catch ( ... ) {
cout << "Error: Inesperado"<< endl;
}
}

12.4. Excepciones Est´andares A

Las excepciones est´andares que el sistema lanza est´an basadas en el tipo exception que se
obtiene incluyendo el fichero <exception> y del cual podemos obtener un mensaje mediante la
llamada a what(). Ejemplo:

try {
. . .
} catch (const exception& e) {
cout << "Error: " << e.what() << endl;
} catch ( ... ) {
cout << "Error: Inesperado"<< endl;
}

As´ı mismo, el sistema tiene un nu´mero de excepciones predefinidas (derivadas del tipo
exception anterior), que pueden, a su vez, ser base para nuevas excepciones definidas por el
programador (cap. 17):

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 12.4. EXCEPCIONES ESTA´ NDARES 153

logic_error(str): especifican errores debidos a la l´ogica interna del programa. Son

errores predecibles, detectables antes de que el programa se ejecute y por lo tanto evitables
mediante chequeos adecuados en determinados lugares. (#include <stdexcept>)
domain_error(str), invalid_argument(str), length_error(str), out_of_range(str)

runtime_error(str): errores debidos a eventos m ´a s all´a del ´ambito del programa.

Son er- rores impredecibles, s´olo detectables cuando el programa se ejecuta y la u´nica
alternativa es su manejo en tiempo de ejecuci´on. (#include <stdexcept>)
range_error(str), overflow_error(str), underflow_error(str)

bad_alloc() lanzada en fallo en new (#include <new>)

bad_cast() lanzada en fallo en dynamic_cast (#include <typeinfo>)
bad_typeid() lanzada en fallo en typeid (#include <typeinfo>)
bad_exception() lanzada en fallo en la especificaci´on de excepciones lanzadas por una fun- ci
´on. (#include <exception>)
ios::failure() lanzada en fallo en operaciones de Entrada/Salida. (#include <iostream>)

A El programador puede extender este conjunto de excepciones derivando nuevas clases basadas en
estas excepciones est´andares.
A Nota: para ver una descripci´on de los requisitos que deben cumplir las clases para comportarse
adecuadamente en un entorno de manejo de excepciones v´ease 13.3

#include <iostream>
#include <stdexcept>
#include <cassert>
using namespace std;
//--------------------------------------------------- -
// retorna el cociente y resto resultado de dividir
// dividendo entre divisor
// Lanza excep. domain_error si (divisor == 0)
//--------------------------------------------------- -
void dividir(int dividendo, int divisor, int& cociente, int& resto)
{
if (divisor == 0) {
throw domain_error("divisi´on por cero");
}
cociente = dividendo / divisor;
resto = dividendo % divisor;
assert(dividendo == (divisor * cociente + resto)); // POST-CONDICI ´ON
}
//--------------------------------------------------- -
int main()
{
try {
int dividendo, divisor, cociente, resto;
cout << "Introduzca Dividendo y Divisor ";
cin >> dividendo >> divisor;
dividir(dividendo, divisor, cociente, resto);
cout << "Dividendo: " << dividendo << endl;
cout << "Divisor: " << divisor << endl;
cout << " Cociente: " << cociente << endl;
cout << " Resto: " << resto << endl;
} catch (const domain_error& e)
{ cerr << e.what() << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 12. MANEJO DE ERRORES. EXCEPCIONES

} catch (const exception& e)

{ cerr << e.what() << endl;
} catch ( ... ) {
cerr << "Error inesperado" << endl;
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 13

Tipos Abstractos de Datos

A medida que aumenta la complejidad del problema a resolver, del mismo modo deben aumen-
tar los niveles de abstracci´on necesarios para disen˜ar y construir su soluci´on algor´ıtmica. As
´ı, la abstracci´on procedimental permite aplicar adecuadamente t´ecnicas de disen˜o
descendente y refi- namientos sucesivos en el desarrollo de algoritmos y programas. La
programaci´on modular permite aplicar la abstracci´on a mayor escala, permitiendo abstraer
sobre conjuntos de operaciones y los datos sobre los que se aplican. De esta forma, a medida que
aumenta la complejidad del problema a resolver, aumenta tambi´en la complejidad de las estructuras
de datos necesarias para su resoluci´on, y este hecho requiere, as´ı mismo, la aplicaci´on de la
abstracci´on a las estructuras de datos.
La aplicaci´on de la abstracci´on a las estructuras de datos da lugar
a los Tipos Abstractos de Datos (TAD), donde se especifica el concepto TAD
que representa un determinado tipo de datos, y la sem´antica (el
op1()
significado) de las operaciones que se le pueden aplicar, pero donde su
representaci´on e im- plementaci´on internas permanecen ocultas e op2()
inaccesibles desde el exterior, de tal forma que no son necesarias para su
op3()
utilizaci´on. As´ı, podemos consid- erar que un tipo abstracto de datos
encapsula una determinada estructura abstracta de datos, impidiendo su
manipulaci´on directa, permitiendo sola-
mente su manipulaci´on a trav´es de las operaciones especificadas. De este modo, los tipos
abstractos de datos proporcionan un mecanismo adecuado para el disen˜o y reutilizaci´on de
software fiable y robusto.
Para un determinado tipo abstracto de datos, se pueden distinguir tres niveles:

Nivel de utilizaci´on, donde se utilizan objetos de un determinado tipo abstracto de datos,

bas´andose en la especificaci´on del mismo, de forma independiente a su implementaci
´on y representaci´on concretas. As´ı, estos objetos se manipulan mediante la invocaci´on
a las op- eraciones especificadas en el TAD.

Nivel de especificaci´on, donde se especifica el tipo de datos,

el concepto abstracto que representa y la sem´antica y Utilizaci´on de TAD
Especificaci´on de TAD
restricciones de las operaciones que se le pueden aplicar. Este
Implementaci´on de TAD
nivel representa el interfaz pu´blico del tipo abstracto de
datos.

Nivel de implementaci´on, donde se define e implementa tanto las estructuras de datos

que soportan la abstracci´on, como las operaciones que actu´an sobre ella segu´n la sem
´antica es- pecificada. Este nivel interno permanece privado, y no es accesible desde el
exterior del tipo abstracto de datos.

N´otese que para una determinada especificaci´on de un tipo abstracto de datos, su implementaci´on
puede cambiar sin que ello afecte a la utilizaci´on del mismo.

155
 13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 1

13.1. Tipos Abstractos de Datos en C++: Clases

En el lenguaje de programaci´on C++, las clases dan la posibilidad al programador de
definir tipos abstractos de datos que se comporten de igual manera que los tipos predefinidos, de tal
forma que permiten definir su representaci´on interna (compuesta por sus atributos miembros),
la forma en la que se crean y se destruyen, como se asignan y se pasan como par´ametros, las
conversiones de tipos aplicables, y las operaciones que se pueden aplicar (denominadas
funciones miembros o simplemente m´etodos). De esta forma se hace el lenguaje extensible.
As´ı mismo, la definici´on de tipos abstractos de datos mediante clases puede ser combinada
con la definici´on de m´odulos (v´ease 11), haciendo de este modo posible la reutilizaci´on de
estos nuevos tipos de datos.

13.1.1. Definici´on e Implementaci´on de Clases “en L´ınea”

En el caso de definici´on de clases simples, es posible realizar la definici´on e implementaci
´on de la clase en l´ınea. Para ello se especifica la palabra reservada class seguida por el nombre
del nuevo tipo que se es t´a definiendo, y entre llaves la definici´on de los atributos (miembros) que
lo componen y de los m´etodos (funciones miembros) que se le pueden aplicar directamente. Por
ejemplo, el TAD pila de nu´meros enteros representa el siguiente concepto abstracto:

Una pila es una colecci´on ordenada (segu´n el orden de inserci´on) de

elementos ho- mog´eneos donde se pueden introducir elementos (manteniendo el
orden de inserci´on) y sacar elementos de ella (en orden inverso al orden de inserci
´on), de tal forma que el primer elemento que sale de la pila es el u´ltimo elemento
que ha sido introducido en ella. Adem´as, tambi´en es posible comprobar si la pila
contiene elementos, de tal forma que no se podr´a sacar ningu´n elemento de una
pila vac´ıa.

y se puede definir la clase Stack dentro del espacio de nombres umalcc de la siguiente forma:1
//-stack.hpp
#ifndef _stack_hpp_
#define _stack_hpp_
#include <tr1/array>
#include <cassert>
#include <stdexcept>
namespace umalcc {
class Stack {
private:
// -- Constantes Privadas -- ··
static const unsigned MAX = 256; ·
// -- Tipos Privados -- ·· ←− top
typedef std::tr1::array<int, MAX> Datos; ·
// -- Atributos Privados -- 3
unsigned top; 2
Datos data; 1
data
public:
// -- Constructor por Defecto P´ublico --
Stack() : top(0), data() {}
// -- M´etodos P´ublicos
-- bool empty() const {
return (top == 0);
}
void push(int e) {
if (top >= data.size()) {
throw std::length_error("Stack::push length error");
}
data[top] = e;
1
N´otese que el delimitador punto y coma (;) debe especificarse despu´es de la llave de cierre de la definici´on de
la clase.
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

++top;
}
int pop() { // Pre-condici´on: (! empty())
assert(! empty());
--top;
return data[top];
}
}; // El delimitador ; termina la definici´on
}
#endif
//------------------------------------------------------------------------ -

Zona Privada y Zona Pu´blica

En la definici´on de una clase, se pueden distinguir dos ´ambitos de visibilidad
(accesibilidad), la parte privada, cuyos miembros s´olo ser´an accesibles desde un ´ambito
interno a la propia clase, y la parte pu´blica, cuyos miembros son accesibles tanto desde un
´ambito interno como desde un
´ambito externo a la clase.
La parte privada comprende desde el principio de la definici´on de la clase hasta la etiqueta
public, y la parte pu´blica comprende desde esta etiqueta hasta que se encuentra otra etiqueta
private. Cada vez que se especifica una de las palabras reservadas public o private, las declara-
ciones que la siguen adquieren el atributo de visibilidad dependiendo de la etiqueta especificada.
En este manual usualmente se definir´a primero la parte pu´blica de la clase, y se definir´a
pos- teriormente la parte privada del mismo, aunque en este primer ejemplo, con objeto de
facilitar la explicaci´on y comprensi´on del mismo, se ha definido primero la parte privada y
posteriormente la parte pu´blica. N´otese que con respecto a la implementaci´on en l´ınea de
los m´etodos de la clase, el orden en el que se declaran los miembros (constantes, tipos,
atributos y m´etodos) de la clase es irrelevante.

Constantes y Tipos de A´ mbito de Clase

Las constantes de ´ambito de clase se definen especificando los cualificadores static
const, seguidos por el tipo, el identificador y el valor de la constante. Estas constantes ser´an
accesibles por todos las instancias (objetos) de la clase. En este ejemplo, se define la constante
MAX con un valor de 256.
Tambi´en se pueden definir tipos internos de ´ambito de clase de igual forma a como se
hace externamente a la clase. En este ejemplo se define un tipo Datos como un array de 256 nu
´meros enteros. Estos tipos ser´an u´tiles en la definici´on de los atributos miembros de la clase,
o para definir elementos auxiliares en la implementaci´on del tipo abstracto de datos.

Atributos
Los atributos componen la representaci´on interna de la clase, y se definen de igual forma a
los campos de los registros (v´ease 6.3). En nuestro ejemplo, el atributo top es un nu´mero
natural que representa el ´ındice de la cima de la pila, y el atributo data es un array de nu
´meros enteros que contiene los elementos almacenados en la pila, de tal forma que un nuevo
elemento se inserta en la cima de la pila, y el u´ltimo elemento se extrae tambi´en desde la
cima, incrementando o disminuyendo la cima de la pila en estas operaciones.
De igual modo a los registros y sus campos, cada instancia de la clase (objeto) que se defina
almacenar´a su propia representaci´on interna de los atributos de forma independiente a las
otras instancias de la clase (v´ease el apartado m ´a s adelante referido a instancias de clase:
objetos).

Constructores
El constructor de una clase permite construir e inicializar una instancia de la clase (un
objeto). En este ejemplo se ha definido el constructor por defecto, que es utilizado como
mecanismo por defecto para construir objetos de este tipo cuando no se especifica otro m´etodo
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 3
de construcci´on.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 1

Los constructores se denominan con el mismo identificador de la clase, seguidamente se especif-

ican entre par´entesis los par´ametros necesarios para la construcci´on, que en el caso del
constructor por defecto, ser´an vac´ıos. Seguidamente, tras el delimitador (:) se especifica la
lista de inicial- izaci´on, donde aparecen segu´ n el orden de declaraci´on todos los atributos
miembros del objeto, as´ı como los valores que toman especificados entre par´entesis (se invoca
al constructor adecuado segu´n los par´ametros especificados entre par´entesis, de tal forma que
los par´entesis vac´ıos rep- resentan la construcci´on por defecto). A continuaci´on se
especifican entre llaves las sentencias pertenecientes al cuerpo del constructor para realizar las
acciones adicionales necesarias para la construcci´on del objeto.
El lenguaje de programaci´on C++ definir´a por defecto el constructor de copia, que
permite inicializar una variable de tipo stack con una copia del valor de otra variable del mismo
tipo. As´ı mismo, tambi´en definir´a por defecto la operaci´on de asignaci´on como una copia
entre variables del mismo tipo.

M´etodos Generales y M´etodos Constantes

Los m´etodos de una clase pueden tener el cualificador const especificado despu´es de los
par´ametros, en cuyo caso indica que el m´etodo no modifica el estado interno del objeto, por
lo que se puede aplicar tanto a objetos constantes como variables. Sin embargo, si dicho
cualificador no aparece entonces significa que el m´etodo si modifica el estado interno del
objeto, por lo que s ´ol o po dr´a ser aplicado a objetos variables, y por el contrario no po dr´a
ser aplicado a objetos constantes. Por ejemplo, el m´etodo empty() que comprueba si la pila es t
´a vac´ıa, no modifica el estado del objeto, y por lo tanto se define como un m´etodo constante.
El m´etodo push(...) inserta un elemento en la cima de la pila, salvo en el caso excepcional
de que la pila est´e llena, en cuyo caso lanza una excepci´on. Por otra parte, el m´etodo pop()
extrae y retorna el elemento de la cima de la pila, con la pre-condici´on de que la pila no debe
estar vac´ıa. Por lo tanto es responsabilidad del programador realizar las comprobaciones
oportunas antes de invocar a este m´etodo.
Desde la implementaci´on interna de una clase, se pueden utilizar internamente, mediante
sus identificadores, tanto las constantes, tipos, atributos y m´etodos de esa clase. En caso de
utilizaci´on de atributos e invocaci´on de m´etodos, se corresponden con los atributos y m
´etodos aplicados a la instancia de la clase a la que se haya aplicado el m´etodo en concreto. As
´ı, cuando se utilizan los atributos data y top en el ejemplo, se est ´a accediendo a esos atributos
para la instancia de la clase a la que le sea aplicado el m´etodo correspondiente.
Por ejemplo, si se invoca al m´etodo pop() aplicado a un determinado objeto s1 de tipo
Stack mediante el operador punto s1.pop() (v´ease el siguiente apartado), entonces la
implementaci´on de pop() se aplica a los atributos data y top correspondientes a la variable
s1. Sin embargo, si se aplica el mismo m´etodo pop() a otro objeto s2 de tipo Stack, entonces
la implementaci´on de pop() se aplica a los atributos data y top correspondientes a la
variable s2.

Instancias de Clase: Objetos

Un objeto es una instancia de una clase, y podremos definir tantos objetos cuyo tipo sea de
una determinada clase como sea necesario, de tal modo que cada objeto contiene su propia
repre- sentaci´on interna de forma independiente del resto. Dado un determinado objeto, se p odr
´a manipu- lar externamente invocando a sus m´etodos pu´blicos mediante el operador punto (.).
Estos m´etodos manipular´an la representaci´on interna (atributos) de la instancia (objeto) de
la clase a la que sean aplicados. Por ejemplo el siguiente c´odigo define dos objetos (s1 y s2)
como instancias de la clase Stack, es decir, define dos objetos de tipo Stack y le aplica varios m
´etodos que lo manipulan:
int main()
{
Stack s1, s2; ···
·· ···
s1.push(3);
s1.push(4); · ···
5 ←− top
if ( ! s1.empty() ) { ·· ←− top
· 7
4
3
data dUatnaiversidad de M´alaga
Dpto. Lenguajes y Ciencias de la Computaci´on
x
s1 s2
13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 1

int x = s1.pop();
}
s2.push(7);
s2.push(5);

Stack s3 = s1; // construcci´on por copia

s3 = s2; // asignaci´on por copia
}

Otro ejemplo de utilizaci´on de la clase Stack definida anteriormente puede ser el

siguiente, donde se define en main() un objeto s de tipo Stack, que se construye mediante el
constructor por defecto, y se pasa como par´ametro por referencia a subprogramas, en los
cuales se manipula el objeto s invocando a sus m´etodos pu´blicos. N´otese como la invocaci
´on al m´etodo pop() est´a pre- cedida por una pregunta para garantizar que la pila no est´e vac
´ıa, as´ı como la manipulaci´on de la pila se encuentra englobada dentro de un bloque try/catch
para capturar la posible excepci´on en caso de que se llene la pila.

#include "stack.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;
void almacenar_datos(Stack& s)
{
for (int x = 0; x < 10; ++x) {
s.push(x);
}
}
void imprimir(Stack& s)
{
while (! s.empty() ) {
cout << s.pop() << " ";
}
cout << endl;
}
int main()
{
try {
Stack s;
almacenar_datos(s);
imprimir(s);
} catch (const length_error& e) {
cout << "Error: " << e.what() << endl;
} catch ( ... ) {
cout << "Error: Inesperado"<< endl;
}
}

13.1.2. Definici´on de Clases e Implementaci´on Separada

El lenguaje de programaci´on C++ tambi´en permite realizar por separado tanto la definici
´on de una clase por una parte, como su implementaci´on por otra parte, y distribuir el interfaz
de la clase en un fichero de encabezamiento, y la implementaci´on de la clase en un fichero de
implementaci´on. Vamos a definir el interfaz y la implementaci´on del tipo abstracto de
datos Vector como un array incompleto de nu´meros enteros, al cual se le pueden an˜adir
elementos hasta un determinado l´ımite. Algunos m´etodos simples se definir´an en l´ınea, mientras
que otros m´etodos m ´a s complejos
se definir´an aparte en el fichero de implementaci´on.

//- vector.hpp

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

#ifndef _vector_hpp_
#define _vector_hpp_
#include <iostream>
#include <tr1/array>
#include <cassert>
namespace umalcc {
class Vector {
public:
~Vector() {} // destructor
Vector() : sz(0), v() {} // constructor por defecto
Vector(const Vector& orig); // constructor de copia
Vector(const Vector& orig, unsigned i, unsigned nelms = MAX); // constructor
explicit Vector(unsigned n); // constructor expl´ıcito
Vector& operator =(const Vector& orig); // asignaci´on
unsigned size() const { return sz; };
void clear() { sz = 0; }
void push_back(int e);
void pop_back(); // Pre-condici´on: (size() > 0)
const int& operator [](unsigned i) const { // Pre-condici´on: (i < size())
assert(i < size());
return v[i];
}
int& operator [](unsigned i) { // Pre-condici´on: (i < size())
assert(i < size());
return v[i];
}
Vector subvector(unsigned i, unsigned nelms = MAX) const;
Vector& operator +=(const Vector& vect);
Vector& operator +=(int e) { push_back(e); return *this; }
friend Vector operator + (const Vector& v1, const Vector& v2);
friend bool operator == (const Vector& v1, const Vector& v2);
friend bool operator < (const Vector& v1, const Vector& v2);
friend bool operator != (const Vector& v1, const Vector& v2) { return ! (v1 == v2); }
friend bool operator > (const Vector& v1, const Vector& v2) { return (v2 < v1); }
friend bool operator >= (const Vector& v1, const Vector& v2) { return ! (v1 < v2); }
friend bool operator <= (const Vector& v1, const Vector& v2) { return ! (v2 < v1); }
friend std::ostream& operator << (std::ostream& out, const Vector& vect);
friend std::istream& operator >> (std::istream& in, Vector& vect);
private:
static const unsigned MAX = 256;
typedef std::tr1::array<int, MAX> Datos;
// -- Atributos --
unsigned sz;
Datos v;
};
}
#endif
//------------------------------------------------------------------ -

Constantes y Tipos de A´ mbito de Clase

Se ha visto anteriormente como es posible definir tipos y constantes de ´ambito de clase.

Estas constantes son compartidas por todas las instancias de la clase (objetos), y es por ello por
lo que es necesario poner la palabra reservada static delante de la definici´on de la constante,
para indicar que esa constante es u´nica y compartida por todas las instancias de la clase.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 3

Atributos
Los atributos componen la representaci´on interna de la clase, de tal forma que cada objeto
se compone de un nu´ mero natural (sz) que indica cuantos elementos tiene almacenados, y de
un array (v) donde se almacenan los elementos de forma consecutiva desde el comienzo del
mismo. Es importante recordar que cada instancia de la clase (objeto) contiene su propia
representaci´on interna (atributos) independiente de las otras instancias.

Destructor
El destructor de la clase se define mediante el s´ımbolo ~ seguido del identificador de la
clase y una lista de par´ametros vac´ıa (~Vector()).
Este destructor s er ´a invocado autom´aticamente (sin par´ametros actuales) para una
determina- da instancia (objeto) de esta clase cuando dicho objeto deba ser destruido,
normalmente suced- e r ´a cuando el flujo de ejecuci´on del programa salga del ´ambito de
visibilidad de dicho objeto.
{
Vector v1; // construcci´on del objeto ’v1’
... // utilizaci´on del objeto ’v1’
} // destrucci´on del objeto ’v1’

En el cuerpo del destructor se especificar´an las sentencias necesarias para destruir el objeto, tales
co- mo liberaciones de los recursos que contenga, etc. Posteriormente, el destructor invoca autom
´atica- mente a los destructores de los atributos miembros del objeto para que ´estos sean
destruidos. En el caso del ejemplo no es necesario realizar ninguna acci´on adicional, por lo
que el cuerpo del de- structor se define en l´ınea como vac´ıo. Esto u´ltimo es equivalente a no
definir el destructor de la clase, en cuyo caso el compilador lo define autom´aticamente como vac
´ıo. N´otese que un destructor nunca deber´a lanzar excepciones.

Constructores
Los constructores de la clase especifican las diferentes formas de crear (construir) un determina-
do objeto y establecen su invariante. Los constructores se denominan con el mismo identificador de
la clase, seguidamente se especifican entre par´entesis los par´ametros necesarios para la construcci
´on. Para su implementaci´on, tras el delimitador (:) se especifica la lista de inicializaci´on,
donde aparecen segu´n el orden de declaraci´on todos los atributos miembros del objeto, as´ı como
los valores que toman especificados entre par´entesis (se invoca al constructor adecuado segu´ n los
par´ametros
especificados entre par´entesis, de tal forma que los par´entesis vac´ıos representan la construcci
´on por defecto). A continuaci´on se especifican entre llaves las sentencias pertenecientes al
cuerpo del constructor para realizar las acciones adicionales necesarias para la construcci´on
del objeto.
Para una determinada clase, pueden existir mu´ltiples definiciones de constructores,
diferen- ci´andose entre ellos por los par´ametros. De entre todos ellos, hay dos constructores
especiales: el constructor por defecto, y el constructor de copia.

Constructor por Defecto

El constructor por defecto no recibe ningu´ n par´ametro y define como se crear´a un
objeto de dicha clase si no se especifica ninguna forma expl´ıcita de construcci´on. Si el
programador no define ningu´n constructor, entonces el compilador definir´a autom´aticamente
un constructor por defecto que invoque autom´aticamente a los constructores por defecto de cada
atributo miembro del objeto. En nuestro ejemplo, el constructor por defecto se ha implementado en l
´ınea debido a su simplicidad.
Se puede crear un objeto de tipo Vector construido por defecto de la siguiente forma:
Vector v1;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS
o tambi´en:
Vector v2 = Vector();

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 5

N´otese como en este segundo ejemplo se invoca directamente al constructor para construir un
objeto.

Constructor de Copia
El constructor de copia recibe como par´ametro un objeto de la misma clase y especifica
como crear un nuevo objeto que sea una copia del objeto que se recibe. Este constructor se
utiliza en las inicializaciones de objetos de este tipo y en el paso de par´ametros por valor a
subprogramas (aunque este caso est´a desaconsejado, prefiri´endose en esta situaci´on el paso
por referencia constante). Si el programador no define expl´ıcitamente el constructor de copia,
entonces el compilador define autom´aticamente un constructor de copia que realiza una copia
individual de todos los atributos del objeto, invocando impl´ıcitamente a los constructores de
copia de cada atributo miembro.
Por ejemplo, se puede crear un objeto de tipo Vector mediante copia de otro objeto de tipo
Vector de la siguiente forma:
Vector v3(v1);

o tambi´en:
Vector v4 = v1;

o tambi´en:
Vector v5 = Vector(v1);

N´otese como en este u´ltimo ejemplo se invoca directamente al constructor para construir un objeto.

A Constructores Expl´ıcitos

Si se especifica la palabra reservada explicit delante de la declaraci´on de un constructor,

entonces se elimina la posibilidad de que el constructor se aplique de forma impl´ıcita, haciendo
necesario que sea invocado expl´ıcitamente. De hecho, es una forma de evitar conversiones de
tipo impl´ıcitas, y adem´as, si el especificador explicit se aplica al constructor de copia,
entonces se evita el paso de par´ametros por valor.
En este ejemplo, se define un constructor expl´ıcito del tipo Vector con un par´ametro de
tipo unsigned, de tal forma que en caso de ser invocado, crear´a un vector inicial con tantos
elementos (con valor inicial cero) como especifique dicho par´ametro. Por ejemplo, para crear
un vector con cinco elementos nulos se puede hacer de la siguiente forma:
Vector v6(5);

o tambi´en:
Vector v7 = Vector(5);

Sin embargo, si no se hubiese cualificado el constructor como explicit, entonces el siguiente c

´odigo tambi´en ser´ıa v´alido, aunque en nuestro ejemplo no lo es, ya que ha sido declarado
explicit.
Vector v8 = 5; // Error: requiere que el constructor no sea explicit

Operador de Asignaci´on
El operador de asignaci´on define como se realiza esta operaci´on para objetos de esta
clase. En caso de que el programador no defina este m´etodo, entonces el compilador define
autom´atica- mente un operador de asignaci´on que invoca autom´aticamente al operador de
asignaci´on para cada atributo miembro de la clase.
No se debe confundir el operador de asignaci´on con el constructor de copia, ya que el
constructor de copia construye un nuevo objeto que no tiene previamente ningu´n valor, mientras
que en el caso del operador de asignaci´on, el objeto ya tiene previamente un valor que deber´a
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
6 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS
ser sustituido por

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 7

el nuevo valor. Este valor previo deber´a, en ocasiones, ser destruido antes de realizar la asignaci
´on del nuevo valor.
A En el lenguaje de programaci´on C++, el operador de asignaci´on devuelve una referencia al
propio objeto que est ´a siendo asignado. Esto es as´ı porque se permite encadenar sucesivas
asignaciones en la misma sentencia, aunque realizar este encadenamiento puede traer consigo
problemas de legibilidad, por lo que en general se desaconseja su utilizaci´on.
A N´otese que devolver una referencia es diferente de la devoluci´on normal donde se devuelve
un determinado valor temporal. En caso de devolver una referencia, se devuelve el propio
objeto y se le puede aplicar un m´etodo directamente, o incluso puede serle asignado un nuevo
valor (puede aparecer en la parte izquierda de una sentencia de asignaci´on).

M´etodos y Operadores Generales y Constantes

Como se explic´o anteriormente, los m´etodos de una clase pueden tener el cualificador
const especificado despu´es de los par´ametros, en cuyo caso indica que el m´etodo no modifica
el estado interno del objeto, por lo que se puede aplicar tanto a objetos constantes como
variables. Sin embargo, si dicho cualificador no aparece entonces significa que el m´etodo si
modifica el estado interno del objeto, por lo tanto s´olo po dr´a ser aplicado a objetos
variables, y por el contrario no po dr´a ser aplicado a objetos constantes.
El m´etodo constante size() no modifica el estado interno del objeto, y devuelve el nu
´mero de elementos actuales almacenados en el vector. En nuestro ejemplo, se ha implementado
en l´ınea debido a su simplicidad.
El m´etodo subvector(...) devuelve un nuevo vector creado con los elementos del vector
actual desde una determinada posici´on, un nu´mero determinado de elementos.
El m´etodo clear() re-inicializa el vector al estado vac´ıo, es decir, sin elementos
almacenados. El m´etodo push_back() permite an˜adir un elemento al final del vector,
mientras que el m´etodo pop_back() elimina el u´ltimo elemento del mismo.
Por otra parte, el operador de incremento (+=) se define para an˜adir elementos al vector,
de tal forma que an˜adir un s ´ol o elemento es equivalente al m´etodo push_back(...),
mientras que tambi´en existe la posibilidad de an˜adir los elementos que contenga otro vector.
Este operador de
incremento devuelve una referencia a este objeto, de igual manera que lo hace el operador de
asignaci´on.
As´ı, los m´etodos de una clase se aplican a los objetos mediante el operador punto. Por ejemplo:
Vector v1(7);
v1.push_back(5);
Vector v2 = v1.subvector(3, 2);

mientras que los operadores se aplican utilizando la notaci´on correspondiente (infija, post-fija
o prefija) segu´ n el operador especificado. Por ejemplo:
Vector v1(7);
v1.push_back(5);
Vector v2;
v2 = v1.subvector(3, 2);
v2 += Vector(3);

A M´etodos y Operadores que Devuelven Referencias

El ejemplo muestra como se define el operador de indexaci´on ([]) para el tipo Vector, el cual
se define de forma independiente para ser aplicado a objetos constantes y para ser aplicado a
objetos variables. Ambos reciben como par´ametro un ´ındice, y devuelven una referencia al
elemento que ocupa dicha posici´on en el vector (una referencia constante en caso de ser
aplicado a un objeto constante).
Como se ha explicado anteriormente, devolver una referencia es diferente de la devoluci´on
normal donde se devuelve un determinado valor temporal. En caso de devolver una referencia,
se devuelve el propio objeto y se le puede aplicar un m´etodo directamente, o incluso, en caso
de
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 8 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

no ser una referencia constante, puede serle asignado un nuevo valor (puede aparecer en la parte
izquierda de una sentencia de asignaci´on).
Ambos m´etodos devuelven una referencia a un elemento, este hecho hace posible que el
resultado de dicho m´etodo pueda aparecer en la parte izquierda de una asignaci´on, por
ejemplo

v1[3] = 5;

adem´as de poder utilizarse para obtener su valor como en

int x = v1[3];

Es importante tener en cuenta que un subprograma o m´etodo no debe devolver una

referencia a un objeto local, ya que su ´ambito desaparece, y en ese caso se devolver´ıa una
referencia a un objeto que no existe.

A Subprogramas y Operadores Amigos

Los subprogramas amigos (friend) son subprogramas y operadores externos a la definici

´on de la clase, es decir, no son m´etodos pertenecientes a la clase. Por lo tanto se utilizan
como subprogramas externos y no se aplican al objeto mediante el operador punto.
Sin embargo, al ser subprogramas amigos, tienen acceso a las definiciones privadas internas
de la clase, tales como su representaci´on interna (atributos miembros), m´etodos privados,
etc., un hecho que no ser´ıa posible en caso de no ser amigos.
Los subprogramas amigos que se definen son para la concatenaci´on de vectores, que
devuelve un nuevo vector resultado de la concatenaci´on de los vectores recibidos como par
´ametros, los operadores relacionales que devuelven un valor l´ogico dependiendo del resultado de
la comparaci´on, y los operadores de entrada y salida. N´otese que los operadores se utilizan
segu´n su notaci´on est´andar. Un posible ejemplo de su utilizaci´on podr´ıa ser:

Vector v1(7);
v1.push_back(5);
Vector v2;
v2 = v1.subvector(3, 2);
Vector v3 = v1 + v2;
if (v1 < v2) {
cout << "Menor" << endl;
}
cout << "Introduzca el contenido de un vector entre llaves:" << endl;
cin >> v1;
cout << "Vector: " << v1 << endl;

Implementaci´on Separada
En este ejemplo, realizaremos la implementaci´on de los m´etodos de la clase Vector en un
fichero independiente, diferenciando claramente los tres niveles de los tipos abstractos de datos
(interfaz, implementaci´on y utilizaci´on). Adem´as, se facilita la ocultaci´on de la
implementaci´on, el proceso de compilaci´on separada, y la distribuci´on del m´odulo de
biblioteca.
Se deber´an definir los m´etodos, operadores y amigos de la clase en el mismo espacio de
nombres donde est´a definida la clase, y el identificador de cada m´etodo y operador debe ser
cualificado con el identificador de la clase a la que corresponde (utilizando el delimitador (::).
No obstante, los subprogramas y operadores amigos no ser´an cualificados, ya que no son
miembros de la clase.
En nuestro ejemplo, la implementaci´on del m´odulo del tipo abstracto de datos Vector
comienza con un espacio de nombres an´onimo donde se definen los subprogramas privados
necesarios para la implementaci´on del m´odulo. Dentro del espacio de nombres umalcc se
definen los m´etodos de la clase Vector. Para ello, cada nombre de m´etodo o operador se
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 9
cualifica con el nombre de la clase a la que pertenece (Vector seguido por el delimitador ::).

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

//-vector.cpp
#include "vector.hpp"
#include <stdexcept>
namespace { // an´onimo. zona privada al m´odulo
inline unsigned minimo(unsigned x, unsigned y)
{
return (x < y) ? x : y ;
}
}
namespace umalcc {
Vector::Vector(const Vector& orig)
: sz(0), v()
{
for (sz = 0; sz < orig.sz; ++sz)
{ v[sz] = orig.v[sz];
}
}
Vector::Vector(const Vector& orig, unsigned inicio, unsigned nelms)
: sz(0), v()
{
if (inicio > orig.sz) {
throw std::out_of_range("Vector::Vector out of range");
}
unsigned n = minimo(nelms, orig.sz - inicio);
for (sz = 0; sz < n; ++sz) {
v[sz] = orig.v[inicio + sz];
}
}
Vector::Vector(unsigned n)
: sz(0), v()
{
if (n > v.size()) {
throw std::length_error("Vector::Vector length error");
}
for (sz = 0; sz < n; ++sz)
{ v[sz] = 0;
}
}
Vector& Vector::operator = (const Vector& orig)
{
if (this != &orig) { // comprobar autoasignaci´on
// destruir el valor antiguo y copiar el nuevo
for (sz = 0; sz < orig.sz; ++sz) {
v[sz] = orig.v[sz];
}
}
return *this;
}
void Vector::push_back(int e) {
if (sz >= v.size()) {
throw std::length_error("Vector::push_back length error");
}
v[sz] = e;
++sz;
}
void Vector::pop_back() {
assert(size() > 0); // Pre-condici´on
--sz;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 11

Vector Vector::subvector(unsigned inicio, unsigned nelms) const

{
return Vector(*this, inicio, nelms);
}
Vector& Vector::operator += (const Vector& vect)
{
if (sz + vect.sz > v.size()) {
throw std::length_error("Vector::operator+= length error");
}
unsigned nelms = vect.sz; // para considerar autoasignaci´on
for (unsigned i = 0; i < nelms; ++i) {
v[sz] = vect.v[i];
++sz;
}
return *this;
}
Vector operator + (const Vector& v1, const Vector& v2)
{
Vector res = v1;
res += v2;
return res;
}
bool operator == (const Vector& v1, const Vector& v2)
{
bool res;
if (v1.sz != v2.sz) {
res = false;
} else {
unsigned i;
for (i = 0; (i < v1.sz)&&(v1.v[i] == v2.v[i]); ++i) {
// vac´ıo
}
res = (i == v1.sz);
}
return res;
}
bool operator < (const Vector& v1, const Vector& v2)
{
unsigned i;
for (i = 0; (i < v1.sz)&&(i < v2.sz)
&&(v1.v[i] == v2.v[i]); ++i) {
// vac´ıo
}
return (((i == v1.sz) && (i < v2.sz))
|| ((i < v1.sz) && (i < v2.sz) && (v1.v[i] < v2.v[i])));
}
std::ostream& operator << (std::ostream& out, const Vector& vect)
{
out << vect.sz << " ";
for (unsigned i = 0; i < vect.sz; ++i)
{ out << vect.v[i] << " ";
}
return out;
}
std::istream& operator >> (std::istream& in, Vector& vect)
{
vect.clear();
unsigned nelms;
in >> nelms;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 12 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

for (unsigned i = 0; (i < nelms)&&(!in.fail()); ++i) {

int x;
in >> x;
if ( ! in.fail() ) {
vect.push_back(x);
}
}
return in;
}
}
//------------------------------------------------------------------------ -

La implementaci´on de los constructores, los m´etodos y los operadores sigue la misma pauta
que lo explicado anteriormente, considerando que cuando se hace referencia a un determinado
atributo o m´etodo, ´estos se refieren (o aplican) a los del propio objeto sobre los que se
aplique el m´etodo en cuesti´on.
Adem´as, en caso de que un objeto de la misma clase se reciba como par´ametro, entonces
es posible acceder a sus atributos e invocar a sus m´etodos mediante el operador punto (.), como
por ejemplo en el constructor de copia de la clase Vector, donde se accede a los atributos sz
y v del objeto recibido como par´ametro (orig) de la siguiente forma: orig.sz y orig.v[...].

Implementaci´on de Constructores
El constructor de copia se define creando un vector vac´ıo en la lista de inicializaci´on, donde
se inicializa cada atributo, segu´ n el orden en que han sido declarados, con el valor adecuado
invocando al constructor especificado.Posteriormente se van asignando los elementos del vector
especificado como par´ametro (orig) al vector que se est ´a construyendo. N´otese que se
accede a los atributos del vector especificado como par´ametro utilizando el operador punto
(orig.sz y orig.v[...]), sin embargo, se accede a los atributos del vector que se est´a creando
especificando u´nicamente sus identificadores (sz y v). Tambi´en se define una un constructor
que copia una parte del contenido de otro vector, en este
caso, la implementaci´on comprueba que los valores especificados son correctos y copia los
elementos especificados del vector orig al vector que se es t ´a construyendo.
En la implementaci´on separada del constructor expl´ıcito no se debe utilizar el especificador
explicit, ya que fue especificada durante la definici´on de la clase. Esta implementaci´on
comprue- ba que los valores especificados como par´ametros son correctos, y an˜ ade al vector
el nu´mero de elementos especificado con el valor cero (0).

Implementaci´on del Operador de Asignaci´on

En la implementaci´on del operador de asignaci´on hay que tener en cuenta las siguientes
con- sideraciones:
1. Hay que comprobar y evitar que se produzca una auto-asignaci´on, ya que si no se evita,
se podr´ıa destruir el objeto antes de copiarlo.
if (this != &orig) { ... }

As´ı, this representa la direcci´on en memoria del objeto que recibe la asignaci´on, y
&orig representa la direcci´on en memoria del objeto que se recibe como par´ametro. Si
ambas di- recciones son diferentes, entonces significa que son variables diferentes y se
puede realizar la asignaci´on.
2. Una vez que se ha comprobado que se es t ´a asignando un objeto diferente, se debe
destruir el valor antiguo del objeto receptor de la asignaci´on. Esta operaci´on a veces no
es necesaria realizarla expl´ıcitamente, ya que el siguiente paso puede realizarla de forma
impl´ıcita.
2
2
N´otese que no es posible invocar expl´ıcitamente al constructor de copia u operador de asignaci´on para un atributo miembro de tipo
array predefinido, sin embargo si es posible hacerlo si es de tipo array de tr1.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 13

En el ejemplo, no es necesario destruir el valor anterior, ya que la asignaci´on de cada

elemento del vector se encargar´a de realizarla individualmente.

3. Se debe copiar el valor nuevo a la representaci´on interna del objeto.

En el ejemplo, se asigna individualmente el valor de cada elemento del vector original al
objeto que recibe la asignaci´on. Esta asignaci´on individual se deber´a encargar de
destruir el valor anterior que tuviese cada elemento.

4. Finalmente, el operador de asignaci´on debe devolver el objeto actual (*this) sobre el

que recae la asignaci´on.

A La siguiente implementaci´on es muy habitual en caso de haber definido un m´etodo eficiente

swap(...) para el intercambio de objetos, ya que realiza la copia y destrucci´on del valor an-
terior invocando expl´ıcitamente al constructor de copia e impl´ıcitamente al destructor de la
clase (cuando se destruye la variable temporal).

Clase& Clase::operator = (const Clase& orig)

{
if (this != &orig) {
Clase(orig).swap(*this);
}
return *this;
}

As´ı, se invoca al constructor de copia (Clase(orig)) para copiar el valor a asignar a una vari-
able temporal, y despu´es se intercambian los valores de esta variable temporal con los del
propio objeto (.swap(*this)). De esta forma el objeto recibir´a la copia de los valores de orig,
y pasa- do sus antiguos valores a la variable temporal. Posteriormente, la variable temporal se
destruye, destruy´endose de esta forma el valor anterior del objeto asignado.

Implementaci´on de M´etodos y Operadores

Tanto los m´etodos push_back() como pop_back() se implementan igual que en el caso del
tipo Stack, pero al estar definidos de forma separada, se deben cualificar con el nombre de la
clase (Vector::).
El m´etodo subvector() devuelve un nuevo vector con el contenido de una parte del vector al
que se aplica el m´etodo. Para realizar su implementaci´on, simplemente se devuelve un nuevo
objeto
construido invocando al constructor explicado anteriormente que copia una parte del objeto actual
(*this).
En la implementaci´on del operador de incremento (+=), primero se comprueba que hay espacio
suficiente para albergar a los nuevos elementos. Posteriormente se an˜aden al final una copia de
los elementos del vector especificado como par´ametro, considerando que en caso de auto
asignaci´on (v += v;), la implementaci´on del m´etodo debe funcionar adecuadamente
an˜adiendo al final una copia de los elementos del propio vector. Finalmente, como en el caso
del operador de asignaci´on, se devuelve una referencia al propio objeto (*this), para poder
encadenar la asignaciones.

Implementaci´on de Subprogramas Amigos

Para implementar los subprogramas y operadores amigos (friend), al no ser funciones miembro
de la clase, no se cualifican con el nombre de la clase, ya que no pertenecen a ella, por lo que se
definen como subprogramas y operadores comunes, pero con la particularidad de que al ser amigos
de una determinada clase, tienen acceso a los miembros privados de los objetos pasados como
par´ametros de dicha clase. Este acceso a los miembros privados de la clase se realiza mediante
el operador punto (.) aplicado a los objetos recibidos como par´ametros de dicha clase.
As´ı, se implementa el operador de concatenaci´on (+) invocando al constructor de copia para
copiar el contenido del primer vector al vector resultado, y posteriormente se invoca al operador

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 14 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

de incremento (+=) para que an˜ada el contenido del segundo vector al vector resultado que ser
´a fi- nalmente devuelto como resultado de la funci´on.
Tambi´en se definen los operadores de comparaci´on de igualdad (==) y menor (<),
realizando una comparaci´on lexicogr´afica de los elementos de ambos vectores recibidos como
par´ametros. Los dem´as operadores relacionales se implementan utilizando ´estos dos operadores
implementados.
Por u´ltimo se implementan los operadores de entrada y salida, de tal forma que
considerando que el nu´mero de elementos del vector es variable, se deben mostrar y leer el nu
´mero de elementos contenidos en el vector, seguido por una secuencia de los elementos del
mismo, separados por espacios. Por ejemplo, si el vector contiene los elementos
{ 1, 2, 3, 4, 5, 6 }

entonces mostrar´a en el flujo de salida los siguientes valores:

6 1 2 3 4 5 6

la entrada de datos realizar´a la operaci´on inversa a la anterior, es decir, leer´a el numero de

elementos del vector, y a continuaci´on leer´a tantos elementos como se haya especificado.
N´otese que al comienzo de la entrada de datos, es necesario inicializar el vector a vac´ıo
mediante la llamada al m´etodo clear(). As´ı mismo, n´otese como estos operadores devuelven
el propio flujo de datos que se recibi´o como par´ametro, y sobre el que se han realizado las
operaciones de entrada y salida, de tal forma que sea posible encadenar en cascada las
invocaciones a estos operadores, como se realiza habitualmente:

A Implementaci´on Alternativa de los Operadores de Entrada y Salida de Datos

Es posible realizar una implementaci´on alternativa (un poco m ´a s complicada) donde la

secuen- cia de longitud indeterminada de elementos que contiene el vector se encuentra
delimitada entre llaves, por ejemplo:
{ 1 2 3 4 5 6 }

//-vector.cpp
namespace umalcc {
// ..........
std::ostream& operator << (std::ostream& out, const Vector& vect)
{
out << "{ ";
for (unsigned i = 0; i < vect.sz; ++i)
{ out << vect.v[i] << " ";
}
out << "}";
return out;
}
std::istream& operator >> (std::istream& in, Vector& vect)
{
char ch = ’\0’;
in >> ch;
if (ch != ’{’) {
in.unget();
in.setstate(std::ios::failbit);
} else if ( ! in.fail() ) {
vect.clear();
in >> ch;
while ((! in.fail()) && (ch != ’}’) ) {
in.unget();
int x;
in >> x;
if ( ! in.fail() ) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 15

vect.push_back(x);
}
in >> ch;
}
}
return in;
}
}
//------------------------------------------------------------------------ -

As´ı, en primer lugar el subprograma de entrada de datos lee un car´acter desde el flujo de
entrada, el cual si no es igual al car´acter ’{’ significa que la entrada de datos es err´onea (no
concuerda con el formato de entrada especificado), por lo que el car´acter previamente le´ıdo se
devuelve al flujo de entrada y el flujo de entrada se pone al estado err´oneo.
std::istream& operator >> (std::istream& in, Vector& vect)
{
char ch = ’\0’;
in >> ch;
if (ch != ’{’) {
in.unget();
in.setstate(std::ios::failbit);

En otro caso, si el car´acter le´ıdo es igual a ’{’ entonces se procede a leer los datos que se
an˜ adir´an al vector. Para ello, se inicializa el vector a vac´ıo mediante la llamada al m´etodo
clear(). Poste- riormente se lee un car´acter desde el flujo de entrada, con el objetivo de poder
detectar el final de los datos de entrada mediante el car´acter ’}’:
} else if ( ! in.fail() ) {
vect.clear();
in >> ch;

Si la lectura fue correcta y distinta del car´acter ’}’ entonces significa que hay datos para leer, por
lo que el car´acter previamente le´ıdo se devuelve al flujo de entrada, y se intenta ahora leer el
dato (un nu´mero entero) desde el flujo de entrada, para an˜adirlo al vector en caso de que se
realice una lectura correcta:
while ((! in.fail()) && (ch != ’}’) ) {
in.unget();
int x;
in >> x;
if ( ! in.fail() ) {
vect.push_back(x);
}

A continuaci´on se vuelve a leer otro car´acter con el objetivo de poder detectar el final de los
datos de entrada mediante el car´acter ’}’, y se vuelve al comienzo del bucle while:
in >> ch;
}

Cuando el car´acter le´ıdo sea igual al car´acter ’}’ entonces se sale del bucle de lectura y los
datos le´ıdos se habr´an an˜adido al vector. En caso de que se haya producido algu´n error
de formato durante la entrada de datos, entonces el flujo de entrada se pondr´a en un estado
err´oneo.
Finalmente, se devuelve el flujo de entrada para que se puedan encadenar en cascada las
invo- caciones a este operador, como se realiza habitualmente:
}
return in;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

16 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

Instancias de Clase: Objetos

El siguiente programa muestra una utilizaci´on del Tipo Abstracto de Datos Vector donde
se comprueba el normal funcionamiento de los objetos declarados de dicho tipo. As´ı, los operadores
se utilizan con la sintaxis esperada, pero las funciones miembro se utilizan a trav´es de la notaci´on
pun- to. Adem´as, vemos tambi´en como se crean los objetos de la clase utilizando diferentes
constructores y diferente sintaxis.
#include "vector.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;
void anyadir(Vector& v, unsigned n)
{
for (unsigned i = 0; i < n; ++i) {
v.push_back(i);
}
}
void eliminar(Vector& v, unsigned i)
{
if (i < v.size()) {
v[i] = v[v.size()-1];
v.pop_back();
}
}
int main()
{
try {
Vector v1;
cout << "Introduzca un vector entre llaves" << endl;
cin >> v1;
cout << "v1: " << v1 << endl;
Vector v2(5);
cout << "v2: " << v2 << endl;
const Vector v3 = v1;
cout << "v3: " << v3 << endl;
Vector v4(v1);
cout << "v4: " << v4 << endl;
Vector v5(v1, 3, 2);
cout << "v5: " << v5 << endl;
anyadir(v5, 4);
cout << "v5: " << v5 << endl;
eliminar(v5, 1);
cout << "v5: " << v5 << endl;

v2 = v1.subvector(3, 2);
cout << "v2: " << v2 << endl;
//v3 = v4; // Error de Compilaci´on

if (3 < v1.size()) {
v1[3] = 9;
cout << "v1: " << v1 << endl;
}
//v3[3] = 9; // Error de Compilaci´on

v5 += v1;
cout << "v5: " << v5 << endl;

Vector v6 = v1 + v2;
cout << "v6: " << v6 << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

13.1. TIPOS ABSTRACTOS DE DATOS EN C++: CLASES 17

cout << (v1 == v1) << endl;

cout << (v1 == v2) << endl;

for (int i = 0; i < 50; ++i)

{ v6 += v6; // hasta
overflow
}
} catch (const length_error& e) {
cout << "Error: " << e.what() << endl;
} catch (const exception& e) {
cout << "Error: " << e.what() << endl;
} catch ( ... ) {
cout << "Error: Inesperado"<< endl;
}
}

13.2. M´etodos Definidos Autom´aticamente por el

Compi- lador
Los siguientes m´etodos pueden ser definidos autom´aticamente por el compilador si el progra-
mador no los define. Por ejemplo, para la siguiente clase:
class X {
public:
// ...
private:
T1 a1; // atributo a1 de tipo T1
T2 a2; // atributo a2 de tipo T2
};

El constructor por defecto (sin par´ametros) ser ´a definido autom´aticamente por el

compilador si el programador no define ningu´n constructor . El comportamiento
predefinido con- sistir´a en la llamada al constructor por defecto para cada atributo
miembro de la clase. En caso de que se invoque expl´ıcitamente, el constructor por defecto
de los tipos predefinidos es la inicializaci´on a cero. Sin embargo, si no se invoca expl
´ıcitamente para los tipos predefinidos, su valor queda inespecificado.
X::X() : a1(), a2() {}

El constructor de copia se definir´a autom´aticamente por el compilador en caso de que

el programador no lo proporcione. El comportamiento predefinido consistir´a en la
llamada al constructor de copia para cada atributo miembro de la clase. El constructor de
copia por defecto de los tipos predefinidos realizar´a una copia byte a byte de un objeto
origen al objeto destino.
X::X(const X& o) : a1(o.a1), a2(o.a2) {}

El operador de asignaci´on s e r´a definido autom´aticamente por el compilador si no es

pro- porcionado por el programador. Su comportamiento predefinido ser´a llamar al
operador de asignaci´on para cada atributo miembro de la clase. El operador de asignaci
´on por defecto de los tipos predefinidos realizar´a una asignaci´on byte a byte de un
objeto origen al objeto destino.
X& X::operator=(const X& o) { a1 = o.a1; a2 = o.a2; return *this; }

El destructor de la clase se definir´a autom´aticamente por el compilador si no es

definido por el programador, y su comportamiento predefinido se r ´a llamar a los
destructores de los atributos miembros de la clase.
~X::X() {}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.3. REQUISITOS DE LAS CLASES RESPECTO A LAS EXCEPCIONES 173

13.3. Requisitos de las Clases Respecto a las Excepciones

Con objeto de disen˜ar clases que se comporten adecuadamente en su ´ambito de utilizaci´on, es
conveniente seguir los siguientes consejos en su disen˜o:

No se deben lanzar excepciones desde los destructores.

Las operaciones de comparaci´on no deben lanzar excepciones.

Cuando se actualiza un objeto, no se debe destruir la representaci´on antigua antes de

haber creado completamente la nueva representaci´on y pueda reemplazar a la antigua sin
riesgo de excepciones.

Antes de lanzar una excepci´on, se deber´a liberar todos los recursos adquiridos que no
pertenez- can a ningu´n otro objeto. (Utilizar la t´ecnica RAII “adquisici´on de recursos es
inicializaci´on” sec. 22.1).

Antes de lanzar una excepci´on, se deber´a asegurar de que cada atributo se encuentra
en un estado “v´alido”. Es decir, dejar cada objeto en un estado en el que pueda ser
destruido por su destructor de forma coherente y sin lanzar ninguna excepci´on.
N´otese que un constructor es un caso especial, ya que cuando lanza una excepci´on no
deja ningu´n objeto “creado” para destruirse posteriormente, por lo que se debe asegurar de
liberar todos los recursos adquiridos durante la construcci´on fallida antes de lanzar la
excepci´on (RAII “adquisici´on de recursos es inicializaci´on”).
Cuando se lanza una excepci´on dentro de un constructor, se ejecutar´an los destructores
aso- ciados a los atributos que hayan sido previamente inicializados al llamar a sus
constructores en la lista de inicializaci´on. Sin embargo, los recursos obtenidos dentro del
cuerpo del con- structor deber´an liberarse expl´ıcitamente en caso de que alguna excepci
´on sea lanzada. (RAII “adquisici´on de recursos es inicializaci´on”).

13.4. M ´a s sobre M´etodos y Atributos A

A Atributos Constantes

Es posible definir atributos miembros constantes (no est´aticos) mediante el cualificador

const. En este caso, el valor del atributo constante toma su valor en el momento de la creaci´on
del objeto, y no var´ıa durante la vida del objeto hasta su destrucci´on. Hay que notar que, en
este caso, estos atributos constantes pueden tener diferentes valores para cada instancia (objeto)
de la clase, a diferencia de las constantes est´aticas, que contienen el mismo valor compartido
para todas las instancias de la clase. En caso de que una clase tenga atributos miembros
constantes, entonces no se le po dr´a aplicar el operador de asignaci´on por defecto.
#include <iostream>
using namespace std;
class X {
public:
X(int v) : valor(v) {}
friend ostream& operator << (ostream& out, const X& x) {
return out << x.valor ;
}
private:
const int valor;
};
int main()
{
X x1(1);
X x2 = 2;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

cout << x1 << " " << x2 << endl;

// x1 = x2; // Error, asignaci´on por defecto no permitida

}

A Atributos Mutables

Es posible, adem´as, definir atributos miembro mutables mediante el cualificador mutable.

Este cualificador significa que el atributo mutable puede ser modificado, incluso aunque
pertenezca a un objeto constante, por medio de un m´etodo u operador constante.
#include <iostream>
using namespace std;
class X {
public:
X(int v) : valor(v) {}
void incremento(int i) const {
valor += i;
}
friend ostream& operator << (ostream& out, const X& x) {
return out << x.valor ;
}
private:
mutable int valor;
};
int main()
{
const X x1(1);
X x2 = 2;
cout << x1 << " " << x2 << endl;
x1.incremento(5);
x2.incremento(7);
cout << x1 << " " << x2 << endl;
}

A Atributos y M´etodos Est´aticos

Tambi´en es posible declarar atributos est´aticos mediante el cualificador static. Este

cualifi- cador significa que el valor de dicho atributo es compartido por todas las instancias
(objetos) de la clase, de tal forma que si un objeto modifica su valor, este nuevo valor s e r´a
compartido por todos los objetos.
Cada objeto que se declare de una determinada clase tendr´a diferentes instancias de los
atributos de la clase, permitiendo as´ı que diferentes objetos de la misma clase tengan atributos
con valores diferentes, pero si algu´n atributo es est´atico, entonces dicho atributo ser´a u´nico
y compartido por todos los objetos de la clase.
Cuando se declara un atributo static, se deber´a definir en el m´odulo de implementaci
´on (cualific´andolo con el nombre de la clase) y asignarle un valor inicial.
Tambi´en es posible definir un m´etodo que sea est´atico, en cuyo caso se podr´a invocar
directa- mente sobre la clase, es decir, no ser´a necesario que se aplique a ningu´n objeto
especifico, y s´olo podr´a acceder a atributos est´aticos (no puede acceder a los atributos que
corresponden a objetos instancias de la clase).

#include <iostream>
using namespace std;
class X {
public:
X(int v) : valor(v) { ++cnt; }
static unsigned cuenta() { // M´etodo est´atico

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 13.4. MA´ S SOBRE ME´ TODOS Y ATRIBUTOS 175

return cnt;
}
friend ostream& operator << (ostream& out, const X& x) {
return out << x.valor ;
}
private:
static unsigned cnt; // Atributo est´atico
int valor;
};
//------------------
unsigned X::cnt = 0; // definici´on e inicializaci´on del atributo est´atico
//------------------
int main()
{
X x1(1);
X x2 = 2;
unsigned num_objs = X::cuenta(); // invocaci´on de m´etodo est´atico
cout << "N´umero de Objetos de Clase X creados: " << num_objs << endl;
cout << x1 << " " << x2 << endl;
}

A Operadores de Incremento y Decremento

Se pueden definir los operadores de incremento y decremento, tanto prefijo, como post-fijo.
#include <iostream>
using namespace std;
class X {
public:
X(int v) : valor(v) {}
X& operator++ () { // Incremento Prefijo
++valor;
return *this;
}
X& operator-- () { // Decremento Prefijo
--valor;
return *this;
}
X operator++ (int) { // Incremento Postfijo
X anterior(*this); // copia del valor anterior
++valor;
return anterior; // devoluci´on del valor anterior
}
X operator-- (int) { // Decremento Postfijo
X anterior(*this); // copia del valor anterior
--valor;
return anterior; // devoluci´on del valor anterior
}
friend ostream& operator << (ostream& out, const X& x) {
return out << x.valor ;
}
private:
int valor;
};
int main()
{
X x1 = 1;
++x1;
x1++;
cout << x1 << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

--x1;
x1--;
cout << x1 << endl;
}

A Conversiones de Tipo

Es posible definir conversiones de tipo impl´ıcitas para un determinado objeto de una clase.
El tipo destino puede ser cualquier tipo, ya sea predefinido o definido por el usuario. Por
ejemplo, se puede definir una conversi´on directa e impl´ıcita de un objeto de la clase X definida
a continuaci´on a un tipo entero.
#include <iostream>
using namespace std;
class X {
public:
X(int v) : valor(v) {} // constructor
operator int () const { // operador de conversi´on a int
return valor;
}
private:
int valor;
};
int main()
{
const X x1(1); // invocaci´on expl´ıcita al constructor
X x2 = 2; // invocaci´on impl´ıcita al constructor
cout << x1 << " " << x2 << endl; // invocaci´on impl´ıcita al op de conversi´on
int z1 = x1; // invocaci´on impl´ıcita al op de conversi´on
int z2 = int(x2); // invocaci´on expl´ıcita al op de conversi´on
cout << z1 << " " << z2 << endl;
X x3 = x1 + x2; // inv. impl. al op de conversi´on y constructor
cout << x3 << endl; // invocaci´on impl´ıcita al op de conversi´on
}

En este ejemplo se aprecia como los valores de x1 y x2 se convierten tanto impl´ıcitamente como
expl´ıcitamente a valores enteros al mostrarlos por pantalla, y tambi´en al asignarlos a variables
de tipo entero (z1 y z2). Adem´as, tambi´en hay una conversi´on impl´ıcita cuando se suman los
valores de x1 y x2, y posteriormente el resultado de tipo int se convierte y asigna a un objeto de
clase X mediante el constructor que recibe un entero como par´ametro.
As´ı, se puede apreciar que los m´etodos de conversi´on de tipos permiten definir la conversi
´on impl´ıcita de un determinado tipo abstracto de datos a otro determinado tipo especificado
por el operador de conversi´on correspondiente. Adem´as, Los constructores tambi´en ofrecen
otro tipo de conversi´on impl´ıcita (o expl´ıcita si se define mediante el especificador explicit)
desde valores de otros tipos al tipo abstracto de datos para el que se define el constructor.
Por lo tanto, en el caso del ejemplo anterior, el constructor X(int v) ofrece una conversi´on
impl´ıcita de un valor de tipo int a un objeto de tipo X. As´ı mismo, el operador de conversi´on
operator int () ofrece una conversi´on impl´ıcita de un objeto de tipo X a un valor de tipo int.
Sin embargo, si el constructor de la clase X se define como explicit, entonces es necesario
invocarlo expl´ıcitamente para realizar la conversi´on de tipo int al tipo X, por ejemplo:
#include <iostream>
using namespace std;
class X {
public:
explicit X(int v) : valor(v) {} // constructor expl´ıcito
operator int () const { // operador de conversi´on a int
return valor;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

13.5. SOBRECARGA DE OPERADORES 177

private
int valor;
};
int main()
{
const X x1(1); // invocaci´on expl´ıcita al constructor
X x2(2); // invocaci´on expl´ıcita al constructor
cout << x1 << " " << x2 << endl; // invocaci´on impl´ıcita al op de conversi´on
int z1 = x1; // invocaci´on impl´ıcita al op de conversi´on
int z2 = int(x2); // invocaci´on expl´ıcita al op de conversi´on
cout << z1 << " " << z2 << endl;
X x3 = X(x1 + x2); // inv. impl. al op de conv. y expl. al ctor
cout << x3 << endl; // invocaci´on impl´ıcita al op de conversi´on
}

13.5. Sobrecarga de Operadores A

El lenguaje de programaci´on C++ permite sobrecargar los operadores para tipos definidos por
el programador. Sin embargo, no es posible definir nuevos operadores ni cambiar la sintaxis, la
aridad, la precedencia o la asociatividad de los operadores existentes. Se puede definir el
comportamiento de los siguientes operadores para tipos definidos por el programador:
Operadores Aridad Asociatividad
() [] -> ->* binario izq. a dch.
++ -- tipo() unario dch. a izq.
! ~ + - * & unario dch. a izq.
* / % binario izq. a dch.
+ - binario izq. a dch.
<< >> binario izq. a dch.
< <= > >= binario izq. a dch.
== != binario izq. a dch.
& binario izq. a dch.
^ binario izq. a dch.
| binario izq. a dch.
&& binario izq. a dch.
|| binario izq. a dch.
= += -= *= /= %= &= ^= |= <<= >>= binario dch. a izq.
, binario izq. a dch.
new new[] delete delete[] unario izq. a dch.

Sin embargo, los siguientes operadores no podr´an ser definidos:

:: . .* ?: sizeof typeid

Los siguientes operadores ya tienen un significado predefinido para cualquier tipo que se defina,
aunque pueden ser redefinidos:
operator= operator& operator,

La conversi´on de tipos y los siguientes operadores s´olo podr´an definirse como funciones
miembros de objetos:
operator= operator[] operator() operator->

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 13. TIPOS ABSTRACTOS DE DATOS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 14

Introduccio´n a la Programaci´on Gen

´erica. Plantillas

El lenguaje de programaci´on C++ proporciona soporte a la programaci´on gen´erica

mediante las plantillas (“templates” en ingl´es). Las plantillas proporcionan un mecanismo eficaz
para definir c´odigo (constantes, tipos y subprogramas) gen´ericos parametrizados, que puedan ser
instanciados en “tiempo de compilaci´on”. Estos par´ametros gen´ericos de las plantillas podr´an
ser instanciados con tipos y valores constantes concretos especificados en tiempo de compilaci
´on.
Las definiciones gen´ericas deber´an, por lo general, estar visibles en el lugar donde sean
instanci- adas, por lo que en el caso de definirse en m´odulos diferentes, deber´an estar definidas
en los ficheros de encabezamiento, para que puedan ser incluidas por todos aquellos m´odulos
que las necesiten.
La definici´on de plantillas, tanto de subprogramas como de tipos comienza con la palabra reser-
vada template, seguida entre delimitadores < ... > por los par´ametros gen´ericos de la definici
´on. Estos par´ametros gen´ericos pueden ser tanto tipos (precedidos por la palabra reservada
typename), como constantes de tipos integrales (char, short, int, unsigned, long) o de tipos gen
´ericos parametrizados con anterioridad (que deben ser instanciados a tipos integrales).

14.1. Subprogramas Gen´ericos

Los subprogramas gen´ericos son u´tiles cuando definen procesamientos gen´ericos que son
inde- pendientes de los tipos concretos sobre los que se aplican. Veamos algunos ejemplos de
definici´on de subprogramas gen´ericos:
template <typename Tipo>
inline Tipo maximo(const Tipo& x, const Tipo& y)
{
return (x > y) ? x : y ;
}
template <typename Tipo>
void intercambio(Tipo& x, Tipo& y)
{
Tipo aux = x;
x = y;
y = aux;
}
int main()
{
int x = 4;
int y = maximo(x, 8);
intercambio(x, y);

double a = 7.5;

179
14.2. TIPOS ABSTRACTOS DE DATOS GENE 1
´ RICOS
double b = maximo(a, 12.0);
intercambio(a, b);

double c = maximo(a, 12); // Error: maximo(double, int) no esta definido

}

En el ejemplo se puede ver que los par´ametros de entrada a los subprogramas se pasan por
referencia constante, ya que al ser un tipo gen´erico podr´ıa ser tanto un tipo simple como un tipo
estructurado. Tambi´en puede apreciarse que la instanciaci´on de subprogramas gen´ericos a tipos
concretos se realiza autom´aticamente a partir de la invocaci´on a los mismos, de tal forma que la
instanciaci´on de los par´ametros gen´ericos se realiza por deducci´on a partir del tipo de los par
´ametros especificados
en la invocaci´on a los subprogramas.
Sin embargo, hay situaciones donde los par´ametros gen´ericos no pueden ser deducidos de
la propia invocaci´on al subprograma. En este caso, los par´ametros gen´ericos involucrados
deben ser especificados expl´ıcitamente en la llamada. Nota: el siguiente ejemplo se proporciona
para ilustrar esta caracter´ıstica, aunque no debe ser tomado como ejemplo de disen˜o, ya que
este ejemplo en concreto carece de utilidad pr´actica.
template <typename TipoDestino, typename TipoOrigen>
inline TipoDestino convertir(const TipoOrigen& x)
{
return TipoDestino(x);
}
int main()
{
int x = convertir<int>(3.14);
}

El siguiente ejemplo de subprograma gen´erico muestra la utilizaci´on de par´ametros gen

´ericos constantes (de tipo integral), y es u´ til para buscar elementos en un array gen´erico. N
´otese que el tipo del elemento a buscar puede ser diferente del tipo base del array siempre y cuando
est´e definido el operador de comparaci´on (!=).
#include <iostream>
#include <tr1/array>
using namespace std;
using namespace std::tr1;
//-------------------------------------
template <typename TipoBusc, typename TipoBase, unsigned SIZE>
unsigned buscar(const TipoBusc& x, const array<TipoBase, SIZE>& v)
{
unsigned i = 0;
while ((i < v.size())&&(x != v[i])) {
++i;
}
return i;
}
//-------------------------------------
typedef array<int, 5> AInt;
void prueba1()
{
AInt a = {{ 1, 2, 3, 4, 5 }};
unsigned i = buscar(4, a);
cout << i << endl;
}
//-------------------------------------
struct Persona
{ string nombre;
string telefono;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 2 CAP´ITULO 14. INTRODUCCIO´ N A LA PROGRAMACIO´ N GENE´ RICA. PLANTILLAS

};
inline bool operator!=(const string& n, const Persona& p)
{
return n != p.nombre;
}
typedef array<Persona, 5> APers;
void prueba2()
{
APers a = {{ { "pepe", "111" }, { "juan", "222" }, { "mar´ıa", "333" },
{ "marta", "444" }, { "lucas", "555" }
}};
unsigned i = buscar("mar´ıa", a);
cout << i << endl;
}
//-------------------------------------

Errores de Instanciaci´on de Par´ametros Gen´ericos

En el caso de que la definici´on de un determinado subprograma sea incorrecta para una
deter- minada instanciaci´on concreta de los par´ametros gen´ericos, se producir´a un error de
compilaci´on indicando el tipo de error. Por ejemplo, el siguiente c´odigo produce un error de
compilaci´on, ya que el tipo Persona no tiene definido el operador de comparaci´on (>).
#include <string>
using namespace std;
struct Persona {
string nombre;
string telefono;
};
template <typename Tipo>
inline Tipo maximo(const Tipo& x, const Tipo& y)
{
return (x > y) ? x : y ;
}
int main()
{
Persona p1 = { "pepe", "1111" };
Persona p2 = { "juan", "2222" };
Persona p3 = maximo(p1, p2);
}

Produce el siguiente mensaje de error de compilaci´on (con GNU GCC ):

main.cpp: In function ’Tipo maximo(const Tipo&, const Tipo&) [with Tipo = Persona]’:
main.cpp:16: instantiated from here
main.cpp:10: error: no match for ’operator>’ in ’x > y’

Cuando se trabaja con plantillas en C++, hay que tener presente que, a veces, los mensajes de
error pueden ser bastante complicados de interpretar en el caso de errores producidos por
instanciaciones de par´ametros gen´ericos.

14.2. Tipos Abstractos de Datos Gen´ericos

Las plantillas tambi´en pueden ser utilizadas para la definici´on de tipos gen´ericos, tanto
registros como clases gen´ericas. No obstante, a diferencia de los subprogramas gen´ericos que son
capaces de instanciar los par´ametros gen´ericos a partir de la invocaci´on al subprograma, en
el caso de tipos gen´ericos ser´a necesaria la instanciaci´on expl´ıcita de los par´ametros de los
mismos.
Como se explic´o al comienzo del cap´ıtulo, las definiciones gen´ericas deben, por lo general,
estar visibles en el lugar donde sean instanciadas, y por lo tanto, en el caso de tipos abstractos
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
14.2. TIPOS ABSTRACTOS DE DATOS GENE 3
´ RICOS
gen´ericos

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 14. INTRODUCCIO´ N A LA PROGRAMACIO´ N GENE´ RICA. PLANTILLAS

tanto la definici´on como la implementaci´on se realizar´a en ficheros de encabezamiento. Adem

´as, en esta secci´on introductoria a la programaci´on gen´erica s´olo veremos los tipos
abstractos de datos gen´ericos definidos e implementados “en l´ınea”, y en su versi´on m´as
simple.
Veamos un ejemplo de definici´on e implementaci´on de un tipo Vector gen´erico, como un
con- tenedor de elementos donde ´estos se pueden an˜adir hasta un determinado l´ımite. En este
ejemplo, se ha simplificado la definici´on e implementaci´on del tipo vector con respecto a la
definici´on del cap´ıtulo anterior, para hacer m ´a s f´acil la comprensi´on de los conceptos
relativos a la programaci´on
gen´erica. As´ı, se utilizan el constructor de copia, el operador de asignaci´on y el destructor de
la clase generados autom´aticamente por el compilador.

//-vector.hpp
#ifndef _vector_hpp_
#define _vector_hpp_
#include <tr1/array>
#include <cassert>
#include <stdexcept>
namespace umalcc {
template <typename Tipo, unsigned SIZE>
class Vector {
public:
Vector() : sz(0), v() {}
unsigned size() const {
return sz;
}
void clear()
{ sz = 0;
}
void push_back(const Tipo& e) {
if (sz >= v.size()) {
throw std::runtime_error("Vector::push_back");
}
v[sz] = e;
++sz;
}
void pop_back() {
assert(size() > 0); // Pre-condici´on
--sz;
}
const Tipo& operator [] (unsigned i) const {
assert(i < size()); // Pre-condici´on
return v[i];
}
Tipo& operator [] (unsigned i)
{ assert(i < size()); // Pre-condici
´on return v[i];
}
friend std::ostream& operator << (std::ostream& out, const Vector& vect)
{ out << vect.sz << " ";
for (unsigned i = 0; i < vect.sz; ++i)
{ out << vect.v[i] << " ";
}
return out;
}
friend std::istream& operator >> (std::istream& in, Vector& vect)
{
vect.clear();
unsigned nelms;
in >> nelms;
for (unsigned i = 0; (i < nelms)&&(!in.fail()); ++i) {
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
14.2. TIPOS ABSTRACTOS DE DATOS GENE 5
´ RICOS
Tipo x;
in >> x;
if ( ! in.fail() ) {
vect.push_back(x);
}
}
return in;
}
private:
typedef std::tr1::array<Tipo, SIZE> Datos;
// -- Atributos --
unsigned sz;
Datos v;
};
}
#endif

As´ı, se puede utilizar el vector definido anteriormente como base para implementar un tipo
Stack. En este caso, se utilizan los constructores por defecto y de copia, as´ı como el operador de
asignaci´on y el destructor de la clase generados autom´aticamente por el compilador. En el
ejemplo puede apreciarse como se realiza una instanciaci´on expl´ıcita de un tipo gen´erico para
la definici´on del atributo v.
//-stack.hpp
#ifndef _stack_hpp_
#define _stack_hpp_
#include <cassert>
#include "vector.hpp"
namespace umalcc {
template <typename Tipo, unsigned SIZE>
class Stack {
public:
bool empty() const
{ return v.size() == 0;
}
void clear()
{ v.clear();
}
void push(const Tipo& e) {
v.push_back(e);
}
void pop(Tipo& e) {
assert(size() > 0); // Pre-condici´on
e = v[v.size() - 1];
v.pop_back();
}
private:
// -- Atributos --
Vector<Tipo, SIZE> v;
};
}
#endif

Ambos tipos abstractos de datos gen´ericos se pueden utilizar de la siguiente forma, donde se
definen dos tipos (Vect y Pila) como instanciaciones expl´ıcitas de los tipos gen´ericos
previamente definidos.
#include <iostream>
#include "vector.hpp"
#include "stack.hpp"

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 6 CAP´ITULO 14. INTRODUCCIO´ N A LA PROGRAMACIO´ N GENE´ RICA. PLANTILLAS

using namespace std;

using namespace umalcc;

typedef Vector<double, 30> Vect;

typedef Stack<int, 20> Pila;

void almacenar_datos(Pila& s, unsigned n)

{
for (int x = 0; x < n; ++x) {
s.push(x);
}
}
void imprimir(Pila& s)
{
while (! s.empty() ) {
int x;
s.pop(x);
cout << x << " ";
}
cout << endl;
}

void anyadir(Vect& v, unsigned n)

{
for (unsigned i = 0; i < n; ++i) {
v.push_back(i);
}
}
void eliminar(Vect& v, unsigned i)
{
if (i < v.size()) {
v[i] = v[v.size()-1];
v.pop_back();
}
}

int main()
{
try {
Pila s;
almacenar_datos(s, 10);
imprimir(s);

Vect v;
anyadir(v, 4);
eliminar(v, 1);
} catch (const length_error& e) {
cout << "Error: " << e.what() << endl;
} catch ( ... ) {
cout << "Error: Inesperado"<< endl;
}
}

14.3. Par´ametros Gen´ericos por Defecto A

Es posible especificar instanciaciones por defecto para los par´ametros gen´ericos en la definici
´on de tipos gen´ericos. Estos par´ametros con valores por defecto deben ser los u´ltimos de
la lista de par´ametros gen´ericos. Por ejemplo:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

14.4. DEFINICIO´ N DE TIPOS DENTRO DE LA DEFINICIO´ N DE TIPOS GENE´ RICOS 185

template <typename T, typename C = vector<T> >

class Stack {
// ...
};

template <typename T, unsigned SIZE=512>

class Array {
// ...
};

typedef Stack<int, list> SInt; // instancia el segundo par´ametro a list<int>

typedef Stack<int> StckInt; // instancia el segundo par´ametro a vector<int>

typedef Array<int, 126> AInt; // instancia el segundo par´ametro a 126

typedef Array<int> ArrayInt; // instancia el segundo par´ametro a 512

14.4. Definici´on de Tipos dentro de la Definici´on de

Tipos Gen´ericos A
Si en algu´ n ´ambito se utiliza un determinado tipo cuya especificaci´on depende de un
tipo gen´erico no instanciado, entonces ser´a necesario cualificar la utilizaci´on de dicho tipo con la
palabra reservada typename. As´ı mismo, para utilizar desde un ´ambito externo un tipo definido
dento de una clase (o estructura), dicho tipo deber´a cualificarse con el nombre de la clase (o
estructura) a la que pertenece. Por ejemplo:
//----------------------------------------------------------------- -
#include <iostream>
using namespace std;
//---------------------------------
struct A {
typedef int Tipo;
};
//---------------------------------
template <typename TT>
struct B {
typedef int Tipo;
typedef TT Base;
};
//---------------------------------
template <typename TT>
void prueba1()
{
A::Tipo x = 3;
typename B<TT>::Tipo z = 5;
typename B<TT>::Base y = 4;
cout << x << " " << y << " " << z << endl;
}
//---------------------------------
void prueba2()
{
A::Tipo x = 3;
B<int>::Tipo z = 5;
B<int>::Base y = 4;
cout << x << " " << y << " " << z << endl;
}
//---------------------------------
int main()
{

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 14.5. SEPARACIO´ N DE DEFINICIO´ N E IMPLEMENTACIO 1
´N
prueba1<int>();
prueba2();
}
//----------------------------------------------------------------- -

14.5. Separacio´n de Definici´on e Implementaci´on A

Tambi´en es posible hacer la definici´on e implementaci´on del tipo abstracto de datos gen
´erico “fuera de l´ınea”, de tal forma que por una parte se realiza la definici´on del tipos, y por
otra parte se realiza la implementaci´on del mismo. No obstante, hay que tener en cuenta que
ambas partes deben ser visibles para poder instanciar el tipo y utilizar sus m´etodos, por lo que
ambas partes residir´an en el mismo fichero de encabezamiento.
Por ejemplo, es posible definir la clase Vector y su implementaci´on de forma separada como
se indica a continuaci´on:

//-vector.hpp
#ifndef _vector_hpp_
#define _vector_hpp_
#include <iostream>
#include <tr1/array>
#include <cassert>
#include <stdexcept>
namespace umalcc {
//-----------------------------
// Declaraci´on adelantada de la clase Vector
template <typename Tipo, unsigned SIZE>
class Vector;
//-----------------------------
// Prototipo del operador de entrada y salida para la clase Vector
template <typename Tipo, unsigned SIZE>
std::ostream& operator <<(std::ostream&, const Vector<Tipo,SIZE>&);
template <typename Tipo, unsigned SIZE>
std::istream& operator >>(std::istream&, Vector<Tipo,SIZE>&);
//-----------------------------
template <typename Tipo, unsigned SIZE>
class Vector {
public:
Vector() ;
unsigned size() const ;
void clear() ;
void push_back(const Tipo& e) ;
void pop_back() ;
const Tipo& operator [] (unsigned i) const ;
Tipo& operator [] (unsigned i) ;
friend std::ostream& operator << <>(std::ostream&, const Vector<Tipo,SIZE>&);
friend std::istream& operator >> <>(std::istream&, Vector<Tipo,SIZE>&);
private:
typedef std::tr1::array<Tipo, SIZE> Datos;
// -- Atributos --
unsigned sz;
Datos v;
};
//-----------------------------
template <typename Tipo, unsigned SIZE>
Vector<Tipo,SIZE>::Vector()
: sz(0), v()
{}
//-----------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 14. INTRODUCCIO´ N A LA PROGRAMACIO´ N GENE´ RICA. PLANTILLAS

template <typename Tipo, unsigned SIZE>

unsigned Vector<Tipo,SIZE>::size() const {
return sz;
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
void Vector<Tipo,SIZE>::clear() {
sz = 0;
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
void Vector<Tipo,SIZE>::push_back(const Tipo& e) {
if (sz >= v.size()) {
throw std::runtime_error("Vector::push_back");
}
v[sz] = e;
++sz;
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
void Vector<Tipo,SIZE>::pop_back() {
assert(size() > 0); // Pre-condici´on
--sz;
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
const Tipo& Vector<Tipo,SIZE>::operator [] (unsigned i) const {
assert(i < size()); // Pre-condici´on
return v[i];
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
Tipo& Vector<Tipo,SIZE>::operator [] (unsigned i) {
assert(i < size()); // Pre-condici´on
return v[i];
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
std::ostream& operator << (std::ostream& out, const Vector<Tipo,SIZE>& vect)
{ out << vect.sz << " ";
for (unsigned i = 0; i < vect.sz; ++i)
{ out << vect.v[i] << " ";
}
return out;
}
//-----------------------------
template <typename Tipo, unsigned SIZE>
std::istream& operator >> (std::istream& out, Vector<Tipo,SIZE>& vect) {
vect.clear();
unsigned nelms;
in >> nelms;
for (unsigned i = 0; (i < nelms)&&(!in.fail()); ++i)
{ Tipo x;
in >> x;
if ( ! in.fail() ) {
vect.push_back(x);
}
}
return in;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

14.5. SEPARACIO´ N DE DEFINICIO´ N E IMPLEMENTACIO 3
´N
}
//-----------------------------
}
#endif

Por ejemplo, para definir e implementar un tipo Subrango de otro tipo b´asico integral, de tal
forma que si se asigna un valor incorrecto fuera del rango especificado, se lance una excepci
´on. En este ejemplo, el compilador genera autom´aticamente el constructor de copia, el
operador de asignaci´on y el destructor de la clase.
//-fichero: subrango.hpp
#include <iostream>
#include <stdexcept>
namespace umalcc {
// Declaraci´on adelantada de la clase Subrango
template<typename Tipo, Tipo menor, Tipo mayor>
class Subrango;

// Prototipo del operador de entrada y salida para la clase Subrango

template<typename Tipo, Tipo menor, Tipo mayor>
std::ostream& operator <<(std::ostream&, const Subrango<Tipo, menor, mayor>&);
template<typename Tipo, Tipo menor, Tipo mayor>
std::istream& operator >>(std::istream&, Subrango<Tipo, menor, mayor>&);

template<typename Tipo, Tipo menor, Tipo mayor>

class Subrango {
public:
Subrango();
Subrango(const T_Base& i);
operator T_Base();
friend std::ostream& operator << <>(std::ostream&, const Subrango<Tipo, menor, mayor>&);
friend std::istream& operator >> <>(std::istream&, Subrango<Tipo, menor, mayor>&);
private:
typedef Tipo T_Base;
// -- Atributos --
T_Base valor;
};

template<typename Tipo, Tipo menor, Tipo mayor>

std::ostream& operator <<(std::ostream& sal,const Subrango<Tipo,menor,mayor>& i)
{
return sal << i.valor;
}

template<typename Tipo, Tipo menor, Tipo mayor>

std::istream& operator >>(std::istream& in, Subrango<Tipo,menor,mayor>& i)
{
Tipo val;
in >> val;
i = val;
return in;
}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::Subrango()
: valor(menor)
{}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::Subrango(const T_Base& i)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 14. INTRODUCCIO´ N A LA PROGRAMACIO´ N GENE´ RICA. PLANTILLAS

: valor(i)
{
if ((valor < menor) || (valor > mayor)) {
throw std::range_error("Subrango::Subrango range error");
}
}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::operator Tipo()
{
return valor;
}
}
//-fin: subrango.hpp

Una posible utilizaci´on del tipo Subrango podr´ıa ser:

//-fichero: main.cpp
#include "subrango.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;

typedef Subrango<int, 3, 20> Dato;

int main()
{
try {
Dato x, z;
Subrango<char, ’a’, ’z’> y;

x = 17;
x = 25; // fuera de rango

y = ’m’;
y = ’M’; // fuera de rango

z = x;
x = x + 5; // fuera de rango

cout << x << " " << y << " " << z << endl;

} catch (const std::range_error& e) {

cerr << "Error: " << e.what() << endl;
} catch ( ... ) {
cerr << "Excepci´on inesperada" << endl;
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

14.5. SEPARACIO´ N DE DEFINICIO´ N E IMPLEMENTACIO 5
´N

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 15

Memoria Din´amica. Punteros

Hasta ahora, todos los programas que se han visto en cap´ıtulos anteriores almacenan su
esta- do interno por medio de variables que son autom´aticamente gestionadas por el
compilador. Las variables son creadas cuando el flujo de ejecuci´on entra en el ´ambito de su
definici´on (se reserva espacio en memoria y se crea el valor de su estado inicial), posteriormente se
manipula el estado de la variable (accediendo o modificando su valor almacenado), y finalmente
se destruye la variable cuando el flujo de ejecuci´on sale del ´ambito donde fue declarada la
variable (liberando los recursos asociados a ella y la zona de memoria utilizada). A este tipo de
variables gestionadas autom´atica- mente por el compilador se las suele denominar variables
autom´aticas (tambi´en variables locales), y residen en una zona de memoria gestionada autom
´aticamente por el compilador, la pila de eje- cuci´on, donde se alojan y desalojan las variables
locales (autom´aticas) pertenecientes al ´ambito de ejecuci´on de cada subprograma.
As´ı, el tiempo de vida de una determinada variable e st´a condicionado por el ´ambito de
su declaraci´on. Adem´as, el nu´mero de variables autom´aticas utilizadas en un determinado
programa es t ´a especificado expl´ıcitamente en el propio programa, y por lo tanto su capacidad
de almace- namiento es t ´a tambi´en especificada y predeterminada por lo especificado expl
´ıcitamente en el pro- grama. Es decir, con la utilizaci´on u´ nica de variables autom´aticas, la
capacidad de almacenamiento de un determinado programa es t ´a predeterminada desde el
momento de su programaci´on (tiempo de compilaci´on), y no puede adaptarse a las necesidades
reales de almacenamiento surgidas durante la ejecuci´on del programa (tiempo de ejecuci´on).La
gesti´on de memoria din´amica surge como un mecanismo para que el propio programa, du-
rante su ejecuci´on (tiempo de ejecuci´on), pueda solicitar (alojar) y liberar (desalojar)
memoria segu´ n las necesidades surgidas durante una determinada ejecuci´on, dependiendo de
las circunstan- cias reales de cada momento de la ejecuci´on del programa en un determinado
entorno. Esta ventaja adicional viene acompan˜ada por un determinado coste asociado a la mayor
complejidad que requiere su gesti´on, ya que en el caso de las variables autom´aticas, es el
propio compilador el encargado de su gesti´on, sin embargo en el caso de las variables din
´amicas es el propio programador el que debe, mediante c´odigo software, gestionar el tiempo
de vida de cada variable din´amica, cuando debe ser alojada y creada, como s e r´a utilizada, y
finalmente cuando debe ser destruida y desalojada. Adicionalmente, como parte de esta gesti´on
de la memoria din´amica por el propio programador, la memoria din´amica pasa a ser un
recurso que debe gestionar el programador, y se debe preocupar de su alojo y de su liberaci´on,
poniendo especial cuidado y ´enfasis en no perder recursos (perder zonas de memoria sin
liberar y sin capacidad de acceso).

1
1
En realidad esto no es completamente cierto, ya que en el caso de subprogramas recursivos, cada invocaci´on recursiva en tiempo de ejecuci´on
tiene la capacidad de alojar nuevas variables que ser´an posteriormente desalojadas autom´aticamente cuando la llamada recursiva finaliza.

191
 1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
15.1. Punteros
El tipo puntero es un tipo simple que permite a un determinado programa acceder a posi-
ciones concretas de memoria, y m ´a s espec´ıficamente a determinadas zonas de la memoria din
´ami- ca. Aunque el lenguaje de programaci´on C++ permite otras utilizaciones m ´a s
diversas del tipo puntero, en este cap´ıtulo s´olo se utilizar´a el tipo puntero para acceder a zonas
de memoria din´amica. As´ı, una determinada variable de tipo puntero apunta (o referencia) a
una determinada entidad (variable) de un determinado tipo alojada en la zona de memoria din
´amica. Por lo tanto, para un determinado tipo puntero, se debe especificar tambi´en el tipo de la
variable (en memoria din´amica) a la que apunta, el cual define el espacio que ocupa en memoria
y las operaciones (y m´etodos) que
se le pueden aplicar, entre otras cosas.
De este modo, cuando un programa gestiona la memoria din´amica a trav´es de punteros,
debe manejar y gestionar por una parte la propia variable de tipo puntero, y por otra parte la
variable din´amica apuntada por ´este.
Un tipo puntero se define utilizando la palabra reservada typedef seguida del tipo de la
variable din´amica apuntada, un asterisco para indicar que es un puntero a una variable de
dicho tipo, y el identificador que denomina al tipo. Por ejemplo:
typedef int* PInt;

struct Persona
{ string nombre;
string telefono;
unsigned edad;
};
typedef Persona* PPersona;

As´ı, el tipo PInt es el tipo de una variable que apunta a una variable din´amica de tipo int. Del
mismo modo, el tipo PPersona es el tipo de una variable que apunta a una variable din´amica
de tipo Persona.
Es posible definir variables de los tipos especificados anteriormente. N´otese que estas variables
(p1 y p2 en el siguiente ejemplo) son variables autom´aticas (gestionadas autom´aticamente
por el compilador), es decir, se crean autom´aticamente al entrar el flujo de ejecuci´on en el
´ambito de visibilidad de la variable, y posteriormente se destruyen autom´aticamente cuando
el flujo de ejecuci´on sale del ´ambito de visibilidad de la variable. Por otra parte, las variables
apuntadas por ellos son variables din´amicas (gestionadas por el programador), es decir el
programador se
encargar´a de solicitar la memoria din´amica cuando sea necesaria y de liberarla cuando ya
no sea necesaria, durante la ejecuci´on del programa. En el siguiente ejemplo, si las variables se
definen sin inicializar, entonces tendr´an un valor inicial inespecificado:
int main()
{
p1: ?
PInt p1;
PPersona p2; p2: ?
}
La constante NULL es una constante especial de tipo puntero que indica que una determinada
variable de tipo puntero no apunta a nada, es decir, especifica que la variable de tipo puntero
que contenga el valor NULL no apunta a ninguna zona de la memoria din´amica. As´ı, se pueden
definir las variables p1 y p2 e inicializarlas a un valor indicando que no apuntan a nada.
int main()
{
p1:
PInt p1 = NULL;
PPersona p2 = NULL; p2:
}
A Alternativamente, tambi´en es posible declarar directamente las variables de tipo puntero sin necesi-
dad de definir expl´ıcitamente un tipo puntero:
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 15.2. GESTIO´ N DE MEMORIA DINA´ MICA 193

int main()
{
int* p1 = NULL;
Persona* p2 = NULL;
}

15.2. Gestio´n de Memoria Din´amica

La memoria din´amica la debe gestionar el propio programador, por lo que cuando necesite
crear una determinada variable din´amica, debe solicitar memoria din´amica con el operador new
seguido por el tipo de la variable din´amica a crear. Este operador realiza dos acciones
principales, primero aloja (reserva) espacio en memoria din´amica para albergar a la variable, y
despu´es crea (invocando al constructor especificado) el contenido de la variable din´amica.
Finalmente, a la variable ptr se le asigna el valor del puntero (una direcci´on de memoria) que
apunta a la variable din´amica creada por el operador new. Por ejemplo, para crear una variable
din´amica del tipo Persona definido anteriormente utilizando el constructor por defecto de
dicho tipo.

int main()
{ ◦
ptr: −→
???
PPersona ptr = new Persona;
}

En caso de que el tipo de la variable din´amica tenga otros constructores definidos, es posible
utilizarlos en la construcci´on del objeto en memoria din´amica. Por ejemplo, suponiendo que el
tipo Persona tuviese un constructor que reciba el nombre, tel´efono y edad de la persona:

int main() pepe 111

{ ◦
ptr: −→ 5
PPersona ptr = new Persona("pepe", "111", 5);
}

Posteriormente, tras manipular adecuadamente, segu´ n las caracter´ısticas del programa, la

memoria din´amica alojada, llegar´a un momento en que dicha variable din´amica ya no sea
necesaria, y su tiempo de vida llegue a su fin. En este caso, el programador debe liberar expl
´ıcitamente dicha variable din´amica mediante el operador delete de la siguiente forma:

int main() pepe 111

◦
ptr: −→ 5
{
PPersona ptr = new Persona("pepe", "111", 5);

// manipulaci´on ptr:
X
?

delete ptr;
}

La sentencia delete ptr realiza dos acciones principales, primero destruye la variable din´amica
(invocando a su destructor), y despu´es desaloja (libera) la memoria din´amica reservada para dicha
variable. Finalmente la variable local ptr queda con un valor inespecificado, y s er´a destruida
autom´aticamente por el compilador cuando el flujo de ejecuci´on salga de su ´ambito de
declaraci´on.
Si se ejecuta la operaci´on delete sobre una variable de tipo puntero que tiene el valor
NULL, entonces esta operaci´on no hace nada.
En caso de que no se libere (mediante el operador delete) la memoria din´amica apuntada
por la variable ptr, y esta variable sea destruida al terminar su tiempo de vida (su ´ambito de
visibilidad), entonces se perder´a la memoria din´amica a la que apunta.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
◦
ptr: −→ pepe 111
int main()
{ 5
PPersona ptr = new Persona("pepe", "111", 5);

// manipulaci´on
perdida
pepe
111
// no se libera la memoria din´amica apuntada por ptr
// se destruye la variable local ptr 5
}

15.3. Operaciones con Variables de Tipo Puntero

Desreferenciaci´on de una Variable de Tipo Puntero
Para acceder a una variable din´amica apuntada por una variable de tipo puntero, se utiliza
el operador unario asterisco (*) precediendo al nombre de la variable de tipo puntero a trav´es
de la cual es apuntada. Por ejemplo, si ptr es una variable local de tipo puntero que apunta a una
variable din´amica de tipo Persona, entonces *ptr es la variable din´amica apuntada, y se trata
de igual forma que cualquier otra variable de tipo Persona.
int main()
{
PPersona ptr = new Persona("pepe", "111", 5);

Persona p = *ptr;

*ptr = p;

delete ptr;
}

Sin embargo, si una variable de tipo puntero tiene el valor NULL, entonces desreferenciar la variable
produce un error en tiempo de ejecuci´on que aborta la ejecuci´on del programa.
Es posible, as´ı mismo, acceder a los elementos de la variable apuntada mediante el operador de
desreferenciaci´on. Por ejemplo:
int main()
{
PPersona ptr = new Persona;

(*ptr).nombre = "pepe";
(*ptr).telefono = "111";
(*ptr).edad = 5;

delete ptr;
}

N´otese que el uso de los par´entesis es obligatorio debido a que el operador punto (.) tiene
mayor precedencia que el operador de desreferenciaci´on (*). Por ello, en el caso de acceder a
los campos de un registro en memoria din´amica a trav´es de una variable de tipo puntero, se
puede utilizar el operador de desreferenciaci´on (->) m ´a s utilizado comu´nmente. Por
ejemplo:
int main()
{
PPersona ptr = new Persona;

ptr->nombre = "pepe";
ptr->telefono = "111";
ptr->edad = 5;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.3. OPERACIONES CON VARIABLES DE TIPO PUNTERO 195

delete ptr;
}
Este operador tambi´en se utiliza para invocar a m´etodos de un objeto si ´este se encuentra
alojado en memoria din´amica. Por ejemplo:
#include <iostream>
using namespace std;
class Numero {
public:
Numero(int v) : val(v) {}
int valor() const { return val; }
private:
int val;
};
typedef Numero* PNumero;
int main()
{
PNumero ptr = new Numero(5);

cout << ptr->valor() << endl;

delete ptr;
}

Asignaci´on de Variables de Tipo Puntero

El puntero nulo (NULL) se puede asignar a cualquier variable de tipo puntero. Por ejemplo:
int main()
{
p1: ?
PPersona p1;
// ...
p1 = NULL; p1:
// ...
}
El resultado de crear una variable din´amica con el operador new se puede asignar a una
variable de tipo puntero al tipo de la variable din´amica creada. Por ejemplo:
int main()
{ p1: ?
PPersona p1;
// ... p1: ◦ −→pepe 111
p1 = new Persona("pepe", "111", 5); 5
// ...
}
As´ı mismo, a una variable de tipo puntero se le puede asignar el valor de otra variable puntero.
En este caso, ambas variables de tipo puntero apuntar´an a la misma variable din´amica, que ser
´a com- partida por ambas. Si se libera la variable din´amica apuntada por una de ellas, la
variable din´amica compartida se destruye, su memoria se desaloja y ambas variables locales de
tipo puntero quedan con un valor inespecificado.
int main() p1: ◦ −→ pepe 111
{ p2: ◦ −→ 5
PPersona p1 = new Persona("pepe", "111", 5);
PPersona p2;
// ... p1: ?
p2 = p1;
// ...
p2: ?
X
delete p1;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
En la operaci´on de asignaci´on, el valor anterior que tuviese la variable de tipo puntero se
pierde, por lo que habr´a que tener especial cuidado de que no se pierda la variable din´amica
que tuviese asignada, si tuviese alguna.
int main() p1: ◦ −→pepe 111
{ 5
PPersona p1 = new Persona("pepe", "111", 5);
// ...
p1 = NULL; // se pierde el valor anterior
perdida
p1: pepe
// ...
111
delete p1;
} 5

Comparaci´on de Variables de Tipo Puntero

Las variables del mismo tipo puntero se pueden comparar entre ellas por igualdad (==) o
desigualdad (!=), para comprobar si apuntan a la misma variable din´amica. As´ı mismo, tambi
´en se pueden comparar por igualdad o desigualdad con el puntero nulo (NULL) para saber si
apunta a alguna variable din´amica, o por el contrario no apunta a nada. Por ejemplo:

int main()
{
PPersona p1, p2;
// ...
if (p1 == p2) {
// ...
}
if (p1 != NULL) {
// ...
}
// ...
}

15.4. Paso de Par´ametros de Variables de Tipo Puntero

El tipo puntero es un tipo simple, y por lo tanto se tratar´a como tal. En caso de paso de par
´ametros de tipo puntero, si es un par´ametro de entrada, entonces se utilizar´a el paso por
valor, y si es un par´ametro de salida o de entrada/salida, entonces se utilizar´a el paso por
referencia.
Hay que ser consciente de que un par´ametro de tipo puntero puede apuntar a una variable
din´amica, y en este caso, a partir del par´ametro se puede acceder a la variable apuntada.
As´ı, si el par´ametro se pasa por valor, entonces se copia el valor del puntero del par
´ametro actual (en la invocaci´on) al par´ametro formal (en el subprograma), por lo que
ambos apuntar´an a la misma variable din´amica compartida, y en este caso, si se modifica el
valor almacenado en la variable din´amica, este valor se ver ´a afectado, as´ı mismo, en el exterior
del subprograma, aunque el par´ametro haya sido pasado por valor.
Por otra parte, las funciones tambi´en pueden devolver valores de tipo puntero.

void modificar(PPersona& p);

PPersona buscar(PPersona l, const string& nombre);

A Alternativamente, tambi´en es posible declarar directamente los par´ametros de tipo puntero sin
necesidad de definir expl´ıcitamente un tipo puntero:

void modificar(Persona* & p);

Persona* buscar(Persona* l, const string& nombre);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 15.5. ABSTRACCIO´ N EN LA GESTIO´ N DE MEMORIA DINA´ MICA 197

A Punteros a Variables Din´amicas Constantes

A veces es interesante garantizar que cuando se pasa un puntero a un subprograma, ´este no

pueda modificar los valores almacenados en la variable din´amica apuntada. Ya que el paso por
valor no puede proporcionar dicha garant´ıa, en el lenguaje de programaci´on C++ existe el
tipo puntero a una variable din´amica constante, de tal forma que se puede realizar un paso
por valor de una variable de tipo puntero a un determinado tipo, a un par´ametro de tipo
puntero a una variable din´amica constante. Por ejemplo:

struct Persona
{ string nombre;
string telefono;
};
typedef Persona* PPersona;
typedef const Persona* PCPersona;
void datos(PCPersona ptr)
{
ptr->nombre = "pepe"; // error, no es posible modificar entidad constante
ptr->telefono = "111"; // error, no es posible modificar entidad constante
}
int main()
{
PPersona ptr = new Persona;
datos(ptr);
}

A Alternativamente, tambi´en es posible declarar directamente los par´ametros de tipo puntero con-
stante sin necesidad de definir expl´ıcitamente un tipo puntero:

struct Persona
{ string nombre;
string telefono;
};
void datos(const Persona* ptr)
{
ptr->nombre = "pepe"; // error, no es posible modificar entidad constante
ptr->telefono = "111"; // error, no es posible modificar entidad constante
}
int main()
{
Persona* ptr = new Persona;
datos(ptr);
}

15.5. Abstracci´on en la Gesti´on de Memoria Din´amica

La gesti´on de memoria din´amica por parte del programador se basa en estructuras de
progra- maci´on de bajo nivel, las cuales son propensas a errores de programaci´on y p´erdida de
recursos de memoria. Adem´as, entremezclar sentencias de gesti´on de memoria, de bajo nivel,
con sentencias aplicadas al dominio de problema a resolver suele dar lugar a c´odigo no legible y
propenso a errores. Por lo tanto se hace necesario aplicar niveles de abstracci´on que aislen la
gesti´on de memo-
ria din´amica (de bajo nivel) del resto del c´odigo m ´a s directamente relacionado con la
soluci´on del problema. Para ello, los tipos abstractos de datos proporcionan el mecanismo
adecuado para aplicar la abstracci´on a estas estructuras de datos basadas en la gesti´on de
memoria din´amica, adem´as de proporcionar una herramienta adecuada para la gesti´on de
memoria din´amica, ya que los destructores se pueden encargar de liberar los recursos asociados a
un determinado objeto. Por ejemplo:
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
template <typename Tipo>
class Dato {
public:
Dato(const Tipo& d) : ptr(NULL) {
ptr = new Nodo;
ptr->dato = d;
}
~Dato() {
delete ptr;
}
// ... Otros m´etodos
private:
struct Nodo {
Tipo dato;
};
typedef Nodo* PNodo;
//-- Atributos --
PNodo ptr;
};

15.6. Estructuras Enlazadas

Una de las principales aplicaciones de la Memoria Din´amica es el uso de estructuras
enlazadas, de tal forma que un campo o atributo de la variable din´amica es a su vez tambi´en de
tipo puntero, por lo que puede apuntar a otra variable din´amica que tambi´en tenga un campo
o atributo de tipo puntero, el cual puede volver a apuntar a otra variable din´amica, y as´ı
sucesivamente, tantas veces como sea necesario, hasta que un puntero con el valor NULL indique
el final de la estructura enlazada (lista enlazada).
As´ı, en este caso, vemos que un campo de la estructura es de tipo puntero a la propia estructura,
por lo que es necesario definir el tipo puntero antes de definir la estructura. Sin embargo, la
estructura todav´ıa no ha sido definida, por lo que no se puede definir un puntero a ella. Por
ello es necesario realizar una declaraci´on adelantada de un tipo incompleto del tipo de la
variable din´amica, donde se declara que un determinado identificador es una estructura o clase,
pero no se definen sus componentes.
struct Persona; // Declaraci´on adelantada del tipo incompleto Persona
typedef Persona* PPersona; // Definici´on de tipo Puntero a tipo incompleto Persona
struct Persona { // Definici´on del tipo Persona
PPersona sig; // enlace a la siguiente estructura din´amica
string nombre;
string telefono;
}; lista:
◦ − mar´ıa 333
◦ ◦ −→
int main() juan
{ → −→
222
PPersona lista = NULL; pepe
string nm, tlf; 111
cin >> nm;
while (n != "fin")
{ cin >> tlf;
PPersona ptr = new Persona;
ptr->nombre = nm;
ptr->telefono = tlf;
ptr->sig = lista;
lista = ptr;
cin >> nm;
}
// ...
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.6. ESTRUCTURAS ENLAZADAS 199

Insertar al Principio Insertar Detr

´as
lista: ◦ -
mar´ıa lista: ◦ −→ ◦ -
pepe mar´ıa

PNodo ptr = new Nodo("pepe");

- PNodo ptr = new Nodo("juan");
lista: ◦
mar´ıa lista: ◦ −→ ◦ -
ptr: ◦ −→ pepe mar´ıa
◦ ◦
ptr: ◦ -
pepe juan
ptr->sig = lista;
lista: ◦ - ptr->sig = lista->sig;
3
mar´ıa lista: ◦ −→ ◦ -
3
ptr: ◦ −→ pepe mar´ıa
◦ ◦
pepe ptr: ◦ -
juan
lista = ptr;
lista->sig = ptr;
lista: ◦ ◦Q
3 mar´ıa lista: ◦ −→ pepe Q
ptr: @R
◦ −→ 3 mar´ıa
◦
-Qs
ptr: ◦ ◦
pepe
juan

lista: ◦ −→ ◦ −→ ◦ −
mar´ıa lista: ◦ −→
pepe pepe → ◦ −→
juan mar´ıa

◦ − ◦ −
pepe pepe

◦Q
pepe Q
◦
pepe

◦
pepe

◦ −
pepe

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Eliminar del Principio Eliminar de Detr´as

lista: ◦ −→ → lista: ◦ −→ → ◦ −→
mar´ıa juan mar´ıa

ptr = lista; ptr = lista->sig;

lista: ◦ lista: ◦ −→
3 mar´ıa 3 mar´ıa
@R
-Qs
ptr: ◦ −→ ptr: ◦ ◦
juan
lista = ptr->sig; lista->sig = ptr->sig;
lista: ◦ -
3 lista: ◦ −→ ◦ -
3
mar´ıa pepe mar´ıa
ptr: ◦ −→ - ◦
ptr: ◦
juan
delete ptr; delete ptr;
lista: ◦ - -
lista: ◦ −→ ◦
ptr: ? mar´ıa pepe mar´ıa

X ptr: ?
X
lista: ◦ −→ lista: ◦ −→ →
mar´ıa mar´ıa

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.7. OPERACIONES CON LISTAS ENLAZADAS 1

15.7. Operaciones con Listas Enlazadas

Aunque las listas enlazadas se pueden programar directamente entremezcladas con el c
´odigo de resoluci´on del problema en cuesti´on, es conveniente que su gesti´on se realice
dentro de una abstracci´on que aisle su tratamiento y permita una mejor gesti´on de sus
recursos.
Con objeto de facilitar su estudio, el siguiente ejemplo es una implementaci´on simplificada del
tipo abstracto de datos lista. N´otese, sin embargo, que otras implementaciones pueden
mejorar notablemente su eficiencia.
Es importante considerar que en presencia de excepciones, esta implementaci´on del TAD
lista puede perder memoria en el caso de excepciones elevadas en el constructor de copia al
duplicar una lista enlazada (v´ease 15.8).
//- lista.hpp
#ifndef _lista_hpp_
#define _lista_hpp_
#include <iostream>
#include <cassert>
namespace umalcc {
//--------------------------------
namespace lista_impl {
template <typename Tipo>
inline void intercambiar(Tipo& a, Tipo& b)
{
Tipo x = a;
a = b;
b = x;
}
}
//--------------------------------
template <typename Tipo>
class Lista {
public:
~Lista() { destruir(); }
Lista() : sz(0), lista(NULL) {}
//------------------------
Lista(const Lista& o) : sz(0), lista(NULL) { duplicar(o); }
//----------------------------
Lista& operator = (const Lista& o)
{
if (this != &o) {
duplicar(o);
}
return *this;
}
//----------------------------
unsigned size() const { return sz; }
//----------------------------
void clear()
{
destruir();
}
//------------------------
void swap(Lista& o)
{
lista_impl::intercambiar(sz, o.sz);
lista_impl::intercambiar(lista, o.lista);
}
//------------------------
unsigned buscar(const Tipo& d) const
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
{
unsigned i = 0;
PNodo ptr = lista;
while ((ptr != NULL)&&(d != ptr->dato))
{ ptr = ptr->sig;
++i;
}
return i;
}
//------------------------
void insertar_inicio(const Tipo& d)
{
insertar_nodo(lista, d);
}
//------------------------
void insertar_final(const Tipo& d)
{
if (lista == NULL)
{ insertar_nodo(lista, d);
} else {
PNodo ptr = lista;
while (ptr->sig != NULL) {
ptr = ptr->sig;
}
insertar_nodo(ptr->sig, d);
}
}
//------------------------
void insertar_ordenado(const Tipo& d)
{
if ((lista == NULL)||(d <= lista->dato))
{ insertar_nodo(lista, d);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;
while ((ptr != NULL)&&(d > ptr->dato))
{ ant = ptr;
ptr = ptr->sig;
}
insertar_nodo(ant->sig, d);
}
}
//------------------------
void insertar(unsigned n, const Tipo& d)
{
if ((lista == NULL)||(n == 0))
{ insertar_nodo(lista, d);
} else {
unsigned i = 1;
PNodo ptr = lista;
while ((ptr->sig != NULL)&&(i < n))
{ ptr = ptr->sig;
++i;
}
insertar_nodo(ptr->sig, d);
}
}
//------------------------
void eliminar_primero()

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.7. OPERACIONES CON LISTAS ENLAZADAS 3

{
if (lista != NULL) {
eliminar_nodo(lista);
}
}
//------------------------
void eliminar_ultimo()
{
if (lista != NULL) {
if (lista->sig == NULL) {
eliminar_nodo(lista);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;
while (ptr->sig != NULL)
{ ant = ptr;
ptr = ptr->sig;
}
eliminar_nodo(ant->sig);
}
}
}
//------------------------
void eliminar_elm(const Tipo& d)
{
if (lista != NULL) {
if (d == lista->dato) {
eliminar_nodo(lista);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;
while ((ptr != NULL)&&(d != ptr->dato))
{ ant = ptr;
ptr = ptr->sig;
}
if (ptr != NULL) {
eliminar_nodo(ant->sig);
}
}
}
}
//------------------------
void eliminar(unsigned p)
{
if (lista != NULL) {
if (p == 0) {
eliminar_nodo(lista);
} else {
unsigned i = 1;
PNodo ptr = lista;
while ((ptr != NULL)&&(i < p))
{ ptr = ptr->sig;
++i;
}
if ((ptr != NULL)&&(ptr->sig != NULL)) {
eliminar_nodo(ptr->sig);
}
}
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
}
//------------------------
void eliminar_todos(const Tipo& d)
{
// borrar el primero si tiene dato
while ((lista != NULL)&&(d == lista->dato)) {
eliminar_nodo(lista);
}
if (lista != NULL) {
// borrar todos los nodos que tienen dato a partir del segundo
PNodo ant = lista;
PNodo ptr = lista->sig;
while (ptr != NULL) {
if (d == ptr->dato) {
eliminar_nodo(ant->sig);
} else {
ant = ptr;
}
ptr = ant->sig;
}
}
}
//------------------------
const Tipo& operator [] (unsigned i) const
{
assert(i < size()); // Pre-condici´on
PNodo ptr = situar(i);
return ptr->dato;
}
//----------------------------
Tipo& operator [] (unsigned i)
{
assert(i < size()); // Pre-condici´on
PNodo ptr = situar(i);
return ptr->dato;
}
//----------------------------
friend std::ostream& operator <<(std::ostream& out, const Lista& lista)
{
out << vect.sz << " ";
PNodo ptr = lista.lista;
while (ptr != NULL) {
out << ptr->dato << " ";
ptr = ptr->sig;
}
return out;
}
//----------------------------
friend std::istream& operator >> (std::istream& in, Lista& lista)
{
lista.clear();
unsigned nelms;
in >> nelms;
for (unsigned i = 0; (i < nelms)&&(!in.fail()); ++i)
{ Tipo x;
in >> x;
if ( ! in.fail() ) {
lista.insertar_final(x);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.7. OPERACIONES CON LISTAS ENLAZADAS 5

}
return in;
}
//----------------------------
private:
//----------------------------
struct Nodo; // declaraci´on adelantada
typedef Nodo* PNodo;
struct Nodo {
PNodo sig; // enlace
Tipo dato;
//--------
// Nodo(const Tipo& d, PNodo s = NULL) : sig(s), dato(d) {} // Insertar_Nodo Alternativo
//--------
};
//---------------
//-- Atributos --
//---------------
unsigned sz;
PNodo lista;
//------------------------
// M´etodos Privados
//------------------------
void insertar_nodo(PNodo& ptr, const Tipo& d)
{
//--------
// ptr = new Nodo(d, ptr); // Insertar_Nodo Alternativo
//--------
PNodo aux = new Nodo;
aux->dato = d;
aux->sig = ptr;
ptr = aux;
//--------
++sz;
//--------
}
//------------------------
void eliminar_nodo(PNodo& ptr)
{
assert(ptr != NULL);
//--------
--sz;
//--------
PNodo aux = ptr;
ptr = ptr->sig;
delete aux;
//--------
}
//------------------------
void destruir()
{
while (lista != NULL) {
eliminar_nodo(lista);
}
}
//------------------------
void duplicar(const Lista& o)
{
assert(this != &o);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
destruir();
if (o.lista != NULL) {
insertar_nodo(lista, o.lista->dato);
PNodo u = lista;
PNodo p = o.lista->sig;
while (p != NULL) {
insertar_nodo(u->sig, p->dato);
u = u->sig;
p = p->sig;
}
}
}
//------------------------
PNodo situar(unsigned n) const
{
unsigned i = 0;
PNodo ptr = lista;
while ((ptr != NULL)&&(i < n))
{ ptr = ptr->sig;
++i;
}
return ptr;
}
//------------------------
};
}
#endif
//------------------------------------------------------------------------ -

Se puede apreciar como tanto el constructor de copia, como el operador de asignaci´on

duplican la lista almacenada, y por el contrario tanto el destructor como el m´etodo clear()
liberan todos los recursos que el objeto tenga asignados. As´ı mismo, el m´etodo duplicar invoca
a la destrucci´on de los recursos que tuviese antes de duplicar la lista. El m´etodo swap(...)
intercambia los contenidos almacenados en dos listas. Este m´etodo se puede utilizar para
pasar el contenido de una lista a otra sin realizar duplicaci´on del contenido.
A continuaci´on se puede ver un ejemplo de utilizaci´on del tipo abstracto de datos lista
definido anteriormente.

#include "lista.hpp"
#include <iostream>
using namespace std;
using namespace umalcc;

int main()
{
try {
Lista<int> lista;
int dato;

cout << "Introduzca lista entre llaves: ";

cin >> lista;
cout << lista << endl;

cout << "Insertar al inicio. " ;

cin >> dato;
lista.insertar_inicio(dato);

cout << "Ctor de Copia" << endl;

Lista<int> copia = lista;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 15.7. OPERACIONES CON LISTAS ENLAZADAS 7

cout << "Copia:" << copia << endl;

cout << "Insertar al final. " ;

cin >> dato;
lista.insertar_final(dato);

cout << "Insertar Posici´on Dato. " ;

unsigned pos;
cin >> pos >> dato;
lista.insertar(pos, dato);

cout << "Lista:" << lista << endl;

cout << "Copia:" << copia << endl;

cout << "buscar un nodo. " ;

cin >> dato;
unsigned i = lista.buscar(dato);
if (i < lista.size()) {
cout << "Encontrado: " << lista[i] << endl;
} else {
cout << "No encontrado: " << dato << endl;
}

copia = lista;

cout << "borrar un nodo. " ;

cin >> dato;
lista.eliminar_elm(dato);
cout << lista << endl;

cout << "Eliminar Posici´on. "

; cin >> pos;
lista.eliminar(pos);

cout << "eliminar todos. " ;

cin >> dato;
copia.eliminar_todos(dato);

cout << "Lista:" << lista << endl;

cout << "Copia:" << copia << endl;
} catch (const exception& e) {
cerr << "Error: " << e.what() << endl;
} catch (...) {
cerr << "Error: Inesperado" << endl;
}
}

A Implementaci´on Alternativa de los Operadores de Entrada y Salida de Datos

Es posible realizar una implementaci´on alternativa (un poco m ´a s complicada) donde la

secuen- cia de longitud indeterminada de elementos que contiene el vector se encuentra
delimitada entre llaves, por ejemplo:
{ 1 2 3 4 5 6 }

//-lista.hpp
namespace umalcc {
// ..........
template <typename Tipo>
class Lista {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 1
EXCEPCIONES
// ..........
friend std::ostream& operator <<(std::ostream& out, const Lista& lista)
{
out << "{ ";
PNodo ptr = lista.lista;
while (ptr != NULL) {
out << ptr->dato << " ";
ptr = ptr->sig;
}
out << "}";
return out;
}
//----------------------------
friend std::istream& operator >> (std::istream& in, Lista& lista)
{
char ch = ’\0’;
in >> ch;
if (ch != ’{’) {
in.unget();
in.setstate(std::ios::failbit);
} else if ( ! in.fail() ) {
lista.clear();
in >> ch;
while ((! in.fail()) && (ch != ’}’) ) {
in.unget();
Tipo x;
in >> x;
if ( ! in.fail() ) {
lista.insertar_final(x);
}
in >> ch;
}
}
return in;
}
// ..........
};
}
//------------------------------------------------------------------------ -

15.8. Gestio´n de Memoria Din´amica en Presencia de

Ex- cepciones A
En secciones anteriores se ha explicado que la gesti´on de memoria din´amica se basa en
es- tructuras de programaci´on de bajo nivel, que debido a su complejidad son propensas a
errores y p´erdidas de recursos, por lo que es adecuado aislar su programaci´on dentro de una
abstracci´on de datos.
Adem´as, si en una determinada pieza de software es posible que se eleven excepciones, ya
sea expl´ıcitamente por el propio c´odigo del programador, como por c´odigo de bibliotecas y m
´odulos externos, entonces el flujo de ejecuci´on del programa se vuelve m ´a s impredecible, y
puede suceder que determinadas zonas de c´odigo encargadas de la liberaci´on de recursos no se
ejecuten finalmente en el flujo de ejecuci´on del programa.
Por lo tanto, en caso de que el software se ejecute en un entorno con presencia de
excepciones, se hace incluso m ´a s necesario que toda la gesti´on de la memoria din´amica se
realice dentro de abstracciones cuyos destructores se encarguen de liberar los recursos
adquiridos, ya que cuando se lanza una excepci´on se destruyen todas las variables (invocando
a su destructor) que hayan
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
2 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
sido definidas dentro de cada ´ambito del que se salga hasta encontrar un capturador adecuado
para la excepci´on elevada. De esta forma se liberan autom´aticamente todos los recursos
asociados a dichas variables (v´ease RAII 22.1), que de otra forma probablemente no ser´ıan
gestionados adecuadamente.
As´ı, la lista enlazada implementada en la secci´on anterior (v´ease 15.7) se comporta
adecuada- mente en presencia de excepciones, ya que en caso de que se destruya una
determinada lista por la elevaci´on de una excepci´on, sus recursos ser´an liberados por la
invocaci´on a su destructor.
Sin embargo, existe una excepci´on a este hecho. Si la excepci´on se eleva durante la
propia construcci´on del objeto de tipo Lista, entonces el objeto no est ´a completamente
creado, por lo que en este caso no se invocar´a a su destructor, aunque sin embargo si se invocar´a
a los destructores de sus componentes que hayan sido correctamente creados. Este hecho puede
hacer que la memoria din´amica reservada durante la construcci´on del objeto se pierda, por lo
que requiere que deba ser manejada atendiendo a estas circunstancias.
Adem´as, en la gesti´on de memoria din´amica, la creaci´on de una variable en memoria din
´amica es susceptible a elevar excepciones por dos motivos fundamentales, en primer lugar puede
suceder que la memoria din´amica se agote y no quede memoria din´amica suficiente para
alojar al nuevo objeto, en cuyo caso se lanzar´a una excepci´on est´andar (bad_alloc), y en
segundo lugar, cuando la construcci´on de un objeto falla por alguna circunstancia, entonces
elevar´a una excepci´on para indicar la causa del fallo. Por ejemplo, si durante la construcci
´on de un objeto de tipo Lista mediante el constructor de copia se eleva una excepci´on,
entonces la memoria alojada al duplicar la lista se perder´a, ya que no se invocar´a al
destructor de la clase Lista.
Por lo tanto, para que nuestro tipo abstracto de datos sea robusto tambi´en ante las
excepciones elevadas durante su propia construcci´on, es necesario garantizar que se destruya la
lista aunque el constructor de copia de la clase Lista eleve alguna excepci´on. Para ello, se
puede definir una clase auxiliar RAII_Lista cuyo destructor libere los recursos asociados a una
lista, de tal forma que se utilice para garantizar dicha destrucci´on durante la duplicaci´on de
la lista.

//- lista_raii.hpp
#ifndef _lista_raii_hpp_
#define _lista_raii_hpp_
#include <iostream>
#include <cassert>
namespace umalcc {
//--------------------------------
namespace lista_raii_impl {
template <typename Tipo>
inline void intercambiar(Tipo& a, Tipo& b)
{
Tipo x = a;
a = b;
b = x;
}
}
//--------------------------------
template <typename Tipo>
class Lista {
public:
~Lista() {
RAII_Lista aux;
aux.swap(lista);
}
//-------------------------
Lista() : sz(0), lista(NULL) {}
//------------------------
Lista(const Lista& o)
: sz(0), lista(NULL)
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 3
EXCEPCIONES{

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
RAII_Lista aux;
aux.duplicar(o.lista);
aux.swap(lista);
sz = o.sz;
}
//----------------------------
Lista& operator = (const Lista& o)
{
if (this != &o) {
Lista(o).swap(*this);
}
return *this;
}
//----------------------------
unsigned size() const { return sz; }
//----------------------------
void clear()
{
Lista().swap(*this);
}
//------------------------
void swap(Lista& o)
{
lista_raii_impl::intercambiar(sz, o.sz);
lista_raii_impl::intercambiar(lista, o.lista);
}
//------------------------
unsigned buscar(const Tipo& d) const
{
unsigned i = 0;
PNodo ptr = lista;
while ((ptr != NULL)&&(d != ptr->dato))
{ ptr = ptr->sig;
++i;
}
return i;
}
//------------------------
void insertar_inicio(const Tipo& d)
{
insertar_nodo(lista, d);
}
//------------------------
void insertar_final(const Tipo& d)
{
if (lista == NULL)
{ insertar_nodo(lista, d);
} else {
PNodo ptr = lista;
while (ptr->sig != NULL) {
ptr = ptr->sig;
}
insertar_nodo(ptr->sig, d);
}
}
//------------------------
void insertar_ordenado(const Tipo& d)
{
if ((lista == NULL)||(d <= lista->dato)) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 5
EXCEPCIONES
insertar_nodo(lista, d);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;
while ((ptr != NULL)&&(d > ptr->dato))
{ ant = ptr;
ptr = ptr->sig;
}
insertar_nodo(ant->sig, d);
}
}
//------------------------
void insertar(unsigned n, const Tipo& d)
{
if ((lista == NULL)||(n == 0))
{ insertar_nodo(lista, d);
} else {
unsigned i = 1;
PNodo ptr = lista;
while ((ptr->sig != NULL)&&(i < n))
{ ptr = ptr->sig;
++i;
}
insertar_nodo(ptr->sig, d);
}
}
//------------------------
void eliminar_primero()
{
if (lista != NULL) {
eliminar_nodo(lista);
}
}
//------------------------
void eliminar_ultimo()
{
if (lista != NULL) {
if (lista->sig == NULL) {
eliminar_nodo(lista);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;
while (ptr->sig != NULL)
{ ant = ptr;
ptr = ptr->sig;
}
eliminar_nodo(ant->sig);
}
}
}
//------------------------
void eliminar_elm(const Tipo& d)
{
if (lista != NULL) {
if (d == lista->dato) {
eliminar_nodo(lista);
} else {
PNodo ant = lista;
PNodo ptr = lista->sig;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

6 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
while ((ptr != NULL)&&(d != ptr->dato))
{ ant = ptr;
ptr = ptr->sig;
}
if (ptr != NULL) {
eliminar_nodo(ant->sig);
}
}
}
}
//------------------------
void eliminar(unsigned p)
{
if (lista != NULL) {
if (p == 0) {
eliminar_nodo(lista);
} else {
unsigned i = 1;
PNodo ptr = lista;
while ((ptr != NULL)&&(i < p))
{ ptr = ptr->sig;
++i;
}
if ((ptr != NULL)&&(ptr->sig != NULL)) {
eliminar_nodo(ptr->sig);
}
}
}
}
//------------------------
void eliminar_todos(const Tipo& d)
{
// borrar el primero si tiene dato
while ((lista != NULL)&&(d == lista->dato)) {
eliminar_nodo(lista);
}
if (lista != NULL) {
// borrar todos los nodos que tienen dato a partir del segundo
PNodo ant = lista;
PNodo ptr = lista->sig;
while (ptr != NULL) {
if (d == ptr->dato) {
eliminar_nodo(ant->sig);
} else {
ant = ptr;
}
ptr = ant->sig;
}
}
}
//------------------------
const Tipo& operator [] (unsigned i) const
{
assert(i < size()); // Pre-condici´on
PNodo ptr = situar(i);
return ptr->dato;
}
//----------------------------
Tipo& operator [] (unsigned i)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 7
EXCEPCIONES
{
assert(i < size()); // Pre-condici´on
PNodo ptr = situar(i);
return ptr->dato;
}
//----------------------------
friend std::ostream& operator <<(std::ostream& out, const Lista& lista)
{
out << "{ ";
PNodo ptr = lista.lista;
while (ptr != NULL) {
out << ptr->dato << " ";
ptr = ptr->sig;
}
out << "}";
return out;
}
//----------------------------
friend std::istream& operator >> (std::istream& in, Lista& lista)
{
char ch = ’\0’;
in >> ch;
if (ch != ’{’) {
in.unget();
in.setstate(std::ios::failbit);
} else if ( ! in.fail() ) {
lista.clear();
in >> ch;
while ((! in.fail()) && (ch != ’}’) ) {
in.unget();
Tipo x;
in >> x;
if ( ! in.fail() ) {
lista.insertar_final(x);
}
in >> ch;
}
}
return in;
}
//----------------------------
private:
//----------------------------
struct Nodo; // declaraci´on adelantada
typedef Nodo* PNodo;
struct Nodo {
PNodo sig; // enlace
Tipo dato;
//--------
Nodo(const Tipo& d, PNodo s = NULL) : sig(s), dato(d) {}
};
//-------------------------
//-- Atributos --
//---------------
unsigned sz;
PNodo lista;
//------------------------
// M´etodos Privados
//------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

8 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
void insertar_nodo(PNodo& ptr, const Tipo& d)
{
ptr = new Nodo(d, ptr);
++sz;
}
//------------------------
void eliminar_nodo(PNodo& ptr)
{
--sz;
PNodo aux = ptr;
ptr = ptr->sig;
delete aux;
}
//------------------------
PNodo situar(unsigned n) const
{
unsigned i = 0;
PNodo ptr = lista;
while ((ptr != NULL)&&(i < n))
{ ptr = ptr->sig;
++i;
}
return ptr;
}
//-------------------------
class RAII_Lista {
public:
//---------------------
~RAII_Lista() { destruir(); }
//---------------------
RAII_Lista() : lista(NULL) {}
//---------------------
void swap(PNodo& l) {
PNodo x = lista;
lista = l;
l = x;
}
//---------------------
void duplicar(PNodo l)
{
destruir();
if (l != NULL) {
lista = new Nodo(l->dato, lista);
PNodo u = lista;
PNodo p = l->sig;
while (p != NULL) {
u->sig = new Nodo(p->dato, u->sig);
u = u->sig;
p = p->sig;
}
}
}
//---------------------
private:
//---------------------
PNodo lista;
//---------------------
RAII_Lista(const RAII_Lista& o); // copia no permitida
RAII_Lista& operator=(const RAII_Lista& o); // asignaci´on no permitida

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 9
EXCEPCIONES
//---------------------
void destruir()
{
while (lista != NULL) {
PNodo aux = lista;
lista = lista->sig;
delete aux;
}
}
//---------------------
};
//------------------------
};
}
#endif
//-------------------------------------------------------------------------

Construcci´on del Objeto en Memoria Din´amica

El operador new desempen˜a principalmente dos acciones, primero aloja espacio suficiente
en memoria din´amica para almacenar la representaci´on de un objeto, y segundo construye el
objeto invocando al constructor adecuado segu´ n lo especificado en la sentencia. En caso de
que falle la construcci´on del objeto, entonces autom´aticamente libera la memoria din´amica
que hab´ıa alojado previamente.
Por lo tanto, alojar la memoria din´amica utilizando en un u´nico paso el constructor
adecuado para construir el objeto con los valores necesarios es m ´a s robusto que alojar la memoria
utilizando el constructor por defecto y posteriormente asignar los valores necesarios. Ya que si esta
asignaci´on falla y lanza una excepci´on, entonces la memoria alojada se perder´a, mientras
que si se hace en un u´ nico paso, si el constructor lanza una excepci´on entonces se desaloja
autom´aticamente la memoria solicitada. Por ejemplo, si el m´etodo insertar_nodo de la clase
Lista se hubiese definido de la siguiente forma:
void insertar_nodo(PNodo& ptr, const Tipo& d)
{
PNodo aux = new Nodo;
aux->dato = d;
aux->sig = ptr;
ptr = aux;
++sz;
}

ser´ıa susceptible de perder la memoria alojada para el nodo en caso de que la asignaci´on del dato
lanzase una excepci´on. Por el contrario, la siguiente definici´on es m ´a s robusta ante excepciones:

void insertar_nodo(PNodo& ptr, const Tipo& d)

{
ptr = new Nodo(d, ptr);
++sz;
}

ya que en caso de que la construcci´on del objeto fallase, se liberar´ıa autom´aticamente la memoria
previamente alojada para dicho objeto.

Utilizaci´on de Lista en Presencia de Excepciones

Las definiciones del tipo Lista anteriores se pueden comprobar en presencia de excepciones me-
diante el siguiente programa que utiliza un objeto que expl´ıcitamente eleva una excepci´on
durante su construcci´on.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

10 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
//- main.cpp
//#include "lista.hpp"
#include "lista_raii.hpp"
#include <iostream>
#include <stdexcept>
using namespace std;
using namespace umalcc;

class X {
public:
~X() { ++cnt_dtor; }
X(int v = 0) : valor(v) {
if (cnt_ctor == 11) {
cerr << "Error" << endl;
throw runtime_error("X::X");
}
++cnt_ctor;
}
X(const X& v) : valor(v.valor) {
if (cnt_ctor == 11) {
cerr << "Error" << endl;
throw runtime_error("X::X");
}
++cnt_ctor;
}
friend bool operator == (const X& a, const X& b)
{ return a.valor == b.valor;
}
friend bool operator != (const X& a, const X& b)
{ return a.valor != b.valor;
}
friend ostream& operator << (ostream& out, const X& x) {
return out << x.valor ;
}
friend istream& operator >> (istream& in, X& x)
{ return in >> x.valor ;
}
//-----------------------------
static unsigned cnt_construidos() { return cnt_ctor; }
static unsigned cnt_destruidos() { return cnt_dtor; }
//-----------------------------
private:
static unsigned cnt_ctor;
static unsigned cnt_dtor;
int valor;
//-----------------------------
};
//------------------
unsigned X::cnt_ctor = 0; // definici´on e inicializaci´on del atributo est´atico
unsigned X::cnt_dtor = 0; // definici´on e inicializaci´on del atributo est´atico
//------------------

int main()
{
try {
Lista<X> lista;
int dato;

cout << "Introduzca lista entre llaves: ";

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.8. GESTIO´ N DE MEMORIA DINA´ MICA EN PRESENCIA DE 11
EXCEPCIONES
cin >> lista;
cout << lista << endl;

cout << "Insertar al inicio. " ;

cin >> dato;
lista.insertar_inicio(dato);

cout << "Ctor de Copia" << endl;

Lista<X> copia = lista;
cout << "Copia:" << copia << endl;

cout << "Insertar al final. " ;

cin >> dato;
lista.insertar_final(dato);

cout << "Insertar Posici´on Dato. " ;

unsigned pos;
cin >> pos >> dato;
lista.insertar(pos, dato);

cout << "Lista:" << lista << endl;

cout << "Copia:" << copia << endl;

cout << "buscar un nodo. " ;

cin >> dato;
unsigned i = lista.buscar(dato);
if (i < lista.size()) {
cout << "Encontrado: " << lista[i] << endl;
} else {
cout << "No encontrado: " << dato << endl;
}

cout << "Asignar: " << endl;

copia = lista;

cout << "borrar un nodo. " ;

cin >> dato;
lista.eliminar_elm(dato);
cout << lista << endl;

cout << "Eliminar Posici´on. "

; cin >> pos;
lista.eliminar(pos);

cout << "eliminar todos. " ;

cin >> dato;
copia.eliminar_todos(dato);

cout << "Lista:" << lista << endl;

cout << "Copia:" << copia << endl;
} catch (const exception& e) {
cerr << "Error: " << e.what() << endl;
} catch (...) {
cerr << "Error: Inesperado" << endl;
}
cout << "Objetos construidos: " << X::cnt_construidos() << endl;
cout << "Objetos destruidos: " << X::cnt_destruidos() << endl;
}
//---------------------------------------------------------------- -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 15.9. COMPROBACIO´ N DE GESTIO´ N DE MEMORIA DINA´ MICA 217

Donde la ejecuci´on con la implementaci´on de Lista sin considerar las excepciones (v´ease 15.7)
produce el siguiente resultado:
Introduzca lista entre llaves: {1 2 3}
{ 1 2 3 }
Insertar al inicio. 0
Ctor de Copia
Error
Error: X::X
Objetos construidos: 11
Objetos destruidos: 8
ERROR, el n´umero de NEW [9] es diferente del n´umero de DELETE [6]

Mientras que la implementaci´on de Lista utilizando la clase auxiliar RAII_Lista (v´ease 15.8)
produce el siguiente resultado:
Introduzca lista entre llaves: {1 2 3}
{ 1 2 3 }
Insertar al inicio. 0
Ctor de Copia
Error
Error: X::X
Objetos construidos: 11
Objetos destruidos: 11
OK, el n´umero de NEW [9] es igual al n´umero de DELETE [9]

Con ayuda del programa de la secci´on 15.9 se puede realizar f´acilmente la comprobaci´on del nu
´mero total de nodos alojados y desalojados.

15.9. Comprobaci´on de Gesti´on de Memoria Din´amica A

El siguiente c´odigo C++ se puede compilar junto con cualquier programa C++ de forma
externa no intrusiva, y autom´aticamente realiza en tiempo de ejecuci´on una cuenta del nu
´mero de nodos alojados y liberados, de tal forma que al finalizar el programa escribe unas
estad´ısticas comprobando si coinciden o no. N´otese que no es necesario modificar el
programa principal para que se pueda comprobar autom´aticamente la cuenta de nodos
alojados y liberados, es suficiente con la invocaci´on al compilador.
g++ -ansi -Wall -Werror -o main main.cpp newdelcnt.cpp

//------------------------------------------------------------------------ -
//- newdelcnt.cpp
//------------------------------------------------------------------------ -
#include <iostream>
#include <cstdlib>
#include <new>
//------------------------------------------------------------------------ -
namespace {
static unsigned inc_new(unsigned n = 0) throw()
{
static unsigned cnt = 0;
return (cnt += n);
}
//------------------------------------
static unsigned inc_delete(unsigned n = 0) throw()
{
static unsigned cnt = 0;
return (cnt += n);
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS
//------------------------------------
static void check_new_delete() throw()
{
if (inc_new() != inc_delete()) {
std::cerr << "ERROR, el n´umero de NEW [" << inc_new()
<< "] es diferente del n´umero de DELETE ["
<< inc_delete() << "]" << std::endl;
#ifdef WIN32
std::system("pause");
#endif
std::exit(1234);
} else {
std::cerr << "OK, el n´umero de NEW [" << inc_new()
<< "] es igual al n´umero de DELETE ["
<< inc_delete() << "]" << std::endl;
}
}
//------------------------------------------------------------------------ -
struct ExecAtEnd { ~ExecAtEnd() throw() { check_new_delete(); } };
static ExecAtEnd x;
//------------------------------------------------------------------------ -
}//end namespace
//-------------------------------------------------------------------------
void* operator new (std::size_t sz) throw (std::bad_alloc)
{
if (sz == 0) {
sz = 1; // malloc(0) es impredecible; lo evitamos.
}
void* p = static_cast<void*>(std::malloc(sz));
if (p == 0) {
std::cerr << "Error: New: Memory failure" << std::endl;
throw std::bad_alloc();
}
inc_new(1);
return p;
}
//------------------------------------------------------------------------ -
void operator delete (void* ptr) throw()
{
if (ptr) {
inc_delete(1);
std::free(ptr);
}
}
//------------------------------------------------------------------------ -

15.10. Operador de Direcci´on A

En el lenguaje de programaci´on C++ una variable de tipo puntero, adem´as de apuntar a
variables alojadas en memoria din´amica, tambi´en puede apuntar a variables alojadas en
otras zonas de memoria gestionadas por el compilador (variables est´aticas y autom´aticas).
Para ello, es necesario poder obtener la direcci´on de dichas variables, de tal forma que la variable
puntero pueda acceder a ellas. El operador que nos devuelve la direcci´on donde se encuentra
una determinada variable es el operador prefijo unario “ampersand” (&). Por ejemplo:
struct Fecha {
unsigned dia, mes, anyo;
};

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

15.10. OPERADOR DE DIRECCIO´ N 219

int main()
{
int x = 3;
int* p = &x;

cout << *p << endl; // escribe 3 en pantalla

*p = 5;
cout << x << endl; // escribe 5 en pantalla

Fecha f;
Fecha* pf = &f;
pf->dia = 21;
pf->mes = 02;
pf->anyo = 2011;
}

Hay que tener presente que en estos casos, la variable de tipo puntero es t´a apuntando a una zona
de memoria gestionada por el compilador, por lo que el programador no debe utilizar los
operadores new ni delete. As´ı mismo, tambi´en puede suceder que la variable de tipo puntero
apunte a una variable autom´atica que haya desaparecido debido a que su ´ambito y tiempo de
vida hayan expirado con anterioridad.
N´otese que esta caracter´ıstica es una estructura de programaci´on de muy bajo nivel que
aumenta a u´ n m ´a s la complejidad de los programas, ya que a la complejidad de la gesti´on de los
punteros y la memoria din´amica se an˜ade la complejidad de gestionar tambi´en punteros a
direcciones de memoria gestionadas por el compilador, y el programador debe discernir entre
ambos tipos, as´ı como sobre el tiempo de vida de las variables gestionadas por el compilador.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 15. MEMORIA DINA´ MICA.
PUNTEROS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 16

Introduccio´n a los
Contenedores de la Biblioteca
Est´andar (STL)

Los contenedores de la biblioteca est´andar proporcionan un m´etodo general para

almacenar y acceder a elementos homog´eneos, proporcionando cada uno de ellos diferentes caracter
´ısticas que los hacen adecuados a diferentes necesidades.
En este cap´ıtulo introductorio se mostrar´an las principales operaciones que se pueden
realizar con los siguientes contenedores: el tipo vector, el tipo stack, y el tipo queue de la
biblioteca est´andar.

Paso de Par´ametros de Contenedores

Los contenedores de la biblioteca est´andar se pueden pasar como par´ametros a
subprogramas como cualquier otro tipo compuesto, y por lo tanto se aplican los mecanismos de paso
de par´ametros para tipos compuestos explicados en la secci´on 6.1. Es decir, los par´ametros de
entrada se pasar´an por referencia constante, mientras que los par´ametros de salida y
entrada/salida se pasar´an por referencia.
As´ı mismo, como norma general, salvo excepciones, no es adecuado que las funciones retornen
valores de tipos de los contenedores, debido a la sobrecarga que generalmente conlleva dicha
op- eraci´on para el caso de los tipos compuestos. En estos casos suele ser m ´a s adecuado que
el valor se devuelva como un par´ametro por referencia.

16.1. Vector
El contenedor de tipo vector<...> representa una secuencia de elementos homog´eneos
opti- mizada para el acceso directo a los elementos segu´ n su posici´on. Para utilizar un
contenedor de tipo vector se debe incluir la biblioteca est´andar <vector>, de tal forma que
sus definiciones se encuentran dentro del espacio de nombres std:

#include <vector>

El tipo vector es similar al tipo array, salvo en el hecho de que los vectores se caracterizan
porque su taman˜o puede crecer en tiempo de ejecuci´on dependiendo de las necesidades
surgidas durante la ejecuci´on del programa. Por ello, a diferencia de los arrays, no es necesario
especificar un taman˜o fijo y predeterminado en tiempo de compilaci´on respecto al nu´mero de
elementos que pueda contener.
El nu´mero m´aximo de elementos que se pueden almacenar en una variable de tipo vector
no e st´a especificado, y se pueden almacenar elementos mientras haya capacidad suficiente en
la memoria del ordenador donde se ejecute el programa.

221
1CAP´ITULO 16. INTRODUCCIO´ N A LOS CONTENEDORES DE LA BIBLIOTECA ESTA´ NDAR (STL)

N´otese que en los siguientes ejemplos, por simplicidad, tanto el nu´mero de elementos
como el valor inicial de los mismos est´an especificados mediante valores constantes, sin embargo,
tambi´en se pueden especificar como valores de variables y expresiones calculados en tiempo de
ejecuci´on.

Instanciaci´on del Tipo Vector

Se pueden definir expl´ıcitamente instanciaciones del tipo vector para tipos de elementos
con- cretos mediante la declaraci´on typedef. Por ejemplo la siguiente definici´on declara el tipo
Vect_Int como un tipo vector de nu´meros enteros.

typedef std::vector<int> Vect_Int;

Las siguientes definiciones declaran el tipo Matriz como un vector de dos dimensiones de nu´meros
enteros.

typedef std::vector<int> Fila;

typedef std::vector<Fila> Matriz;

Construcci´on de un Objeto de Tipo Vector

Se pueden definir variables de un tipo vector previamente definido expl´ıcitamente, o
directa- mente de la instanciaci´on del tipo. Por ejemplo, el siguiente c´odigo define dos
variables (v1 y v2) de tipo vector de nu´meros enteros, as´ı como la variable m de tipo vector de
dos dimensiones de nu´meros enteros.

int main()
{
Vect_Int v1; // vector de enteros vac´ıo
std::vector<int> v2; // vector de enteros vac´ıo
Matriz m; // vector de dos dimensiones de enteros vac´ıo
// ...
}

El constructor por defecto del tipo vector crea un objeto vector inicialmente vac´ıo, sin
elementos. Posteriormente se podr´an an˜adir y eliminar elementos cuando sea necesario.
Tambi´en es posible crear un objeto vector con un nu´mero inicial de elementos con un valor
inicial por defecto, al que posteriormente se le podr´an an˜adir nuevos elementos. Este nu
´mero inicial de elementos puede ser tanto una constante, como el valor de una variable
calculado en tiempo de ejecuci´on.

int main()
{
Vect_Int v1(10); // vector con 10 enteros con valor inicial 0
Matriz m(10, Fila(5)); // matriz de 10x5 enteros con valor inicial 0
// ...
}

As´ı mismo, tambi´en se puede especificar el valor por defecto que tomar´an los elementos creados
inicialmente.

int main()
{
Vect_Int v1(10, 3); // vector con 10 enteros con valor inicial 3
Matriz m(10, Fila(5, 3)); // matriz de 10x5 enteros con valor inicial 3
// ...
}

Tambi´en es posible inicializar un vector con el contenido de otro vector de igual tipo:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

16.1. VECTOR 223

int main()
{
Vect_Int v1(10, 3); // vector con 10 enteros con valor inicial 3
Vect_Int v2(v1); // vector con el mismo contenido de v1
Vect_Int v3 = v1; // vector con el mismo contenido de v1
// ...
}

Asignaci´on de un Objeto de Tipo Vector

Es posible la asignaci´on de vectores de igual tipo. En este caso, se destruye el valor anterior del
vector destino de la asignaci´on.
int main()
{
Vect_Int v1(10, 3); // vector con 10 enteros con valor inicial 3
Vect_Int v2; // vector de enteros vac´ıo

v2 = v1; // asigna el contenido de v1 a v2

v2.assign(5, 7); // asigna 5 enteros con valor inicial 7
}

As´ı mismo, tambi´en es posible intercambiar (swap en ingl´es) el contenido entre dos vectores uti-
lizando el m´etodo swap. Por ejemplo:
int main()
{
Vect_Int v1(10, 5); // v1 = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 }
Vect_Int v2(5, 7); // v2 = { 7, 7, 7, 7, 7 }

v1.swap(v2); // v1 = { 7, 7, 7, 7, 7 }
// v2 = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 }
}

Control sobre los Elementos de un Vector

El nu´mero de elementos actualmente almacenados en un vector se obtiene mediante el m´etodo
size(). Por ejemplo:
int main()
{
Vect_Int v1(10, 3); // vector con 10 enteros con valor inicial 3
unsigned n = v1.size(); // n´umero de elementos de v1
}

Es posible tanto an˜adir un elemento al final de un vector mediante el m´etodo

push_back(...), como eliminar el u´ltimo elemento del vector mediante el m´etodo pop_back()
(en este caso el vector no debe estar vac´ıo). As´ı mismo, el m´etodo clear() elimina todos los
elementos del vector. Por ejemplo:
int main()
{
Vect_Int v(5); // v = { 0, 0, 0, 0, 0 }
for (int i = 1; i <= 3; ++i) {
v.push_back(i);
} // v = { 0, 0, 0, 0, 0, 1, 2, 3 }
for (unsigned i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
} // muestra: 0 0 0 0 0 1 2 3
cout << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1CAP´ITULO 16. INTRODUCCIO´ N A LOS CONTENEDORES DE LA BIBLIOTECA ESTA´ NDAR (STL)

while (v.size() > 3) {

v.pop_back();
} // v = { 0, 0, 0 }
v.clear(); // v = { }
}

Tambi´en es posible cambiar el taman˜o del nu´mero de elementos almacenados en el vector.

As´ı, el m´etodo resize(...) reajusta el nu´ mero de elementos contenidos en un vector. Si el
nu´mero especificado es menor que el nu´mero actual de elementos, se eliminar´an del final
del vector tantos elementos como sea necesario para reducir el vector hasta el nu´mero de
elementos especificado. Si por el contrario, el nu´mero especificado es mayor que el nu´mero
actual de elementos, entonces se an˜adir´an al final del vector tantos elementos como sea
necesario para alcanzar el nuevo nu´mero de elementos especificado (con el valor especificado o
con el valor por defecto). Por ejemplo:
int main()
{
Vect_Int v(10, 1); // v = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
v.resize(5); // v = { 1, 1, 1, 1, 1 }
v.resize(9, 2); // v = { 1, 1, 1, 1, 1, 2, 2, 2, 2 }
v.resize(7, 3); // v = { 1, 1, 1, 1, 1, 2, 2 }
v.resize(10); // v = { 1, 1, 1, 1, 1, 2, 2, 0, 0, 0 }
}

Acceso a los Elementos de un Vector

Es posible acceder a cada elemento del vector individualmente, segu´n el ´ındice de la posici
´on que ocupe, tanto para obtener su valor almacenado, como para modificarlo mediante el
operador de indexaci´on []. El primer elemento ocupa la posici´on cero (0), y el u´ltimo
elemento almacenado en el vector v ocupa la posici´on v.size()-1. Por ejemplo:
int main()
{
Vect_Int v(10);
for (unsigned i = 0; i < v.size(); ++i)
{ v[i] = i;
}
for (unsigned i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << endl;
}

El lenguaje de programaci´on C++ no comprueba que los accesos a los elementos de un

vector sean correctos y se encuentren dentro de los l´ımites v´alidos del vector, por lo que ser ´a
responsabil- idad del programador comprobar que as´ı sea.
Tambi´en es posible acceder a un determinado elemento mediante el m´etodo at(i), de tal
forma que si el valor del ´ındice i est´a fuera del rango v´alido, entonces se lanzar´a una
excepci´on out_of_range. Se puede tanto utilizar como modificar el valor de este elemento.
int main()
{
Vect_Int v(10);
for (unsigned i = 0; i < v.size(); ++i)
{ v.at(i) = i;
}
for (unsigned i = 0; i < v.size(); ++i) {
cout << v.at(i) << " ";
}
cout << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 16.2. STACK 225

Comparaci´on Lexicogr´afica entre Vectores

Es posible realizar la comparaci´on lexicogr´afica (==, !=, >, >=, <, <=) entre vectores del
mismo tipo siempre y cuando los operadores de comparaci´on est´en definidos para el tipo de
los compo- nentes del vector. Por ejemplo:
int main()
{
Vect_Int v1(10, 7); // v1 = { 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 }
Vect_Int v2(5, 3); // v2 = { 3, 3, 3, 3, 3 }
if (v1 == v2) {
cout << "Iguales" << endl;
} else {
cout << "Distintos" << endl;
}
if (v1 < v2) {
cout << "Menor" << endl;
} else {
cout << "Mayor o Igual" << endl;
}
}

16.2. Stack
El contenedor de tipo stack<...> representa el tipo abstracto de datos Pila, como una
colec- ci´on ordenada (segu´n el orden de inserci´on) de elementos homog´eneos donde se pueden
introducir elementos (manteniendo el orden de inserci´on) y sacar elementos de ella (en orden
inverso al orden de inserci´on), de tal forma que el primer elemento que sale de la pila es el u
´ltimo elemento que ha sido introducido en ella. Adem´as, tambi´en es posible comprobar si la
pila contiene elementos, de tal forma que no se po dr´a sacar ningu´n elemento de una pila vac
´ıa. Para utilizar un contenedor de tipo stack se debe incluir la biblioteca est´andar <stack>,
de tal forma que sus definiciones se encuentran dentro del espacio de nombres std:
#include <stack>

El nu´mero m´aximo de elementos que se pueden almacenar en una variable de tipo stack no est
´a es- pecificado, y se pueden introducir elementos mientras haya capacidad suficiente en la
memoria del ordenador donde se ejecute el programa.

Instanciaci´on del Tipo Stack

Se pueden definir expl´ıcitamente instanciaciones del tipo stack para tipos de elementos
concre- tos mediante la declaraci´on typedef. Por ejemplo la siguiente definici´on declara el
tipo Stack_Int como un tipo pila de nu´meros enteros.
typedef std::stack<int> Stack_Int;

Construcci´on de un Objeto de Tipo Pila

Se pueden definir variables de un tipo pila previamente definido expl´ıcitamente, o directamente
de la instanciaci´on del tipo. Por ejemplo, el siguiente c´odigo define dos variables (s1 y s2) de
tipo pila de nu´meros enteros.
int main()
{
Stack_Int s1; // stack de enteros vac´ıo
std::stack<int> s2; // stack de enteros vac´ıo
// ...
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1CAP´ITULO 16. INTRODUCCIO´ N A LOS CONTENEDORES DE LA BIBLIOTECA ESTA´ NDAR (STL)

El constructor por defecto del tipo stack crea un objeto stack inicialmente vac´ıo, sin elementos.
Posteriormente se podr´an an˜adir y eliminar elementos cuando sea necesario.
Tambi´en es posible inicializar una pila con el contenido de otra pila de igual tipo:
int main()
{
Stack_Int s1; // stack de enteros vac´ıo
// ...
Stack_Int s2(s1); // stack con el mismo contenido de s1
Stack_Int s3 = s1; // stack con el mismo contenido de s1
// ...
}

Asignaci´on de un Objeto de Tipo Pila

Es posible la asignaci´on de pilas de igual tipo. En este caso, se destruye el valor anterior de
la pila destino de la asignaci´on.
int main()
{
Stack_Int s1; // stack de enteros vac´ıo
Stack_Int s2; // stack de enteros vac´ıo

s2 = s1; // asigna el contenido de s1 a s2

}

Control y Acceso a los Elementos de una Pila

Es posible tanto an˜adir un elemento una pila mediante el m´etodo push(...), como
eliminar el u´ltimo elemento introducido en la pila mediante el m´etodo pop() (en este caso la
pila no debe estar vac´ıa).
Por otra parte, el m´etodo empty() indica si una pila est´a vac´ıa o no, mientras que el nu
´mero de elementos actualmente almacenados en una pila se obtiene mediante el m´etodo
size().
As´ı mismo, se puede acceder al u´ltimo elemento introducido en la pila mediante el m
´etodo top(). Se puede tanto utilizar como modificar el valor de este elemento (en este caso la
pila no debe estar vac´ıa).
Por ejemplo:
int main()
{
Stack_Int s; // s = { }
for (int i = 1; i <= 3; ++i) {
s.push(i);
} // s = { 1, 2, 3 }

s.top() = 5; // s = { 1, 2, 5 }

s.pop(); // s = { 1, 2 }
s.pop(); // s = { 1 }
s.push(7); // s = { 1, 7 }
s.push(9); // s = { 1, 7, 9 }

cout << s.size() << endl; // muestra: 3

while (! s.empty()) {
cout << s.top() << " "; // muestra: 9 7 1
s.pop();
} // s = { }
cout << endl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 16.3. QUEUE 227

Comparaci´on Lexicogr´afica entre Pilas

Es posible realizar la comparaci´on lexicogr´afica (==, !=, >, >=, <, <=) entre pilas del mismo
tipo siempre y cuando los operadores de comparaci´on est´en definidos para el tipo de los
componentes de la pila. Por ejemplo:
int main()
{
Stack_Int s1;
Stack_Int s2;
// ...
if (s1 == s2) {
cout << "Iguales" << endl;
} else {
cout << "Distintos" << endl;
}
if (s1 < s2) {
cout << "Menor" << endl;
} else {
cout << "Mayor o Igual" << endl;
}
}

16.3. Queue
El contenedor de tipo queue<...> representa el tipo abstracto de datos Cola, como una colec-
ci ´on ordenada (segu´n el orden de inserci´on) de elementos homog´eneos donde se pueden
introducir elementos (manteniendo el orden de inserci´on) y sacar elementos de ella (en el
mismo orden al or- den de inserci´on), de tal forma que el primer elemento que sale de la cola es el
primer elemento que ha sido introducido en ella. Adem´as, tambi´en es posible comprobar si la
cola contiene elementos, de tal forma que no se podr´a sacar ningu´n elemento de una cola vac
´ıa. Para utilizar un contenedor de tipo queue se debe incluir la biblioteca est´andar <queue>, de
tal forma que sus definiciones se encuentran dentro del espacio de nombres std:
#include <queue>
El nu´mero m´aximo de elementos que se pueden almacenar en una variable de tipo queue no es t
´a es- pecificado, y se pueden introducir elementos mientras haya capacidad suficiente en la
memoria del ordenador donde se ejecute el programa.

Instanciaci´on del Tipo Queue

Se pueden definir expl´ıcitamente instanciaciones del tipo queue para tipos de elementos concre-
tos mediante la declaraci´on typedef. Por ejemplo la siguiente definici´on declara el tipo
Queue_Int como un tipo cola de nu´meros enteros.
typedef std::queue<int> Queue_Int;

Construcci´on de un Objeto de Tipo Cola

Se pueden definir variables de un tipo cola previamente definido expl´ıcitamente, o directamente
de la instanciaci´on del tipo. Por ejemplo, el siguiente c´odigo define dos variables (c1 y c2) de
tipo cola de nu´meros enteros.
int main()
{
Queue_Int c1; // queue de enteros vac´ıo
std::queue<int> c2; // queue de enteros vac´ıo
// ...
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

16.4. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO 1
CONTENEDORES
El constructor por defecto del tipo queue crea un objeto queue inicialmente vac´ıo, sin elementos.
Posteriormente se podr´an an˜adir y eliminar elementos cuando sea necesario.
Tambi´en es posible inicializar una cola con el contenido de otra cola de igual tipo:
int main()
{
Queue_Int c1; // queue de enteros vac´ıo
// ...
Queue_Int c2(c1); // queue con el mismo contenido de c1
Queue_Int s3 = c1; // queue con el mismo contenido de c1
// ...
}

Asignaci´on de un Objeto de Tipo Cola

Es posible la asignaci´on de colas de igual tipo. En este caso, se destruye el valor anterior de
la cola destino de la asignaci´on.
int main()
{
Queue_Int c1; // queue de enteros vac´ıo
Queue_Int c2; // queue de enteros vac´ıo

c2 = c1; // asigna el contenido de c1 a c2

}

Control y Acceso a los Elementos de una Cola

Es posible tanto an˜adir un elemento una cola mediante el m´etodo push(...), como
eliminar el primer elemento introducido en la cola mediante el m´etodo pop() (en este caso la
cola no debe estar vac´ıa).
Por otra parte, el m´etodo empty() indica si una cola est´a vac´ıa o no, mientras que el nu
´mero de elementos actualmente almacenados en una cola se obtiene mediante el m´etodo
size().
As´ı mismo, se puede acceder al u´ltimo elemento introducido en la cola mediante el m
´etodo back(), as´ı como al primer elemento introducido en ella mediante el m´etodo front().
Se pueden tanto utilizar como modificar el valor de estos elementos (en este caso la cola no debe
estar vac´ıa).
Por ejemplo:
int main()
{
Queue_Int c; // c = { }
for (int i = 1; i <= 3; ++i) {
c.push(i);
} // c = { 1, 2, 3 }

c.front() = 6; // c = { 6, 2, 3 }
c.back() = 5; // c = { 6, 2, 5 }

c.pop(); // c = { 2, 5 }
c.pop(); // c = { 5 }
c.push(7); // c = { 5, 7 }
c.push(9); // c = { 5, 7, 9 }

cout << c.size() << endl; // muestra: 3

while (! c.empty()) {
cout << c.front() << " "; // muestra: 5 7 9
c.pop();
} // c = { }
Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga
 2CAP´ITULO 16. INTRODUCCIO´ N A LOS CONTENEDORES DE LA BIBLIOTECA ESTA´ NDAR (STL)

cout << endl;

}

Comparaci´on Lexicogr´afica entre Colas

Es posible realizar la comparaci´on lexicogr´afica (==, !=, >, >=, <, <=) entre colas del mismo
tipo siempre y cuando los operadores de comparaci´on est´en definidos para el tipo de los
componentes de la cola. Por ejemplo:
int main()
{
Queue_Int c1;
Queue_Int c2;
// ...
if (c1 == c2) {
cout << "Iguales" << endl;
} else {
cout << "Distintos" << endl;
}
if (c1 < c2) {
cout << "Menor" << endl;
} else {
cout << "Mayor o Igual" << endl;
}
}

16.4. Resoluci´on de Problemas Utilizando Contenedores

Ejemplo 1: Agentes de Ventas
Disen˜ e un programa que lea y almacene las ventas realizadas por unos agentes de
ventas, de tal forma que se eliminen aquellos agentes cuyas ventas sean inferiores a la media de
las ventas realizadas.
//----------------------------------------------------------------- -
#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Agente {
string nombre;
double ventas;
};

typedef vector<Agente> VAgentes;

void leer (VAgentes& v)

{
v.clear();
Agente a;
cout << "Introduzca Nombre: ";
getline(cin, a.nombre);
while (( ! cin.fail()) && (a.nombre.size() > 0))
{ cout << "Introduzca Ventas: ";
cin >> a.ventas;
cin.ignore(1000, ’\n’);
v.push_back(a);
cout << "Introduzca Nombre: ";

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

16.4. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO 3
CONTENEDORES
getline(cin, a.nombre);
}
}

double media(const VAgentes& v)

{
double suma=0.0;
for (unsigned i = 0; i < v.size(); ++i) {
suma += v[i].ventas;
}
return suma/double(v.size());
}

void eliminar(VAgentes& v, double media)

{
unsigned i = 0;
while (i < v.size()) {
if (v[i].ventas < media)
{ v[i] = v[v.size()-1];
v.pop_back();
} else {
++i;
}
}
}

void eliminar_ordenado(VAgentes& v, double media)

{
unsigned k = 0;
for (unsigned i = 0; i < v.size(); ++i)
{ if(v[i].ventas >= media) {
if(i != k) {
v[k] = v[i];
}
++k;
}
}
v.resize(k);
}

void imprimir(const VAgentes& v)

{
for (unsigned i = 0; i < v.size(); ++i) {
cout << v[i].nombre << " " << v[i].ventas << endl;
}
}

int main ()
{
VAgentes v;
leer(v);
eliminar(v, media(v));
imprimir(v);
}
//----------------------------------------------------------------- -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4CAP´ITULO 16. INTRODUCCIO´ N A LOS CONTENEDORES DE LA BIBLIOTECA ESTA´ NDAR (STL)

Ejemplo 2: Multiplicaci´on de Matrices

Disen˜e un programa que lea dos matrices de taman˜os arbitrarios y muestre el resultado de
multiplicar ambas matrices.
//----------------------------------------------------------------- -
#include <vector>
#include <iostream>
#include <iomanip>
using namespace std;

typedef vector <double> Fila;

typedef vector <Fila> Matriz;

void imprimir(const Matriz& m)

{
for (unsigned f = 0; f < m.size(); ++f ) {
for (unsigned c = 0; c < m[f].size(); ++c)
{ cout << setw(10) << setprecision(4)
<< m[f][c] << " ";
}
cout << endl;
}
}

void leer(Matriz& m)
{
unsigned nf, nc;
cout << "Introduzca el numero de filas: ";
cin >> nf;
cout << "Introduzca el numero de columnas: ";
cin >> nc;
m = Matriz(nf, Fila (nc));
cout << "Introduzca los elementos: " << endl;
for (unsigned f = 0; f < m.size(); ++f){
for (unsigned c = 0; c < m[f].size(); ++c)
{ cin >> m[f][c];
}
}
}

// otra opci´on m ´a s efciente para la lectura de vectores

void leer_2(Matriz& m)
{
unsigned nf, nc;
cout << "Introduzca el numero de filas: ";
cin >> nf;
cout << "Introduzca el numero de columnas: ";
cin >> nc;
Matriz aux(nf, Fila (nc));
cout << "Introduzca los elementos: " << endl;
for (unsigned f = 0; f < aux.size(); ++f ){
for (unsigned c = 0; c < aux[f].size(); ++c){
cin >> aux[f][c];
}
}
m.swap(aux);
}

void multiplicar(const Matriz& m1, const Matriz& m2, Matriz& m3)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

16.4. RESOLUCIO´ N DE PROBLEMAS UTILIZANDO 5
CONTENEDORES
{
m3.clear();
if ((m1.size() > 0) && (m2.size() > 0) && (m2[0].size() > 0)
&& (m1[0].size() == m2.size())){
Matriz aux(m1.size(), Fila(m2[0].size()));
for (unsigned f = 0; f < aux.size(); ++f){
for (unsigned c = 0; c < aux[f].size(); ++c){
double suma = 0.0;
for (unsigned k = 0; k < m2.size(); ++k)
{ suma += m1[f][k] * m2[k][c];
}
aux[f][c] = suma;
}
}
m3.swap(aux);
}
}

int main()
{
Matriz m1, m2, m3;
leer(m1);
leer(m2);
multiplicar(m1, m2, m3);
if (m3.size() == 0) {
cout << "Error en la multiplicaci´on de Matrices" << endl;
} else {
imprimir(m3);
}
}
//----------------------------------------------------------------- -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Parte III

Programacio´n Avanzada

233
 235

A PARTIR DE ESTE PUNTO,

EL TEXTO NECESITA SER
REVISADO EN
PROFUNDIDAD.
EN EL ESTADO ACTUAL, SE
ENCUENTRA EN UNA VERSIO
´ N PRELIMINAR

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

236

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 17

Programacio´n Orientada a Objetos

#include <iostream>
using namespace std;
//------------------------------------
//------------------------------------
class Cloneable
{ public:
virtual Cloneable* clone() const =0;
};
//------------------------------------
class Volador { // : public virtual XXX
public:
virtual void despega() =0;
virtual void vuela(int ix, int iy) =0;
virtual void aterriza() =0;
};
//------------------------------------
class Insectivoro {
public:
virtual void comer() =0;
};
//------------------------------------
//------------------------------------
class Animal : public virtual Cloneable {
public:
virtual ~Animal() {
cout << "Muerto en ";
print();
}
virtual void print() const {
cout << "[ " << x << ", " << y << " ]" << endl;
}
virtual void mover(int ix, int iy)
{ x += ix; y += iy;
}
virtual void comer() =0;
protected:
Animal(int _x = 0, int _y = 0) : x(_x), y(_y)
{ cout << "Nace en ";
print();
}
Animal(const Animal& a) : x(a.x), y(a.y) { // C++0x
cout << "Nace en ";
print();

237
1 CAP´ITULO 17. PROGRAMACIO´ N ORIENTADA A
OBJETOS
}
private:
int x, y;
const Animal& operator=(const Animal& o);
};
//------------------------------------
class Mamifero : public Animal {
public:
virtual void mover(int ix, int iy) {
cout << "Andando" << endl;
Animal::mover(ix, iy);
}
virtual void print() const
{ cout << "Estoy en ";
Animal::print();
}
};
//------------------------------------
class Murcielago : public Mamifero,
public virtual Volador, public virtual Insectivoro {
public:
Murcielago() : Mamifero() {}
virtual Murcielago* clone() const {
return new Murcielago(*this);
}
virtual void mover(int ix, int iy)
{ cout << "Volando" << endl;
Animal::mover(ix, iy);
}
virtual void comer() {
cout << "Comiendo mosquitos ";
Animal::print();
}
virtual void despega() {
cout << "Despega ";
Animal::print();
}
virtual void vuela(int ix, int iy)
{ mover(ix, iy);
}
virtual void aterriza() {
cout << "Aterriza ";
Animal::print();
}
protected:
Murcielago(const Murcielago& o) : Mamifero(o) {}
};
//------------------------------------
//------------------------------------
int main()
{
Murcielago* m = new Murcielago();
m->despega();
m->vuela(5, 7);
m->comer();
m->aterriza();
m->print();
Animal* a = m->clone();
a->mover(11, 13);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 239

a->comer();
a->print();
Murcielago* m2 = dynamic_cast<Murcielago*>(a);
if (m2 != NULL) {
m2->vuela(5, 7);
}
delete m;
delete a;
}
//------------------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 17. PROGRAMACIO´ N ORIENTADA A
OBJETOS

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 18

Memoria Din´amica Avanzada

18.1. Memoria Din´amica de Agregados

Otra posibilidad consiste en solicitar memoria din´amica para un agregado de elementos. En
tal caso, se genera un puntero al primer elemento del agregado, siendo el tipo devuelto por el
operador new un puntero al tipo base. Por ejemplo para solicitar un agregado de 20 Personas:
typedef Persona* AD_Personas;
const int N_PERS = 20;

AD_Personas pers = new Persona[N_PERS];

accedemos a cada elemento de igual forma como si fuera un agregado normal:

pers[i].nombre
pers[i].fec_nacimiento
........

Para liberar un agregado din´amico previamente solicitado:

delete [] pers;

Nota: En el caso de punteros, no hay diferencia en el tipo entre un puntero a un elemento simple,
y un puntero a un agregado de elementos, por lo que ser´a el propio programador el responsable
de diferenciarlos, y de hecho liberarlos de formas diferentes (con los corchetes en caso de
agregados). Una posibilidad para facilitar dicha tarea al programador consiste en definir el tipo
de tal forma que indique que es un agregado din´amico, y no un puntero a un elemento.

Paso de Par´ametros de Variables de Tipo Puntero a Agregado

Respecto al paso de agregados din´amicos como par´ametros, y con objeto de diferenciar el
paso de un puntero a una variable del paso de un puntero a un agregado, el paso de agregados din
´amicos se realizar´a como el paso de un agregado abierto (constante o no), incluyendo o no,
dependiendo de su necesidad el nu´mero de elementos del agregado, como se indica a
continuaci´on:
int ad_enteros[] // agregado din´amico de enteros
const int adc_enteros[] // agregado din´amico constante de enteros

Ejemplo:
#include <iostream>
typedef int* AD_Enteros;

void leer(int n, int numeros[])

{

241
 1 CAP´ITULO 18. MEMORIA DINA´ MICA
AVANZADA
cout << "Introduce " << n << " elementos " << endl;
for (int i = 0; i < n; ++i) {
cin >> numeros[i];
}
}
double media(int n, const int numeros[])
{
double suma = 0.0;
for (int i = 0; i < n; ++i) {
suma += numeros[i];
}
return suma / double(n);
}
int main()
{
int nelm;
AD_Enteros numeros; // agregado din´amico

cout << "Introduce el n´umero de elementos ";

cin >> nelm;
numeros = new int[nelm];
leer(nelm, numeros);
cout << "Media: " << media(nelm, numeros) << endl;
delete [] numeros;
}

18.2. Punteros a Subprogramas

Es posible, as´ı mismo, declarar punteros a funciones:
typedef void (*PtrFun)(int dato);

void imprimir_1(int valor)

{
cout << "Valor: " << valor << endl;
}

void imprimir_2(int valor)

{
cout << "Cuenta: " << valor << endl;
}

int main()
{
PtrFun salida; // vble puntero a funci´on (devuelve void y recibe int)

salida = imprimir_1; // asigna valor al puntero

salida(20); // llamada. no es necesario utilizar (*salida)(20);

salida = imprimir_2; // asigna valor al puntero

salida(20); // llamada. no es necesario utilizar (*salida)(20);

}

18.3. Punteros Inteligentes

auto_ptr<...> unique_ptr<...>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

18.3. PUNTEROS INTELIGENTES 243

shared_ptr<...> weak_ptr<......>
otros definidos por los usuarios

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 18. MEMORIA DINA´ MICA
AVANZADA

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 19

Tipos Abstractos de Datos

Avanzados

19.1. Punteros a Miembros

Punteros a miembros de clases (atributos y m´etodos). N´otese los par´entesis en la “llamada a
trav´es de puntero a miembro” por cuestiones de precedencia.

#include <iostream>
using namespace std;

struct Clase_X {
int v;
void miembro() { cout << v << " " << this << endl; }
};

typedef void (Clase_X::*PointerToClaseXMemberFunction) ();

typedef int Clase_X::*PointerToClaseXMemberAttr;

int main()
{
PointerToClaseXMemberFunction pmf = &Clase_X::miembro;
PointerToClaseXMemberAttr pma = &Clase_X::v;

Clase_X x;

x.*pma = 3; // acceso a traves de puntero a miembro

x.miembro(); // llamada directa a miembro
(x.*pmf)(); // llamada a traves de puntero a miembro

Clase_X* px = &x;

px->*pma = 5; // acceso a traves de puntero a miembro

px->miembro(); // llamada directa a miembro
(px->*pmf)(); // llamada a traves de puntero a miembro
}

19.2. Ocultar la Implementaci´on

Aunque C++ no soporta directamente tipos opacos, dicha caracter´ıstica se puede simular muy f
´acilmente con las herramientas que C++ ofrece. Hay dos corrientes principales a la hora de

245
19.2. OCULTAR LA IMPLEMENTACIO´ N 1

solucionar el problema, aunque hay otras menores que no comentaremos:

Puntero a la Implementaci´on
// elem.hpp
#ifndef _elem_hpp_
#define _elem_hpp_
namespace elem {
class Elem {
public:
~Elem() throw();
Elem();
Elem(const Elem& o);
Elem& operator=(const Elem& o);
int get_val() const;
void set_val(int);
void swap(Elem& o);
private:
class ElemImpl;
ElemImpl* pimpl;
};// class Elem
} //namespace elem
#endif
// main.cpp
#include <iostream>
#include "elem.hpp"
using namespace std;
using namespace elem;
int main()
{
Elem e;
e.set_val(7);
cout << e.get_val() << endl;
Elem e2(e);
e2.set_val(e2.get_val()+2);
cout << e2.get_val() << endl;
e2 = e;
cout << e2.get_val() << endl;
}
// elem.cpp
#include "elem.hpp"
#include <iostream>
using namespace std;
namespace elem {
class Elem::ElemImpl {
public:
~ElemImpl() throw() { cout << "destrucci´on de: " << val << endl; }
ElemImpl() : val(0) {}
//ElemImpl(const Elem& o) : val(o.val) {}
//ElemImpl& operator=(const ElemImpl& o) { val = o.val; return *this; }
int get_val() const { return val; }
void set_val(int v) { val = v; }
private:
int val;
};// class ElemImpl
Elem::~Elem() throw()
{
delete pimpl;
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 19. TIPOS ABSTRACTOS DE DATOS AVANZADOS

Elem::Elem()
: pimpl(new ElemImpl)
{}
Elem::Elem(const Elem& o)
: pimpl(new ElemImpl(*o.pimpl))
{}
Elem& Elem::operator=(const Elem& o)
{
if (this != &o) {
Elem(o).swap(*this);
}
return *this;
}
int Elem::get_val() const
{
return pimpl->get_val();
}
void Elem::set_val(int v)
{
pimpl->set_val(v);
}
void Elem::swap(Elem& o)
{
ElemImpl* aux = o.pimpl;
o.pimpl = pimpl;
pimpl = aux;
}
}// namespace elem
// fin

Puntero a la Implementaci´on
//- complejo.hpp
#ifndef _complejo_hpp_
#define _complejo_hpp_
#include <iostream>
namespace umalcc {
class Complejo
{ public:
~Complejo();
Complejo();
Complejo(double r, double i);
Complejo(const Complejo& c);
Complejo& operator=(const Complejo& c);
double get_real() const;
double get_imag() const;
Complejo& operator+=(const Complejo& c);
Complejo& swap(Complejo& c);
private:
struct Hidden* impl;
};
inline Complejo operator+(const Complejo& c1, const Complejo& c2) {
Complejo res = c1;
res += c2;
return res;
}
inline std::ostream& operator<<(std::ostream& out, const Complejo& c)
{ out << "[ " << c.get_real() << "," << c.get_imag() << " ]";
return out;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

19.2. OCULTAR LA IMPLEMENTACIO´ N 3

}
}// namespace umalcc
#endif
//- main.cpp
#include <iostream>
#include <string>
#include "complejo.hpp"
using namespace std;
using namespace umalcc;

int main()
{
Complejo c1;
Complejo c2;
Complejo c3 = c1 + c2;
cout << c1 << " " << c2 << " " << c3 << endl;
c3 += Complejo(4, 5);
cout << c3 << endl;
c3 = Complejo(411, 535);
cout << c3 << endl;
}
//- complejo.cpp
#include "complejo.hpp"
namespace umalcc {
struct Hidden {
double real, imag;
};
Complejo::~Complejo() {
delete impl;
}
Complejo::Complejo() : impl() {}
Complejo::Complejo(double r, double i) : impl() {
impl = new Hidden;
impl->real = r;
impl->imag = i;
}
Complejo::Complejo(const Complejo& c) : impl() {
if (c.impl != NULL) {
impl = new Hidden;
impl->real = c.impl->real;
impl->imag = c.impl->imag;
}
}
Complejo& Complejo::operator=(const Complejo& c) {
if (this != &c) {
Complejo(c).swap(*this);
}
return *this;
}
Complejo& Complejo::swap(Complejo& c) {
swap(impl, c.impl);
}
double Complejo::get_real() const {
return (impl == NULL) ? 0.0 : impl->real;
}
double Complejo::get_imag() const {
return (impl == NULL) ? 0.0 : impl->imag;
}
Complejo& Complejo::operator+=(const Complejo& c) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 19. TIPOS ABSTRACTOS DE DATOS AVANZADOS

if (impl == NULL) {
*this = c;
} else {
impl->real += c.get_real();
impl->imag += c.get_imag();
}
return *this;
}
}// namespace umalcc
//------------------------------------------------------------------- -

Base Abstracta
// elem.hpp
#ifndef _elem_hpp_
#define _elem_hpp_
namespace elem {
class Elem {
public:
static Elem* create();
virtual Elem* clone() const = 0;
virtual ~Elem() throw();
virtual int get_val() const = 0;
virtual void set_val(int) = 0;
};// class Elem
} //namespace elem
#endif
// main.cpp
#include <iostream>
#include <memory>
#include "elem.hpp"
using namespace std;
using namespace elem;
int main()
{
auto_ptr<Elem> e(Elem::create());
e->set_val(7);
cout << e->get_val() << endl;
auto_ptr<Elem> e2(e->clone());
e2->set_val(e2->get_val()+2);
cout << e2->get_val() << endl;
e2 = auto_ptr<Elem>(e->clone());
cout << e2->get_val() << endl;
}
// elem.cpp
//#include "elem.hpp"
#include <iostream>
using namespace std;
namespace {
class ElemImpl : public elem::Elem
{ public:
virtual ElemImpl* clone() const { return new ElemImpl(*this); }
virtual ~ElemImpl() throw()
{ cout << "destrucci´on de: " << val << endl; }
ElemImpl() : _ClaseBase(), val(0) {}
//ElemImpl(const Elem& o) : _ClaseBase(o), val(o.val) {}
//ElemImpl& operator=(const ElemImpl& o) { val = o.val; return *this; }
virtual int get_val() const { return val; }
virtual void set_val(int v) { val = v; }

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

19.2. OCULTAR LA IMPLEMENTACIO´ N 5

private:
typedef elem::Elem _ClaseBase;
int val;
};// class ElemImpl
}
namespace elem {
Elem* Elem::create() { return new ElemImpl(); }
Elem::~Elem() throw() {}
}// namespace elem
// fin

19.3. Control de Elementos de un Contenedor

En esta secci´on veremos como acceder a elementos de un contenedor definido por nosotros, pero
manteniendo el control sobre las operaciones que se realizan sobre el mismo:

// matriz.hpp
#ifndef _matriz_hpp_
#define _matriz_hpp_
/*
* Matriz Dispersa
*
* Definici´on de tipos
*
* typedef Matriz<int> Mat_Int;
*
* Definici´on de Variables
*
* Mat_Int mat(NFIL, NCOL);
*
* Definici´on de Constantes
*
* const Mat_Int aux2(mat);
*
* Operaciones
*
* aux1 = mat; // asignaci´on
* print(mat); // paso de par´ametros
* unsigned nfil = mat.getnfil(); // n´umero de filas
* unsigned ncol = mat.getncol(); // n´umero de columnas
* unsigned nelm = mat.getnelm(); // n´umero de elementos almacenados
* mat(1U, 3U) = 4; // asignaci´on a elemento
* x = mat(1U, 3U); // valor de elemento
*
* Excepciones
*
* OutOfRange
*/
#include <map>
#include <iterator>

namespace matriz {

class OutOfRange {};

template <typename Tipo>

class Ref_Elm;
template <typename Tipo>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

19.3. CONTROL DE ELEMENTOS DE UN CONTENEDOR 1

class RefC_Elm;

// Matriz
template <typename Tipo>
class Matriz {
private:
friend class Ref_Elm<Tipo>;
friend class RefC_Elm<Tipo>;
//
typedef Tipo Tipo_Elm;
typedef Ref_Elm<Tipo_Elm> Tipo_Ref_Elm;
typedef RefC_Elm<Tipo_Elm> Tipo_RefC_Elm;

typedef std::map<unsigned,Tipo_Elm> Lista_Elm;

typedef std::map<unsigned,Lista_Elm> Lista_Fila;

typedef typename Lista_Elm::iterator ItElm;

typedef typename Lista_Fila::iterator ItFil;
typedef typename Lista_Elm::const_iterator ItCElm;
typedef typename Lista_Fila::const_iterator ItCFil;
// atributos
unsigned nfil;
unsigned ncol;
Lista_Fila elm;
public:
Matriz(unsigned nf, unsigned nc) : nfil(nf ), ncol(nc) {}
unsigned getnfil() const { return nfil; }
unsigned getncol() const { return ncol; }
unsigned size() const;
unsigned getnfilalm() const { return elm.size(); }//DEBUG
const Tipo_RefC_Elm operator() (unsigned f, unsigned c) const
throw(OutOfRange);
Tipo_Ref_Elm operator() (unsigned f, unsigned c)
throw(OutOfRange);
};// class Matriz
// RefC_Elm
template <typename Tipo>
class RefC_Elm {
private:
friend class Matriz<Tipo>;
//
typedef Tipo Tipo_Elm;
typedef Matriz<Tipo_Elm> Matriz_Elm;
//
const Matriz_Elm* mat;
unsigned fil;
unsigned col;
//
RefC_Elm(const Matriz_Elm* m, unsigned f, unsigned c)
: mat(m), fil(f ), col(c) {}
public:
operator Tipo_Elm () const;
};// class RefC_Elm
// Ref_Elm
template <typename Tipo>
class Ref_Elm {
private:
friend class Matriz<Tipo>;
//

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 19. TIPOS ABSTRACTOS DE DATOS AVANZADOS

typedef Tipo Tipo_Elm;

typedef Matriz<Tipo_Elm> Matriz_Elm;
//
Matriz_Elm* mat;
unsigned fil;
unsigned col;
//
Ref_Elm(Matriz_Elm* m, unsigned f, unsigned c)
: mat(m), fil(f ), col(c) {}
void eliminar_elemento_si_existe();
public:
Ref_Elm& operator=(const Tipo_Elm& e);
operator RefC_Elm<Tipo> () const;
};// class Ref_Elm
// Matriz
template <typename Tipo>
const typename Matriz<Tipo>::Tipo_RefC_Elm
Matriz<Tipo>::operator() (unsigned f, unsigned c) const throw(OutOfRange)
{
if ((f >= nfil)||(c >= ncol)) {
throw OutOfRange();
}
return Tipo_RefC_Elm(this, f, c);
}
template <typename Tipo>
typename Matriz<Tipo>::Tipo_Ref_Elm
Matriz<Tipo>::operator() (unsigned f, unsigned c) throw(OutOfRange)
{
if ((f >= nfil)||(c >= ncol)) {
throw OutOfRange();
}
return Tipo_Ref_Elm(this, f, c);
}

template <typename Tipo>

unsigned Matriz<Tipo>::size() const
{
unsigned nelm = 0;
for (ItCFil i = elm.begin(); i != elm.end(); ++i)
{ nelm += i->second.size();
}
return nelm;
}
// RefC_Elm
template <typename Tipo>
RefC_Elm<Tipo>::operator typename RefC_Elm<Tipo>::Tipo_Elm () const
{
typedef typename Matriz_Elm::ItCElm ItCElm;
typedef typename Matriz_Elm::ItCFil ItCFil;

ItCFil itfil = mat->elm.find(fil);

if (itfil == mat->elm.end()) {
return Tipo_Elm();
} else {
ItCElm itelm = itfil->second.find(col);
if (itelm == itfil->second.end()) {
return Tipo_Elm();
} else {
return itelm->second;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

19.3. CONTROL DE ELEMENTOS DE UN CONTENEDOR 3

}
}
}
// Ref_Elm
template <typename Tipo>
Ref_Elm<Tipo>::operator RefC_Elm<Tipo> () const
{
return RefC_Elm<Tipo>(mat, fil, col);
}
template <typename Tipo>
Ref_Elm<Tipo>& Ref_Elm<Tipo>::operator=(const Tipo_Elm& e)
{
if (e == Tipo_Elm()) {
eliminar_elemento_si_existe();
} else {
typename Matriz_Elm::Lista_Elm& fila = mat->elm[fil];
fila[col] = e;
}
return *this;
}
template <typename Tipo>
void Ref_Elm<Tipo>::eliminar_elemento_si_existe()
{
typedef typename Matriz_Elm::ItElm ItElm;
typedef typename Matriz_Elm::ItFil ItFil;

ItFil itfil = mat->elm.find(fil);

if (itfil != mat->elm.end()) {
ItElm itelm = itfil->second.find(col);
if (itelm != itfil->second.end()) {
itfil->second.erase(itelm);
if (itfil->second.empty()) {
mat->elm.erase(itfil);
}
}
}
}
//---------------------------------------------- -
} //namespace matriz
#endif
// main.cpp
#include <iostream>
#include <string>

#include "matriz.hpp"

using namespace std;

using namespace matriz;

typedef Matriz<int> Mat_Int;

const unsigned NFIL = 5U;

const unsigned NCOL = 6U;

void
print(const Mat_Int& mat)
{
cout << "N´umero de filas reales: " << mat.getnfilalm() << endl;
cout << "N´umero de elementos almacenados: " << mat.size() << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 19. TIPOS ABSTRACTOS DE DATOS AVANZADOS

for (unsigned f = 0; f < mat.getnfil(); ++f ) {

for (unsigned c = 0; c < mat.getncol(); ++c)
{ cout << mat(f,c) << " ";
}
cout << endl;
}
cout << endl;
}
int
main()
{
try {
Mat_Int mat(NFIL,NCOL);

mat(1U, 3U) = 4;
mat(2U, 2U) = 5;
mat(1U, 1U) = 3;

print(mat);

Mat_Int aux1(NFIL,NCOL);
aux1 = mat;
aux1(2U, 2U) = 0;// elimina un elemento y una fila
print(aux1);

const Mat_Int aux2(mat);

print(aux2);
//aux2(1U, 1U) = 3;// Error de compilaci´on

// Fuera de Rango
mat(NFIL, NCOL) = 5;
} catch ( OutOfRange ) {
cerr << "excepci´on fuera de rango" << endl;
} catch ( ... ) {
cerr << "excepci´on inesperada" << endl;
}
}
// fin

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 20

Programacio´n Gen´erica Avanzada

Las plantillas (“templates” en ingl´es) son u´tiles a la hora de realizar programaci´on gen
´erica. Esto es, definir clases y funciones de forma gen´erica que se instancien a tipos particulares en
funci´on de la utilizaci´on de ´estas.
Los par´ametros de las plantillas podr´an ser tanto tipos como valores constantes. Veamos
un ejemplo de definiciones de funciones gen´ericas:

20.1. Par´ametros Gen´ericos por Defecto

template <typename T, typename C = deque<T> >
class Stack {
// ...
};

template <typename T, unsigned SIZE=512>

class Array {
// ...
};

20.2. Tipos dentro de Clases Gen´ericas

template <typename Tipo>
class Dato {
typedef array<Tipo,64> Array;
// ...
};

template <typename Tipo>

class XXX {
typedef typename Dato<Tipo>::Array Array;
// ...
};

20.3. M´etodos de Clase Gen´ericos

cuando usar template en la utilizaci´on de un m´etodo gen´erico.
template <typename Tipo>
class Dato {
template <typename T>
T metodo(const Tipo& x) {

255
 1 CAP´ITULO 20. PROGRAMACIO´ N GENE´ RICA
AVANZADA
return T(x);
}
// ...
};
int main()
{
Dato<int> d;
double z = d.template metodo<double>(3);
}

template <unsigned IDX,

typename Tipo>
inline const
typename Dato<Tipo>::template Type<IDX>::type &
member(const Dato<Tipo>& m,
const typename Dato<Tipo>::template Type<IDX>::type& a)
{ return m.template metodo<IDX>(a);
}

20.4. Amigos Gen´ericos

//-fichero: subrango.hpp
#include <iostream>
#include <stdexcept>
namespace umalcc {
// Declaraci´on adelantada de la clase Subrango
template<typename Tipo, Tipo menor, Tipo mayor>
class Subrango;

// Prototipo del operador de salida para la clase Subrango

template<typename Tipo, Tipo menor, Tipo mayor>
std::ostream& operator <<(std::ostream&, const Subrango<Tipo, menor, mayor>&);
template<typename Tipo, Tipo menor, Tipo mayor>
std::istream& operator >>(std::istream&, Subrango<Tipo, menor, mayor>&);

template<typename Tipo, Tipo menor, Tipo mayor>

class Subrango {
public:
Subrango();
Subrango(const T_Base& i);
operator T_Base();
friend std::ostream& operator << <>(std::ostream&, const Subrango<Tipo, menor, mayor>&);
friend std::istream& operator >> <>(std::istream&, Subrango<Tipo, menor, mayor>&);
private:
typedef Tipo T_Base;
// -- Atributos --
T_Base valor;
};

template<typename Tipo, Tipo menor, Tipo mayor>

std::ostream& operator <<(std::ostream& sal,const Subrango<Tipo,menor,mayor>& i)
{
return sal << i.valor;
}

template<typename Tipo, Tipo menor, Tipo mayor>

std::istream& operator >>(std::istream& in, Subrango<Tipo,menor,mayor>& i)
{
Tipo val;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 20.5. RESTRICCIONES EN PROGRAMACIO´ N GENE´ RICA 257

in >> val;
i = val;
return in;
}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::Subrango()
: valor(menor)
{}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::Subrango(const T_Base& i)
: valor(i)
{
if ((valor < menor) || (valor > mayor)) {
throw std::range_error("Subrango::Subrango range error");
}
}

template<typename Tipo, Tipo menor, Tipo mayor>

Subrango<Tipo,menor,mayor>::operator Tipo()
{
return valor;
}
}
//-fin: subrango.hpp

20.5. Restricciones en Programaci´on Gen´erica

En programaci´on gen´erica puede ser conveniente especificar un conjunto de restricciones
sobre los tipos gen´ericos que pueden ser instanciados en diferentes clases o funciones:

// constraint.hpp
// Tomado de: B. Stroustrup Technical FAQ
#ifndef _constraint_hpp_
#define _constraint_hpp_
#ifndef _UNUSED_
#ifdef GNUC
#define _UNUSED_ attribute ((unused))
#else
#define _UNUSED_
#endif
#endif
namespace constraint {
template<typename T, typename B> struct Derived_From {
static void constraints(T* p) { B* pb = p; }
Derived_From() { void(*p)(T*) _UNUSED_ = constraints; }
};
template<typename T1, typename T2> struct Can_Copy {
static void constraints(T1 a, T2 b) { T2 c = a; b = a; }
Can_Copy() { void(*p)(T1,T2) _UNUSED_ = constraints; }
};
template<typename T1, typename T2 = T1> struct Can_Compare
{ static void constraints(T1 a, T2 b) { a==b; a!=b; a<b; }
Can_Compare() { void(*p)(T1,T2) _UNUSED_ = constraints; }
};
template<typename T1, typename T2, typename T3 = T1> struct Can_Multiply {
static void constraints(T1 a, T2 b, T3 c) { c = a*b; }

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 20. PROGRAMACIO´ N GENE´ RICA
AVANZADA
Can_Multiply() { void(*p)(T1,T2,T3) _UNUSED_ = constraints; }
};
template<typename T1> struct Is_Vector {
static void constraints(T1 a) { a.size(); a[0]; }
Is_Vector() { void(*p)(T1) _UNUSED_ = constraints; }
};
} //namespace constraint
#ifdef _UNUSED_
#undef _UNUSED_
#endif
// ~constraint.hpp

Un ejemplo de su utilizaci´on:
#include <iostream>
using namespace std;

struct B { };
struct D : B { };
struct DD : D { };
struct X { };

// Los elementos deben ser derivados de ’ClaseBase’

template<typename T>
class Container : Derived_from<T,ClaseBase> {
// ...
};

template<typename T>
class Nuevo : Is_Vector<T> {
// ...
};

int main()
{
Derived_from<D,B>();
Derived_from<DD,B>();
Derived_from<X,B>();
Derived_from<int,B>();
Derived_from<X,int>();

Can_compare<int,double>();
Can_compare<X,B>();
Can_multiply<int,double>();
Can_multiply<int,double,double>();
Can_multiply<B,X>();

Can_copy<D*,B*>();
Can_copy<D,B*>();
Can_copy<int,B*>();
}

20.6. Especializaciones
Veamos otro ejemplo de una definici´on gen´erica (tomado de GCC 3.3) con especializaci´on:

//-fichero: stl_hash_fun.hpp
namespace gnu_cxx {
using std::size_t;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 20.7. META-PROGRAMACIO´ N 259

// definici´on de la clase generica vac´ıa

template <typename _Key>
struct hash { };

inline size_t stl_hash_string(const char* s)

{
unsigned long h = 0;
for ( ; * s; ++ s) {
h = 5* h + * s;
}
return size_t( h);
}
// especializaciones
template<> struct hash<char*> {
size_t operator () (const char* s) const
{ return stl_hash_string( s); }
};
template<> struct hash<const char*> {
size_t operator () (const char* s) const
{ return stl_hash_string( s); }
};
template<> struct hash<char> {
size_t operator () (char x) const
{ return x; }
};
template<> struct hash<int> {
size_t operator () (int x) const
{ return x; }
};
template <> struct hash<string> {
size_t operator () (const string& str) const
{ return stl_hash_string(str.c_str()); }
};

} // namespace gnu_cxx
//-fin: stl_hash_fun.hpp

Una posible ventaja de hacer esta especializaci´on sobre un tipo que sobre una funci´on, es que
la funci´on estar´a definida para cualquier tipo, y ser ´a en tiempo de ejecuci´on donde rompa si
se utiliza sobre un tipo no v´alido. De esta forma, es en tiempo de compilaci´on cuando falla.
Otra ventaja es que puede ser pasada como par´ametro a un “template”.

20.7. Meta-programacio´n
template <unsigned X, unsigned Y>
struct GcdX {
static const unsigned val = (Y==0)?X:GcdX<Y, X%Y>::val ;
};
template <unsigned X>
struct GcdX<X,0> {
static const unsigned val = X;
};
template <unsigned X, unsigned Y>
struct Gcd {
static const unsigned val = (X>=Y)?GcdX<X,Y>::val:GcdX<Y,X>::val ;
};

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 20. PROGRAMACIO´ N GENE´ RICA
AVANZADA
20.8. SFINAE

//-------------------------------------------------------------------------
#ifndef _sfinae_hpp_
#define _sfinae_hpp_
namespace umalcc {
//---------------------------------------------------------------- -
// SFINAE ("Substitution Failure Is Not An Error" principle)
//------------------------------------
// has member type: type
template<typename Tipo>
class has_type_type {
public:
enum { value = (sizeof(test<Tipo>(0)) == sizeof(Yes)) };
private:
struct Yes { char a[1]; };
struct No { char a[2]; };
template <typename TT> class Helper{};
template<typename TT> static Yes test(Helper<typename TT::type> const*);
template<typename TT> static No test(...);
};
//---------------------------------------------------------------- -
// has member data: int value
template <typename Tipo>
class has_data_value {
public:
enum { value = (sizeof(test<Tipo>(0)) == sizeof(Yes)) };
private:
struct Yes { char a[1]; };
struct No { char a[2]; };
template <typename TT, TT t> class Helper{};
template<typename TT> static Yes test(Helper<int TT::*, &TT::value> const*);
template<typename TT> static No test(...);
};
//---------------------------------------------------------------- -
// has static member data: static int value
template <typename Tipo>
class has_static_value {
public:
enum { value = (sizeof(test<Tipo>(0)) == sizeof(Yes)) };
private:
struct Yes { char a[1]; };
struct No { char a[2]; };
template <typename TT, TT t> class Helper{};
template<typename TT> static Yes test(Helper<int *, &TT::value> const*);
template<typename TT> static No test(...);
};
//---------------------------------------------------------------- -
// has member function: RT foo()
template <typename Tipo>
class has_function_foo
{ public:
enum { value = (sizeof(test<Tipo>(0)) == sizeof(Yes)) };
private:
struct Yes { char a[1]; };
struct No { char a[2]; };
template <typename TT, TT t> class Helper{};
template<typename TT> static Yes test(Helper<void (TT::*)(), &TT::foo> const*);
template<typename TT> static No test(...);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

20.8. SFINAE 261

};
//---------------------------------------------------------------- -
} //namespace umalcc
#endif

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 20. PROGRAMACIO´ N GENE´ RICA
AVANZADA

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 21

Buffer y Flujos de Entrada y

Salida

Como se vio anteriormente, para realizar operaciones de entrada y salida es necesario incluir
las definiciones correspondientes en nuestro programa. para ello realizaremos la siguiente acci´on al
comienzo de nuestro programa:
#include <iostream>
using namespace std;

Para declarar simplemente los nombres de tipos:

#include <iosfwd>

En este cap´ıtulo entraremos con m ´a s profundidad en las operaciones a realizar en la

entrada y salida, c´o m o controlar dichos flujos y comprobar su estado, as´ı como la entrada y salida
a ficheros.

21.1. Operaciones de Salida

Adem´as de las operaciones ya vistas, es posible aplicar las siguientes operaciones a los
flujos de salida:
cout.put(’#’); // imprime un car´acter
cout.write(char str[], int tam);// imprime ’tam’ caracteres del ’string’

int n = cout.pcount(); // devuelve el n´umero de caracteres escritos

cout.flush(); // fuerza la salida del flujo
cout.sync(); // sincroniza el buffer

{
ostream::sentry centinela(cout); // creaci´on del centinela en <<
if (!centinela) {
setstate(failbit);
return(cout);
}
...
}

21.2. Operaciones de Entrada

Adem´as de las vistas anteriormente (no las de salida), se pueden aplicar las siguientes opera-
ciones a los flujos de entrada:
Para leer un simple car´acter:

263
1 CAP´ITULO 21. BUFFER Y FLUJOS DE ENTRADA Y
SALIDA
int n = cin.get(); // lee un car´acter de entrada o EOF
cin.get(char& c); // lee un car´acter de entrada
int n = cin.peek(); // devuelve el prox car´acter (sin leerlo)

Para leer cadenas de caracteres (una l´ınea cada vez):

cin.get(char str[], int tam);

// lee un string como m´aximo hasta ’tam-1’ o hasta fin de l´ınea
// a~nade el terminador ’\0’ al final de str
// el car´acter de fin de l´ınea NO se elimina del flujo

cin.get(char str[], int tam, char delim);

// lee un string como m´aximo hasta ’tam-1’ o hasta que se lea ’delim’
// a~nade el terminador ’\0’ al final de str
// el car´acter delimitador NO se elimina del flujo

cin.getline(char str[], int tam);

// lee un string como m´aximo hasta ’tam-1’ o hasta fin de l´ınea
// a~nade el terminador ’\0’ al final de str
// el car´acter de fin de l´ınea SI se elimina del flujo

cin.getline(char str[], int tam, char delim);

// lee un string como m´aximo hasta ’tam-1’ o hasta que se lea ’delim’
// a~nade el terminador ’\0’ al final de str
// el car´acter delimitador SI se elimina del flujo

cin.read(char str[], int tam);

// lee ’tam’ caracteres y los almacena en el string
// NO pone el terminador ’\0’ al final del string

Tambi´en es posible leer un string mediante las siguientes operaciones.

cin >> str; // salta espacios y lee hasta espacios
getline(cin, str); // lee hasta fin de l´ınea (’\n’)
getline(cin, str, delimitador); // lee hasta encontrar el delim. especificado

N´otese que realizar una operaci´on getline despu´es de una operaci´on con >> puede tener
com- plicaciones, ya que >> dejara los separadores en el buffer, que ser´an le´ıdos por getline.
Para evitar este problema (leer´a una cadena que sea distinta de la vac´ıa):

void leer_linea_no_vacia(istream& ent, string& linea)

{
ent >> ws; // salta los espacios en blanco y rc’s
getline(ent, linea); // leer´a la primera l´ınea no vac´ıa
}

Tambi´en es posible leer un dato y eliminar el resto (separadores) del buffer de entrada.

template <typename Tipo>

void leer(istream& ent, Tipo& dato)
{
ent >> dato; // lee el dato
ent.ignore(numeric_limits<streamsize>::max(), ’\n’); // elimina los caracteres del buffer
}

Las siguientes operaciones tambi´en est´an disponibles.

int n = cin.gcount(); // devuelve el n´umero de caracteres leidos

cin.ignore([int n][, int delim]); // ignora cars hasta ’n’ o ’delim’
cin.unget(); // devuelve al flujo el ´ultimo car´acter leido

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 21.3. BUFFER 265

cin.putback(char ch); // devuelve al flujo el car´acter ’ch’

{
istream::sentry centinela(cin); // creaci´on del centinela en >>
if (!centinela) {
setstate(failbit);
return(cin);
}
...
}

std::ios::sync_with_stdio(false);

int n = cin.readsome(char* p, int n); // lee caracteres disponibles (hasta n)

n = cin.rdbuf()->in_avail(); // n´umero de caracteres disponibles en el buffer
cin.ignore(cin.rdbuf()->in_avail()); // elimina los caracteres del buffer

cin.sync(); // sincroniza el buffer

Para hacer que lance una excepci´on cuando ocurra algu´n error:

ios::iostate old_state = cin.exceptions();

cin.exceptions(ios::badbit | ios::failbit | ios::eofbit);
cout.exceptions(ios::badbit | ios::failbit | ios::eofbit);

la excepci´on lanzada es del tipo ios::failure.

21.3. Buffer
Se puede acceder al buffer de un stream, tanto para obtener su valor como para modificarlo.
El buffer es el encargado de almacenar los caracteres (antes de leerlos o escribirlos) y definen
adem´as su comportamiento. Es donde reside la inteligencia de los streams. Es posible la
redirecci´on de los streams gracias a los buffers (v´ease 21.4).

typedef basic_streambuf<ostream::char_type, ostream::traits_type> streambuf_type;

streambuf* pbuff1 = stream.rdbuf(); // obtener el ptr al buffer
streambuf* pbuff2 = stream.rdbuf(pbuff1); // actualizar y obtener el ptr anterior

Ejemplo donde se desactiva el buffer si el nivel de verbosidad no supera un umbral (v´ease

mas ejemplos en Secci´on 21.4):

//------------------------------------------------------------------------ -
//#include <iostream>
#include <iosfwd>
using namespace std;
//------------------------------------------------------------------------ -
namespace umalcc {
//-------------------------------------------------------------------- -
inline unsigned verbose_level(unsigned l = -1U)
{ static unsigned verb_level = 1;
unsigned res = verb_level;
if (l != -1U) {
verb_level = l;
}
return res;
}
//-------------------------------------------------------------------- -
namespace _verbose_ {
//---------------------------------------------------------------- -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 21. BUFFER Y FLUJOS DE ENTRADA Y
SALIDA
template <class cT, class traits = std::char_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{ return traits::not_eof(c); // indicate success
}
};
template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf ),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}
private:
basic_nullbuf<cT, traits> m_sbuf;
};
typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<wchar_t> wonullstream;
//---------------------------------------------------------------- -
inline std::ostream& verb(std::ostream& os, unsigned l)
{ static onullstream out;
if (l>verbose_level()) {
return out;
} else {
return os;
}
}
class VerboseMngr {
friend std::ostream& operator<< (std::ostream& out,
const class VerboseMngr& vm);
friend VerboseMngr umalcc::verbose(unsigned l);
unsigned lv;
VerboseMngr(unsigned l) : lv(l) {}
};
inline std::ostream& operator<< (std::ostream& out,
const VerboseMngr& vm) {
return verb(out, vm.lv);
}
} //namespace _verbose_
//-------------------------------------------------------------------- -
inline std::ostream& verb(unsigned l) {
return umalcc::_verbose_::verb(std::cerr, l);
}
inline umalcc::_verbose_::VerboseMngr verbose(unsigned l) {
return umalcc::_verbose_::VerboseMngr(l);
}
//-------------------------------------------------------------------- -
}
//------------------------------------------------------------------------ -
int main()
{
verbose_level(2);

cerr << verbose(0) << "Prueba-1 0" << endl;

cerr << verbose(1) << "Prueba-1 1" << endl;
cerr << verbose(2) << "Prueba-1 2" << endl;
cerr << verbose(3) << "Prueba-1 3" << endl;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

21.4. REDIRECCIO´ N TRANSPARENTE DE LA SALIDA ESTA´ NDAR A UN STRING 267

cerr << verbose(4) << "Prueba-1 4" << endl;

verb(0) << "Prueba-2 0" << endl;

verb(1) << "Prueba-2 1" << endl;
verb(2) << "Prueba-2 2" << endl;
verb(3) << "Prueba-2 3" << endl;
verb(4) << "Prueba-2 4" << endl;

cerr << verbose(0) << "Prueba-3 0" << endl;

cerr << verbose(1) << "Prueba-3 1" << endl;
cerr << verbose(2) << "Prueba-3 2" << endl;
cerr << verbose(3) << "Prueba-3 3" << endl;
cerr << verbose(4) << "Prueba-3 4" << endl;
}
//-------------------------------------------------------------------------

21.4. Redirecci´on Transparente de la Salida Est´andar a

un String
Para que de forma transparente la informaci´on que se env´ıa a la salida est´andar se capture
en un string:

// ostrcap.hpp
#ifndef _ostrcap_hpp_
#define _ostrcap_hpp_
#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>

namespace ostrcap {

class Capture_Error : public std::runtime_error {

public:
Capture_Error() : std::runtime_error ("Capture_Error") {}
Capture_Error(const std::string& arg) : std::runtime_error (arg) {}
};
class Release_Error : public std::runtime_error {
public:
Release_Error() : std::runtime_error ("Release_Error") {}
Release_Error(const std::string& arg) : std::runtime_error (arg) {}
};

class OStreamCapture {
public:
OStreamCapture()
: str_salida(), output_stream(), output_streambuf_ptr() {}
void capture(std::ostream& os) {
if (output_streambuf_ptr != NULL)
{ throw Capture_Error();
}
str_salida.str("");
output_stream = &os;
output_streambuf_ptr = output_stream->rdbuf(str_salida.rdbuf());
}
std::string release() {
if (output_streambuf_ptr == NULL) {
throw Release_Error();

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 21. BUFFER Y FLUJOS DE ENTRADA Y
SALIDA
}
output_stream->rdbuf(output_streambuf_ptr);
output_streambuf_ptr = NULL;
return str_salida.str();
}
private:
std::ostringstream str_salida;
std::ostream* output_stream;
std::streambuf* output_streambuf_ptr;
};// class OStreamCapture
} //namespace ostrcap
#endif
// main.cpp
#include <iostream>
#include <string>

#include "ostrcap.hpp"

using namespace std;

using namespace ostrcap;

void salida(int x)
{
cout << "Informaci´on " << x << endl;
}

int main()
{
OStreamCapture ostrcap;
ostrcap.capture(cout);
salida(34);
cout << "La salida es: " << ostrcap.release();

ostrcap.capture(cout);
salida(36);
cout << "La salida es: " << ostrcap.release();
}
// fin

21.5. Ficheros
Las operaciones vistas anteriormente sobre los flujos de entrada y salida est´andares se
pueden aplicar tambi´en sobre ficheros de entrada y de salida, simplemente cambiando las
variables cin y cout por las correspondientes variables que especifican cada fichero. Para ello es
necesario incluir la siguiente definici´on:

#include <fstream>

21.6. Ficheros de Entrada

Veamos como declaramos dichas variables para ficheros de entrada:

ifstream fichero_entrada; // declara un fichero de entrada

fichero_entrada.open(char nombre[] [, int modo]); // abre el fichero

donde los modos posibles, combinados con OR de bits (|):

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 21.7. FICHEROS DE SALIDA 269

ios::in // entrada
ios::out // salida
ios::app // posicionarse al final antes de cada escritura
ios::binary // fichero binario

ios::ate // abrir y posicionarse al final

ios::trunc // truncar el fichero a vac´ıo

Otra posibilidad es declarar la variable y abrir el fichero simult´aneamente:

ifstream fichero_entrada(char nombre[] [, int modo]);

Para cerrar el fichero

fichero_entrada.close();

Nota: si se va a abrir un fichero utilizando la misma variable que ya ha sido utilizada (tras el
close()), se deber´a utilizar el m´etodo clear() para limpiar los flags de estado.
Para posicionar el puntero de lectura del fichero (puede coincidir o no con el puntero de escrit-
ura):

n = cin.tellg(); // devuelve la posici´on de lectura

cin.seekg(pos); // pone la posici´on de lectura a ’pos’
cin.seekg(offset, ios::beg|ios::cur|ios::end); // pone la posici´on de lectura relativa

21.7. Ficheros de Salida

ofstream fichero_salida; // declara un fichero de salida

fichero_salida.open(char nombre[] [, int modo]); // abre el fichero

donde los modos posibles, combinados con OR de bits (|) son los anteriormente especificados.
Otra posibilidad es declarar la variable y abrir el fichero simult´aneamente:

ofstream fichero_salida(char nombre[] [, int modo]);

Para cerrar el fichero

fichero_salida.close();

Nota: si se va a abrir un fichero utilizando la misma variable que ya ha sido utilizada (tras el
close()), se deber´a utilizar el m´etodo clear() para limpiar los flags de estado.
Para posicionar el puntero de escritura del fichero (puede coincidir o no con el puntero de
lectura):

n = cout.tellp(); // devuelve la posici´on de escritura

cout.seekp(pos); // pone la posici´on de escritura a ’pos’
cout.seekp(offset, ios::beg|ios::cur|ios::end); // pone la posici´on de escritura relativa

21.8. Ejemplo de Ficheros

Ejemplo de un programa que lee caracteres de un fichero y los escribe a otro hasta encontrar
el fin de fichero:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 21. BUFFER Y FLUJOS DE ENTRADA Y
SALIDA
#include <iostream>
#include <fstream>

void
copiar_fichero_2(const string& salida, const string& entrada, bool& ok)
{
ok = false;
ifstream f_ent(entrada.c_str());
if (f_ent) {
ofstream f_sal(salida.c_str());
if (f_sal) {
f_sal << f_ent.rdbuf();
ok = f_ent.eof() && f_sal.good();
f_sal.close(); // no es necesario
}
f_ent.close(); // no es necesario
}
}

inline ostream& operator<< (ostream& out, istream& in)

{
return out << in.rdbuf();
}

21.9. Ficheros de Entrada y Salida

Para ficheros de entrada y salida utilizamos el tipo:

fstream fich_ent_sal(char nombre[], ios::in | ios::out);

21.10. Flujo de Entrada desde una Cadena

Es posible tambi´en redirigir la entrada desde un string de memoria. Veamos como se realiza:

#include <sstream>

// const char* entrada = "123 452";

// const char entrada[10] = "123 452";
const string entrada = "123 452";

istringstream str_entrada(entrada);

str_entrada >> valor1; // valor1 = 123;

str_entrada >> valor2; // valor2 = 452;
str_entrada >> valor3; // EOF

str_entrada.str("nueva entrada")

21.11. Flujo de Salida a una Cadena

As´ı mismo, tambi´en es posible redirigir la salida a un string en memoria:

#include <sstream>

ostringstream str_salida;

str_salida << 123; // salida tendra "123"

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

21.12. JERARQU´IA DE CLASES DE FLUJO ESTA´ NDAR 271

n = str_salida.pcount(); // devuelve la longitud de la cadena

string salida = str_salida.str();
str_salida.str("cadena inicial");

21.12. Jerarqu´ıa de Clases de Flujo Est´andar

ios_base
^
|
ios<>
^
:
......:......
: :
istream<> ostream<>
^ ^
| |
+--------------+------+----+ +----+------+---------------+
| | | | | |
istringstream<> ifstream<> iostream<> ofstream<> ostringstream<>
^
|
+-----+-----+
| |
fstream<> stringstream<>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 21. BUFFER Y FLUJOS DE ENTRADA Y
SALIDA

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 22

T´ecnicas de Programaci´on
Usuales en C++

En este cap´ıtulo veremos algunas t´ecnicas de programaci´on usualmente utilizadas en C++.

Las t´ecnicas mostradas en este cap´ıtulo han sido tomadas de diferentes recursos pu´blicos
obtenidos de Internet.

22.1. Adquisici´on de Recursos es Inicializaci´on (RAII)

(DRAFT)
Esta t´ecnica consiste en que las adquisici´on de recursos se realiza en la inicializaci´on de
un objeto que lo gestiona (manager), de tal forma que la destrucci´on del manager lleva
asociado la liberaci´on del recurso. N´otese que este mecanismo permite disen˜ar mecanismos
robustos de gesti´on de recursos en situaciones complejas, tales como entornos con excepciones.
Se puede disen˜ar de forma simple, o mediante managers que poseen recursos y permiten
la transferencia de propiedad a otros managers.

22.1.1. auto ptr (unique ptr)

Para soportar la t´ecnica “Adquisici´on de recursos es inicializaci´on” con objeto de
implementar clases que se comporten de forma segura ante las excepciones, la biblioteca est
´andar proporciona la clase auto_ptr.
Nota: auto_ptr no debe ser utilizado dentro de los contenedores est´andares.
El est´andar de C++98 define el tipo auto_ptr<> para gestionar la memoria din´amica.
Sin embargo, el nuevo est´andar de C++0x, elimina auto_ptr<> y define en su lugar
unique_ptr<> como mecanismo adecuado para expresar el propietario de un recurso de memoria
din´amica.
Esta clase se comporta igual que el tipo puntero (“smart pointer”) pero con la salvedad de
que cuando se destruye la variable, la zona de memoria apuntada por ella se libera (delete) au-
tom´aticamente, salvo que se indique lo contrario mediante el m´etodo release. De esta forma, si
hay posibilidad de lanzar una excepci´on, las zonas de memoria din´amica reservada se deber´an
proteger de esta forma para que sean liberadas autom´aticamente en caso de que se eleve una
excepci´on. En caso de que haya pasado la zona donde se pueden elevar excepciones, entonces
se puede revocar dicha caracter´ıstica. Ejemplo:

#include <iostream>
#include <memory>
using namespace std;

class Dato {
public:

273
22.1. ADQUISICIO´ N DE RECURSOS ES INICIALIZACIO´ N 1
(RAII)
~Dato() throw() { cout << "Destruye dato " << val << endl; }
Dato(unsigned v = 0): val(v) { cout << "Construye dato " << val << endl; }
unsigned get() const { return val; }
private:
unsigned val;
};

int main()
{
auto_ptr<Dato> ptr1(new Dato(5));
auto_ptr<Dato> ptr2;
cout << "Valor1: " << ptr1->get() << endl;
ptr2 = ptr1;
cout << "Valor2: " << (*ptr2).get() << endl;
}

Otro ejemplo de utilizaci´on

#include <memory>

class X {
public:
~X();
X();
...
private:
int* ptr;
};
X::~X() throw{} { delete ptr; }
X::X()
: ptr(0)
{
auto_ptr<int> paux(new int);
// utilizaci´on de paux. zona posible de excepciones
// *paux paux-> paux.get() paux.reset(p)
ptr = paux.release();
}

22.1.2. RAII Simple de Memoria Din´amica

Un gestor de recursos simple, especifico para memoria din´amica, sin transferencia de
propiedad, donde la adquisici´on del recurso de realiza durante la inicializaci´on del objeto, y
su liberaci´on durante la destrucci´on del mismo.

#include <iostream>
using namespace std;

template <typename PtrBase>

class RaiiPtr {
public:
~RaiiPtr() throw() { try { delete ptr; } catch (...) {} }
explicit RaiiPtr(PtrBase* p) : ptr(p) {}
void swap(RaiiPtr& o) { std::swap(this->ptr, o.ptr); }
PtrBase& operator*() const throw() { return *ptr; }
PtrBase* operator->() const throw() { return ptr; }
PtrBase* get() const throw() { return ptr; }
private:
PtrBase* ptr;
RaiiPtr& operator=(const RaiiPtr& o);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 22. TE´ CNICAS DE PROGRAMACIO´ N USUALES EN
C++
};

class Dato {
public:
~Dato() throw() { cout << "Destruye dato " << val << endl; }
Dato(unsigned v = 0): val(v) { cout << "Construye dato " << val << endl; }
unsigned get() const { return val; }
private:
unsigned val;
};

int main()
{
RaiiPtr<Dato> ptr1(new Dato(5));
RaiiPtr<Dato> ptr2(new Dato(7));
cout << "Valor1: " << ptr1->get() << endl;
cout << "Valor2: " << ptr2->get() << endl;
ptr1.swap(ptr2);
cout << "Valor1: " << (*ptr1).get() << endl;
cout << "Valor2: " << (*ptr2).get() << endl;
}

22.1.3. RAII Simple Gen´erico

#include <iostream>
using namespace std;

template <typename Releaser>

class Raii {
public:
~Raii() throw() {
if (owner) { try { rlsr(); } catch (...) {} }
}
explicit Raii(const Releaser& r): owner(true), rlsr(r) {}
Raii(const Raii& o): owner(o.owner), rlsr(o.rlsr) { o.release(); }
Raii& operator=(const Raii& o) {
if (this != &o) { Raii(o).swap(*this); } return *this;
}
void release() const throw() { owner = false; }
void swap(Raii& o) {
std::swap(this->owner, o.owner);
std::swap(this->rlsr, o.rlsr);
}
private:
mutable bool owner;
const Releaser& rlsr;
};

template <typename PtrBase>

class PtrReleaser {
public:
~PtrReleaser() throw() {}
PtrReleaser(const PtrBase* p) : ptr(p) {}
void swap(PtrReleaser& o) { std::swap(this->ptr, o.ptr); }
void operator()() const { delete ptr; }
private:
const PtrBase* ptr;
};

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

22.1. ADQUISICIO´ N DE RECURSOS ES INICIALIZACIO´ N 3
(RAII)
int main()
{
cout << "----------------" << endl;
Dato* ptr1 = new Dato(5);
Raii<PtrReleaser<Dato> > mngr1(ptr1);
cout << "Valor1: " << ptr1->get() << endl;
}

22.1.4. RAII Gen´erico

template <typename Fun, typename Arg>
class SGuard {
public:
~SGuard() throw() {
if (!_released) { try{ _fun(_arg); } catch(...) {} }
}
SGuard(const Fun& f, const Arg& a)
: _released(false), _fun(f ), _arg(a) {}
void release() const throw() { _released = true; }
private:
bool _released;
const Fun& _fun;
const Arg& _arg;
};

template <typename Fun, typename Arg>

inline SGuard<Fun,Arg> mk_guard(const Fun& f, const Arg& a) {
return SGuard<Fun,Arg>(f, a);
}

int main()
{
// adquisici´on de recurso
Recurso rec_1 = acquire_resource();
// liberaci´on automatica de recurso si surge una excepci´on
SGuard guarda_rec_1 = mk_guard(funcion, arg);
// ...
// Acciones que pueden elevar una excepci´on
// ...
guarda_rec_1.release();
// Anulaci´on de liberaci´on automatica del recurso
}

22.1.5. RAII Gen´erico

//------------------------------------------------------------------------ -
#ifndef _guard_hpp_
#define _guard_hpp_
/*
* Generic<Programming>:
* Change the Way You Write Exception-Safe Code ? Forever
* Andrei Alexandrescu and Petru Marginean
* C/C++ User Journal
* http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/
*/
namespace raii {
//-------------------------------------------------------------------- -
class SGuardImplBase {
public:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 22. TE´ CNICAS DE PROGRAMACIO´ N USUALES EN
C++
void release() const throw() { _released = true; }
protected:
mutable bool _released;
~SGuardImplBase() throw() {} // nonvirtual
SGuardImplBase() throw() : _released(false) {}
SGuardImplBase(const SGuardImplBase& o) throw()
: _released(o._released) { o.release(); }
private:
SGuardImplBase& operator=(const SGuardImplBase& o);//prohibida
};// class SGuardImplBase
//-------------------------------------------------------------------- -
template <typename Fun>
class SGuard0Arg : public SGuardImplBase
{ public:
~SGuard0Arg() throw()
{ if (!_released) { try{ _fun(); } catch(...) {} }}
SGuard0Arg(const Fun& f )
: _fun(f ) {}
private:
const Fun& _fun;
};// class SGuard1Arg
//--------------------------------
template <typename Fun, typename Arg>
class SGuard1Arg : public SGuardImplBase {
public:
~SGuard1Arg() throw()
{ if (!_released) { try{ _fun(_arg); } catch(...) {} }}
SGuard1Arg(const Fun& f, const Arg& a)
: _fun(f ), _arg(a) {}
private:
const Fun& _fun;
const Arg& _arg;
};// class SGuard1Arg
//--------------------------------
template <typename Fun, typename Arg1, typename Arg2>
class SGuard2Arg : public SGuardImplBase {
public:
~SGuard2Arg() throw()
{ if (!_released) { try{ _fun(_arg1,_arg2); } catch(...) {} }}
SGuard2Arg(const Fun& f, const Arg1& a1, const Arg2& a2)
: _fun(f ), _arg1(a1), _arg2(a2) {}
private:
const Fun& _fun;
const Arg1& _arg1;
const Arg2& _arg2;
};// class SGuard1Arg
//-------------------------------------------------------------------- -
template <typename Fun>
inline SGuard0Arg<Fun>
mk_guard(const Fun& f )
{
return SGuard0Arg<Fun>(f);
}
//--------------------------------
template <typename Fun, typename Arg>
inline SGuard1Arg<Fun,Arg>
mk_guard(const Fun& f, const Arg& a)
{
return SGuard1Arg<Fun,Arg>(f, a);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

22.1. ADQUISICIO´ N DE RECURSOS ES INICIALIZACIO´ N 5
(RAII)
}
//--------------------------------
template <typename Fun, typename Arg1, typename Arg2>
inline SGuard2Arg<Fun,Arg1,Arg2>
mk_guard(const Fun& f, const Arg1& a1, const Arg2& a2)
{
return SGuard2Arg<Fun,Arg1,Arg2>(f, a1, a2);
}
//-------------------------------------------------------------------- -
typedef const SGuardImplBase& SGuard;
//-------------------------------------------------------------------- -
}// namespace raii
#endif
//-------------------------------------------------------------------------
// _EJEMPLO_DE_USO_
//------------------------------------
using namespace raii;
int main()
{
// adquisici´on de recurso
Recurso rec_1 = acquire_resource();
// liberaci´on automatica de recurso si surge una excepci´on
SGuard guarda_rec_1 = mk_guard(funcion, arg);
// ...
// Acciones que pueden elevar una excepci´on
// ...
guarda_rec_1.release();
// Anulaci´on de liberaci´on automatica del recurso
}
//-------------------------------------------------------------------------

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

Cap´ıtulo 23

Gestio´n Din´amica de Memoria

23.1. Gestio´n de Memoria Din´amica

Los operadores new y delete en sus diferentes modalidades solicitan y liberan memoria din
´ami- ca, as´ı como crean y destruyen objetos alojados en ella.
El operador new Tipo se encarga de reservar memoria del taman˜o necesario para contener
un elemento del tipo especificado llamando a
void *operator new(std::size_t) throw (std::bad_alloc);

y crea un objeto (constructor por defecto) de dicho tipo. Devuelve un puntero al objeto creado.
Tambi´en existe la posibilidad de crear un objeto llamando a otro constructor: new Tipo(args).
El operador delete ptr se encarga de destruir el objeto apuntado (llamando al destructor) y
de liberar la memoria ocupada llamando a
void operator delete(void *) throw();

El operador new Tipo[nelms] reserva espacio en memoria para contener nelms elementos
del tipo especificado llamando a
void *operator new[](std::size_t) throw (std::bad_alloc);

y crea dichos elementos llamando al constructor por defecto. Devuelve un puntero al primer objeto
especificado.
El operador delete [] ptr se encarga de destruir los objetos apuntados (llamando al
destruc- tor) en el orden inverso en el que fueron creados y de liberar la memoria ocupada por ellos
llamando a
void operator delete[](void *) throw();

Los operadores anteriores elevan la excepci´on std::bad_alloc en caso de agotamiento de la

memoria. Si queremos que no se lance dicha excepci´on se pueden utilizar la siguiente
modalidad, y en caso de agotamiento de memoria devolver´an 0.

Tipo* ptr = new (nothrow) Tipo;

Tipo* ptr = new (nothrow) Tipo(args);
Tipo* ptr = new (nothrow) Tipo[nelms];

Se implementan en base a los siguientes operadores:

void *operator new(std::size_t, const std::nothrow_t&) throw();

void *operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void *, const std::nothrow_t&) throw();
void operator delete[](void *, const std::nothrow_t&) throw();

279
1 CAP´ITULO 23. GESTIO´ N DINA´ MICA DE
MEMORIA
El operador new (ptr) Tipo (new con emplazamiento) no reserva memoria, simplemente crea
el objeto del tipo especificado (utilizando el constructor por defecto u otra clase de constructor
con la sintaxis new (ptr) Tipo(args) en la zona de memoria especificada por la llamada con
argumento ptr a
inline void *operator new(std::size_t, void *place) throw() { return place; }

Los operadores encargados de reservar y liberar memoria din´amica y pueden redefinirse

para las clases definidas por el usuario [tambi´en pueden redefinirse en el ´ambito global,
aunque esto u´ltimo no es aconsejable]

#include <new>

void *operator new(std::size_t) throw (std::bad_alloc);

void operator delete(void *) throw();
void *operator new[](std::size_t) throw (std::bad_alloc);
void operator delete[](void *) throw();

void *operator new(std::size_t, const std::nothrow_t&) throw();

void operator delete(void *, const std::nothrow_t&) throw();
void *operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete[](void *, const std::nothrow_t&) throw();

inline void *operator new(std::size_t, void *place) throw() { return place; }

inline void *operator new[](std::size_t, void *place) throw() { return place; }

y los comportamientos por defecto podr´ıan ser los siguientes para los operadores new y delete:
Los operadores new y delete encargados de alojar y desalojar zonas de memoria pueden
ser redefinidos por el programador, tanto en el ´ambito global como para clases espec´ıficas.
Una
definici´on est´andar puede ser como se indica a continuaci´on: (fuente: M. Cline, C++ FAQ-Lite,
http://www.parashift.com/c++-faq-lite/)

#include <new>

extern "C" void *malloc(std::size_t);

extern "C" void free(void *);
extern std::new_handler new_handler;

/*
* ********************************
* Tipo* ptr = new Tipo(lista_val);
* ********************************
*
* ptr = static_cast<Tipo*>(::operator new(sizeof(Tipo))); // alojar mem
* try {
* new (ptr) Tipo(lista_val); // llamada al constructor
* } catch (...) {
* ::operator delete(ptr);
* throw;
* }
*/
void*
operator new (std::size_t sz) throw(std::bad_alloc)
{
void* p;

/* malloc(0) es impredecible; lo evitamos. */

if (sz == 0) {
sz = 1;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

23.1. GESTIO´ N DE MEMORIA DINA´ MICA 281

}
p = static_cast<void*>(malloc(sz));
while (p == 0) {
std::new_handler handler = new_handler;
if (handler == 0) {
#ifdef EXCEPTIONS
throw std::bad_alloc();
#else
std::abort();
#endif
}
handler();
p = static_cast<void*>(malloc(sz));
}
return p;
}
/*
* ********************************
* delete ptr;
* ********************************
*
* if (ptr != 0) {
* ptr->~Tipo(); // llamada al destructor
* ::operator delete(ptr); // liberar zona de memoria
* }
*
* ********************************
*/
void
operator delete (void* ptr) throw()
{
if (ptr) {
free(ptr);
}
}
/*
* *****************************
* Tipo* ptr = new Tipo [NELMS];
* *****************************
*
* // alojar zona de memoria
* char* tmp = (char*)::operator new[](WORDSIZE+NELMS*sizeof(Tipo));
* ptr = (Tipo*)(tmp+WORDSIZE);
* *(size_t*)tmp = NELMS;
* size_t i;
* try {
* for (i = 0; i < NELMS; ++i) {
* new (ptr+i) Tipo(); // llamada al constructor
* }
* } catch (...) {
* while (i-- != 0) {
* (p+i)->~Tipo();
* }
* ::operator delete((char*)ptr - WORDSIZE);
* throw;
* }
*
* ********************************
*/

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 23. GESTIO´ N DINA´ MICA DE
MEMORIA
void*
operator new[] (std::size_t sz) throw(std::bad_alloc)
{
return ::operator new(sz);
}
/*
* **************
* delete [] ptr;
* **************
*
* if (ptr != 0) {
* size_t n = *(size_t*)((char*)ptr - WORDSIZE);
* while (n-- != 0) {
* (ptr+n)->~Tipo(); // llamada al destructor
* }
* ::operator delete[]((char*)ptr - WORDSIZE);
* }
*
* **********
*/
void
operator delete[] (void* ptr) throw()
{
::operator delete (ptr);
}

23.2. Gestio´n de Memoria Din´amica sin Inicializar

La biblioteca est´andar tambi´en proporciona una clase para poder trabajar con zonas de
memoria sin inicializar, de forma que sea u´ til para la creaci´on de clases contenedoras, etc. As´ı,
proporciona m´etodos para reservar zonas de memoria sin inicializar, construir objetos en ella,
destruir objetos de ella y liberar dicha zona:
#include <memory>

template <typename Tipo>

class allocator {
public:
Tipo* allocate(std::size_t nelms) throw(std::bad_alloc);
void construct(Tipo* ptr, const Tipo& val);
void destroy(Tipo* ptr);
void deallocate(Tipo* ptr, std::size_t nelms) throw();
};

uninitialized_fill(For_It begin, For_It end, const Tipo& val);

uninitialized_fill_n(For_It begin, std::size_t nelms, const Tipo& val);
uninitialized_copy(In_It begin_org, In_It end_org, For_It begin_dest);

23.3. RAII: auto ptr

Para soportar la t´ecnica “Adquisici´on de recursos es inicializaci´on” con objeto de
implementar clases que se comporten de forma segura ante las excepciones, la biblioteca est
´andar proporciona la clase auto_ptr.
Esta clase se comporta igual que el tipo puntero (“smart pointer”) pero con la salvedad de
que cuando se destruye la variable, la zona de memoria apuntada por ella se libera (delete) au-
tom´aticamente, salvo que se indique lo contrario mediante el m´etodo release. De esta forma, si
hay posibilidad de lanzar una excepci´on, las zonas de memoria din´amica reservada se deber´an
proteger

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

23.4. COMPROBACIO´ N DE GESTIO´ N DE MEMORIA DINA´ MICA 283

de esta forma para que sean liberadas autom´aticamente en caso de que se eleve una excepci
´on. En caso de que haya pasado la zona donde se pueden elevar excepciones, entonces se puede
revocar dicha caracter´ıstica. Ejemplo:

#include <memory>

class X {
public:
~X();
X();
...
private:
int* ptr;
};
X::~X() throw{} { delete ptr; }
X::X()
: ptr(0)
{
auto_ptr<int> paux(new int);
// utilizaci´on de paux. zona posible de excepciones
// *paux paux-> paux.get() paux.reset(p)
ptr = paux.release();
}

23.4. Comprobaci´on de Gesti´on de Memoria Din´amica

El siguiente c´odigo C++ se puede compilar junto con cualquier programa C++ de forma
externa no intrusiva, y autom´aticamente realiza en tiempo de ejecuci´on una cuenta del nu
´mero de nodos alojados y liberados, de tal forma que al finalizar el programa escribe unas
estad´ısticas comprobando si coinciden o no. N´otese que no es necesario modificar el
programa principal para que se pueda comprobar autom´aticamente la cuenta de nodos
alojados y liberados, es suficiente con la invocaci´on al compilador.
g++ -ansi -Wall -Werror -o main main.cpp newdelcnt.cpp

//------------------------------------------------------------------------ -
//- newdelcnt.cpp
//------------------------------------------------------------------------ -
#include <iostream>
#include <cstdlib>
#include <new>
//------------------------------------------------------------------------ -
namespace {
static unsigned inc_new(unsigned n = 0) throw()
{
static unsigned cnt = 0;
return (cnt += n);
}
//------------------------------------
static unsigned inc_delete(unsigned n = 0) throw()
{
static unsigned cnt = 0;
return (cnt += n);
}
//------------------------------------
static void check_new_delete() throw()
{
if (inc_new() != inc_delete()) {

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 23. GESTIO´ N DINA´ MICA DE
MEMORIA
std::cerr << "ERROR, el n´umero de NEW [" << inc_new()
<< "] es diferente del n´umero de DELETE ["
<< inc_delete() << "]" << std::endl;
#ifdef WIN32
std::system("pause");
#endif
std::exit(1234);
} else {
std::cerr << "OK, el n´umero de NEW [" << inc_new()
<< "] es igual al n´umero de DELETE ["
<< inc_delete() << "]" << std::endl;
}
}
//------------------------------------------------------------------------ -
struct ExecAtEnd { ~ExecAtEnd() throw() { check_new_delete(); } };
static ExecAtEnd x;
//------------------------------------------------------------------------ -
}//end namespace
//------------------------------------------------------------------------ -
void* operator new (std::size_t sz) throw (std::bad_alloc)
{
if (sz == 0) {
sz = 1; // malloc(0) es impredecible; lo evitamos.
}
void* p = static_cast<void*>(std::malloc(sz));
if (p == 0) {
std::cerr << "Error: New: Memory failure" << std::endl;
throw std::bad_alloc();
}
inc_new(1);
return p;
}
//------------------------------------------------------------------------ -
void operator delete (void* ptr) throw()
{
if (ptr) {
inc_delete(1);
std::free(ptr);
}
}
//------------------------------------------------------------------------ -

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Cap´ıtulo 24

Biblioteca Est´andar de C++. STL

La biblioteca est´andar de C++ se define dentro del espacio de nombres std y proporciona:

Soporte para las caracter´ısticas del lenguaje, tales como manejo de memoria y la informaci´on
de tipo en tiempo de ejecuci´on.
Informaci´on sobre aspectos del lenguaje definidos por la implementaci´on, tal como el
valor del mayor double.
Funciones que no se pueden implementar de forma ´optima en el propio lenguaje para cada
sistema, tal como sqrt y memmove.
Facilidades no primitivas sobre las cuales un programador se puede basar para portabilidad,
tal como vector, list, map, ordenaciones, entrada/salida, etc.
La base comu´n para otras bibliotecas.

Los contenedores de la biblioteca est´andar proporcionan un m´etodo general para

almacenar y acceder a elementos homog´eneos, proporcionando cada uno de ellos diferentes caracter
´ısticas que los hacen adecuados a diferentes necesidades.

Paso de Par´ametros de Contenedores

Los contenedores de la biblioteca est´andar se pueden pasar como par´ametros a
subprogramas como cualquier otro tipo compuesto, y por lo tanto se aplican los mecanismos de paso
de par´ametros para tipos compuestos explicados en la secci´on 6.1. Es decir, los par´ametros de
entrada se pasar´an por referencia constante, mientras que los par´ametros de salida y
entrada/salida se pasar´an por referencia.
As´ı mismo, como norma general, salvo excepciones, no es adecuado que las funciones retornen
valores de tipos de los contenedores, debido a la sobrecarga que generalmente conlleva dicha
op- eraci´on para el caso de los tipos compuestos. En estos casos suele ser m ´a s adecuado que
el valor se devuelva como un par´ametro por referencia.

24.1. Caracter´ısticas Comunes

24.1.1. Ficheros
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>

285
1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
#include <map>
#include <iterator>

#include <utility>
#include <functional>
#include <algorithm>

24.1.2. Contenedores
vector<tipo_base> vec; // vector de tama~no variable
list<tipo_base> ls; // lista doblemente enlazada
deque<tipo_base> dqu; // cola doblemente terminada

stack<tipo_base> st; // pila

queue<tipo_base> qu; // cola
priority_queue<tipo_base> pqu; // cola ordenada

map<clave,valor> mp; // contenedor asociativo de pares de valores

multimap<clave,valor> mmp;// cont asoc con repetici´on de clave
set<tipo_base> cnj; // conjunto
multiset<tipo_base> mcnj;// conjunto con valores multiples

24.1.3. Tipos Definidos

t::value_type // tipo del elemento
t::allocator_type // tipo del manejador de memoria
t::size_type // tipo de sub´ındices, cuenta de elementos,
... t::difference_type // tipo diferencia entre iteradores
t::iterator // iterador (se comporta como value_type*)
t::const_iterator // iterador const (como const value_type*)
t::reverse_iterator // iterador inverso (como value_type*)
t::const_reverse_iterator// iterador inverso (como const value_type*)
t::reference // value_type&
t::const_reference // const value_type&
t::key_type // tipo de la clave (s´olo contenedores asociativos)
t::mapped_type // tipo del valor mapeado (s´olo cont asoc)
t::key_compare // tipo de criterio de comparaci´on (s´olo cont asoc)

24.1.4. Iteradores
c.begin() // apunta al primer elemento
c.end() // apunta al (´ultimo+1) elemento
c.rbegin() // apunta al primer elemento (orden inverso)
c.rend() // apunta al (´ultimo+1) elemento (orden inverso)

bi = back_inserter(contenedor) // insertador al final

fi = front_inserter(conenedor) // insertador al principio
in = inserter(contenedor, iterador) // insertador en posici´on

it = ri.base(); // convierte de ri a it. it = ri + 1

for (list<tipo_base>::const_iterator i = nombre.begin();

i != nombre.end(); ++i) {
cout << *i;
}

for (list<tipo_base>::reverse_iterator i = nombre.rbegin();

i != nombre.rend(); ++i) {
*i = valor;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.1. CARACTER´ISTICAS COMUNES 287

contenedor<tipo_base>::iterator i = ri.base(); // ri + 1

24.1.5. Acceso
c.front() // primer elemento
c.back() // ´ultimo elemento
v[i] // elemento de la posici´on ’i’ (vector, deque y map)
v.at[i] // elem de la posici´on ’i’ => out_of_range (vector y deque)

24.1.6. Operaciones de Pila y Cola

c.push_back(e) // a~nade al final
c.pop_back() // elimina el ´ultimo elemento
c.push_front(e) // a~nade al principio (list y deque)
c.pop_front() // elimina el primer elemento (list y deque)

24.1.7. Operaciones de Lista

c.insert(p, x) // a~nade x antes de p
c.insert(p, n, x) // a~nade n copias de x antes de p
c.insert(p, f, l) // a~nade elementos [f:l) antes de p
c.erase(p) // elimina elemento en p
c.erase(f, l) // elimina elementos [f:l)
c.clear() // elimina todos los elementos

// s´olo para list

l.reverse() // invierte los elementos
l.remove(v) // elimina elementos iguales a v
l.remove_if(pred1) // elimina elementos que cumplen pred1
l.splice(pos, lst) // mueve (sin copia) los elementos de lst a pos
l.splice(pos, lst, p) // mueve (sin copia) elemento posici´on p de lst a pos
l.splice(pos, lst, f, l) // mueve (sin copia) elementos [f:l) de lst a pos
l.sort() // ordena
l.sort(cmp2) // ordena seg´un bool cmp2(o1, o2)
l.merge(lst) // mezcla ambas listas (ordenadas) en l
l.merge(lst, cmp2) // mezcla ambas listas (ordenadas) en l
l.unique() // elimina duplicados adyacentes
l.unique(pred2) // elimina duplicados adyacentes que cumplen pred2

24.1.8. Operaciones
c.size() // n´umero de elementos
c.empty() // (c.size() == 0)
c.max_size() // tama~no del mayor posible contenedor
c.capacity() // espacio alojado para el vector (s´olo vector)
c.reserve(n) // reservar espacio para expansi´on (s´olo vector)
c.resize(n) // cambiar el tam del cont (s´olo vector, list y deque)
c.swap(y) // intercambiar
== // igualdad
!= // desigualdad
< // menor

24.1.9. Constructores
cont() // contenedor vac´ıo
cont(n) // n elementos con valor por defecto (no cont asoc)
cont(n, x) // n copias de x (no cont asoc)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
cont(f, l) // elementos iniciales copiados de [f:l)
cont(x) // inicializaci´on igual a x

24.1.10. Asignaci´on
x = y; // copia los elementos de y a x
c.assign(n, x) // asigna n copias de x (no cont asoc)
c.assign(f, l) // asigna de [f:l)

24.1.11. Operaciones Asociativas

m[k] // acceder al elemento con clave k (para clave unica)
m.find(k) // encontrar el elemento con clave k
m.lower_bound(k) // encontrar el primer elemento con clave k
m.upper_bound(k) // encontrar el primer elem con clave mayor que k
m.equal_range(k) // encontrar el lower_bound(k) y upper_bound(k)
m.key_comp() // copia la clave
m.value_comp() // copia el valor

24.1.12. Resumen
[] op.list op.front op.back iter

vector const O(n)+ const+ Random

list const const const Bidir
deque const O(n) const const Random

stack const
queue const const
prque O(log(n)) O(log(n))

map O(log(n)) O(log(n))+ Bidir

mmap O(log(n))+ Bidir
set O(log(n))+ Bidir
mset O(log(n))+ Bidir

string const O(n)+ O(n)+ const+ Random

array const Random
valarray const Random
bitset const

24.1.13. Operaciones sobre Iteradores

|Salida |Entrada|Avance |Bidir |Random
------------+-------+-------+-------+-------+--------------------- -
Leer | | =*p | =*p | =*p | =*p
Acceso | | -> | -> | -> | -> []
Escribir | *p= | | *p= | *p= | *p=
Iteraci´on | ++ | ++ | ++ | ++ -- | ++ -- + - += -=
Comparac | | == != | == != | == != | == != < > >= <=
------------+-------+-------+-------+-------+--------------------- -

24.2. Contenedores
Los contenedores proporcionan un m´etodo est´andar para almacenar y acceder a elementos,
proporcionando diferentes caracter´ısticas.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.3. VECTOR 289

24.3. Vector
Es una secuencia optimizada para el acceso aleatorio a los elementos. Proporciona, as´ı mismo,
iteradores aleatorios.
#include <vector>

Construcci´on:

typedef std::vector<int> vect_int;

vect_int v1; // vector de enteros de tama~no inicial vac´ıo

vect_int v2(100); // vector de 100 elementos con valor inicial por defecto
vect_int v3(50, val_inicial); // vector de 50 elementos con el valor especificado
vect_int v4(it_ini, it_fin); // vector de elementos copia de [it_ini:it_fin[
vect_int v5(v4); // vector copia de v4

typedef std::vector<int> Fila;

typedef std::vector<Fila> Matriz;

Matriz m(100, Fila(50)); // Matriz de 100 filas X 50 columnas

Asignaci´on (despu´es de la asignaci´on, el taman˜o del vector asignado se adapta al nu´mero de

elementos asignados):

//(se destruye el valor anterior de v1)

v1 = v2; // asignaci´on de los elementos de v2 a v1
v1.assign(it_ini, it_fin); // asignaci´on de los elementos [it_ini:it_fin[
v1.assign(50, val_inicial); // asignaci´on de 50 elementos con val_inicial

Acceso a elementos:

cout << v1.front(); // acceso al primer elemento (debe existir)

v1.front() = 1; // acceso al primer elemento (debe existir)

cout << v1.back(); // acceso al ´ultimo elemento (debe existir)

v1.back() = 1; // acceso al ´ultimo elemento (debe existir)

Acceso aleatorio a elementos (s´olo vector y deque):

cout << v1[i]; // acceso al elemento i-´esimo (debe existir)
v1[i] = 3; // acceso al elemento i-´esimo (debe existir)

cout << v1.at(i); // acceso al elemento i-´esimo (lanza out_of_range si no existe)

v1.at(i) = 3; // acceso al elemento i-´esimo (lanza out_of_range si no existe)

Operaciones de Pila

v1.push_back(val); // a~nade val al final de v1 (crece)

v1.pop_back(); // elimina el ´ultimo elemento (decrece) (no devuelve nada)

Operaciones de Lista

it = v1.insert(it_pos, val); // inserta val en posici´on. dev it al elem (crece)

v1.insert(it_pos, n, val); // inserta n copias de val en posici´on (crece)
v1.insert(it_pos, it_i, it_f ); // inserta [it_i:it_f[ en pos (crece)

it = v1.erase(it_pos); // elimina elem en pos. dev it al sig (decrece)

it = v1.erase(it_i, it_f ); // elim elems en [it_i:it_f[. dev it al sig (decrece)

v1.clear(); // elimina todos los elementos. (decrece) (no devuelve memoria)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
Nu´mero de elementos:
n = v1.size(); // n´umero de elementos de v1
bool b = v1.empty(); // (v1.size() == 0)

Taman˜o del contenedor:

n = v1.max_size(); // tama~no del mayor vector posible

// s´olo vector deque list

v1.resize(nuevo_tam); // redimensiona el vector al nuevo_tam con valor por defecto
v1.resize(nuevo_tam, valor); // redimensiona el vector. utiliza valor.

// s´olo vector
v1.reserve(n); // reservar n elementos (prealojados) sin inicializar valores
n = v1.capacity(); // n´umero de elementos reservados
assert(&v[0] + n == &v[n]); // Se garantiza que la memoria es contigua
// aunque puede ser realojada por necesidades de nuevo espacio

Otras operaciones:
v1 == v2 , v1 != v2 , v1 < v2 , v1 <= v2 , v1 > v2 , v1 >=
v2 v1.swap(v2);
swap(v1 , v2);

template <typename Tipo>

void vaciar_vector(std::vector<Tipo>& vect)
{
std::vector<Tipo> aux;
vect.swap(aux);
// se devuelve la memoria anterior de vect
}

template <typename Tipo>

void reajustar_vector(std::vector<Tipo>& vect)
{
std::vector<Tipo> aux(vect);
vect.swap(aux);
// se devuelve la memoria anterior de vect
}

24.4. List
Es una secuencia optimizada para la inserci´on y eliminaci´on de elementos. Proporciona, as´ı
mis- mo, iteradores bidireccionales.
#include <list>

Construcci´on:
typedef std::list<int> list_int;

list_int l1; // lista de enteros de tama~no inicial vac´ıo

list_int l2(100); // lista de 100 elementos con valor inicial por defecto
list_int l3(50, val_inicial); // lista de 50 elementos con el valor especificado
list_int l4(it_ini, it_fin); // lista de elementos copia de [it_ini:it_fin[
list_int l5(l4); // lista copia de l4

Asignaci´on (despu´es de la asignaci´on, el taman˜o de la lista asignada se adapta al nu´mero

de elementos asignados):

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.4. LIST 291

//(se destruye el valor anterior de l1)

l1 = l2; // asignaci´on de los elementos de l2 a l1
l1.assign(it_ini, it_fin); // asignaci´on de los elementos [it_ini:it_fin[
l1.assign(50, val_inicial); // asignaci´on de 50 elementos con val_inicial

Acceso a elementos:

cout << l1.front(); // acceso al primer elemento (debe existir)

l1.front() = 1; // acceso al primer elemento (debe existir)

cout << l1.back(); // acceso al ´ultimo elemento (debe existir)

l1.back() = 1; // acceso al ´ultimo elemento (debe existir)

Operaciones de Pila

l1.push_back(val); // a~nade val al final de l1 (crece)

l1.pop_back(); // elimina el ´ultimo elemento (decrece) (no devuelve nada)

Operaciones de Cola (s´olo list y deque)

l1.push_front(val); // a~nade val al principio de l1 (crece)
l1.pop_front(); // elimina el primer elemento (decrece) (no devuelve nada)

Operaciones de Lista

it = l1.insert(it_pos, val); // inserta val en posici´on. dev it al elem (crece)

l1.insert(it_pos, n, val); // inserta n copias de val en posici´on (crece)
l1.insert(it_pos, it_i, it_f ); // inserta [it_i:it_f[ en pos (crece)

it = l1.erase(it_pos); // elimina elem en pos. dev it al sig (decrece)

it = l1.erase(it_i, it_f ); // elim elems en [it_i:it_f[. dev it al sig (decrece)

l1.clear(); // elimina todos los elementos. (decrece)

Nu´mero de elementos:

n = l1.size(); // n´umero de elementos de l1

bool b = l1.empty(); // (l1.size() == 0)

Taman˜o del contenedor:

n = l1.max_size(); // tama~no de la mayor lista posible

// s´olo vector deque list

l1.resize(nuevo_tam); // redimensiona la lista al nuevo_tam con valor por defecto
l1.resize(nuevo_tam, valor); // redimensiona la lista. utiliza valor.

Otras operaciones:

l1 == l2 , l1 != l2 , l1 < l2 , l1 <= l2 , l1 > l2 , l1 >= l2

l1.swap(l2);
swap(l1 , l2);

Otras operaciones propias del contenedor lista:

l1.reverse(); // invierte los elementos de l1

l1.remove(val); // elimina de l1 todos los elementos igual a val

l1.remove_if(pred1); // elimina de l1 todos los elementos que cumplen pred1(elem)

l1.splice(it_pos, l2); // mueve (sin copia) los elementos de l2 a pos

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
l1.splice(it_pos, l2, it_el); // mueve (sin copia) (*it_el) de l2 a pos
l1.splice(it_pos, l2, it_i, it_f ); // mueve (sin copia) [it_i:it_f[ de l2 a pos

l1.sort(); // ordena l1
l1.sort(cmp2); // ordena l1 seg´un bool cmp2(e1, e2)

l1.merge(l2); // mezcla ambas listas (ordenadas) en l1 (mueve sin copia)

l1.merge(l2, cmp2); // mezcla ambas listas (ordenadas) en l1 seg´un cmp2(e1, e2)

l1.unique(); // elimina elementos duplicados adyacentes

l1.unique(pred2); // elimina elementos adyacentes que cumplen pred2(e1, e2)

Tanto los predicados como las funciones de comparaci´on pueden ser funciones (unarias
o binarias) que reciben los par´ametros (1 o 2) del tipo del elemento del contenedor y
devuelven un bool resultado de la funci´on, o un objeto de una clase que tenga el operador
() definido. Ejemplo:

bool mayor_que_5(int elem)

{
return (elem > 5);
}

int main()
{
. . .
l1.remove_if(mayor_que_5);
}
bool operator()(const Tipo& arg1, const Tipo& arg2) {}

o tambi´en de la siguiente forma:

class mayor_que : public unary_function<int, bool>

{ public:
mayor_que(int val) : _valor(val) {} // constructor

bool operator() (int elem) const { return (elem > _valor); }

private:
int _valor;
};

int main()
{
std::list<int> l1;
. . .
l1.remove_if(mayor_que(5));
l1.remove_if(mayor_que(3));
}

o tambi´en de la siguiente forma:

int main()
{
std::list<int> l1;
. . .
l1.remove_if(bind2nd(greater<int>(), 5));
l1.remove_if(bind2nd(greater<int>(), 3));
}

Veamos otro ejemplo:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.5. DEQUE 293

bool
mayor1(const string& s1, const string& s2)
{
return s1 > s2;
}

class mayor2 : public binary_function<string, string, bool> {

public:
bool operator() (const string& s1, const string& s2) const { return s1 > s2; }
};

int
main()
{
std::list<string> l1;
. . .
l1.sort(); // ordena de menor a mayor
l1.sort(mayor1); // ordena de mayor a menor (utiliza mayor1)
l1.sort(mayor2()); // ordena de mayor a menor (utiliza mayor2())
l1.sort(greater<string>()); // ordena de mayor a menor (utiliza greater<>())
}

24.5. Deque
Secuencia optimizada para que las operaciones de inserci´on y borrado en ambos extremos
sean tan eficientes como en una lista, y el acceso aleatorio tan eficiente como un vector.
Proporciona iteradores aleatorios.

#include <deque>

Construcci´on:

typedef std::deque<int> deq_int;

deq_int d1; // deque de enteros de tama~no inicial vac´ıo

deq_int d2(100); // deque de 100 elementos con valor inicial por defecto
deq_int d3(50, val_inicial); // deque de 50 elementos con el valor especificado
deq_int d4(it_ini, it_fin); // deque de elementos copia de [it_ini:it_fin[
deq_int d5(d4); // deque copia de d4

Asignaci´on (despu´es de la asignaci´on, el taman˜o del deque asignado se adapta al nu´mero de

elementos asignados):

//(se destruye el valor anterior de d1)

d1 = d2; // asignaci´on de los elementos de d2 a d1
d1.assign(it_ini, it_fin); // asignaci´on de los elementos [it_ini:it_fin[
d1.assign(50, val_inicial); // asignaci´on de 50 elementos con val_inicial

Acceso a elementos:

cout << d1.front(); // acceso al primer elemento (debe existir)

d1.front() = 1; // acceso al primer elemento (debe existir)

cout << d1.back(); // acceso al ´ultimo elemento (debe existir)

d1.back() = 1; // acceso al ´ultimo elemento (debe existir)

Acceso aleatorio a elementos (s´olo vector y deque):

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
cout << d1[i]; // acceso al elemento i-´esimo (debe existir)
d1[i] = 3; // acceso al elemento i-´esimo (debe existir)

cout << d1.at(i); // acceso al elemento i-´esimo (lanza out_of_range si no existe)

d1.at(i) = 3; // acceso al elemento i-´esimo (lanza out_of_range si no existe)

Operaciones de Pila

d1.push_back(val); // a~nade val al final de d1 (crece)

d1.pop_back(); // elimina el ´ultimo elemento (decrece) (no devuelve nada)

Operaciones de Cola (s´olo list y deque)

d1.push_front(val); // a~nade val al principio de d1 (crece)
d1.pop_front(); // elimina el primer elemento (decrece) (no devuelve nada)

Operaciones de Lista

it = d1.insert(it_pos, val); // inserta val en posici´on. dev it al elem (crece)

d1.insert(it_pos, n, val); // inserta n copias de val en posici´on (crece)
d1.insert(it_pos, it_i, it_f ); // inserta [it_i:it_f[ en pos (crece)

it = d1.erase(it_pos); // elimina elem en pos. dev it al sig (decrece)

it = d1.erase(it_i, it_f ); // elim elems en [it_i:it_f[. dev it al sig (decrece)

d1.clear(); // elimina todos los elementos. (decrece)

Nu´mero de elementos:

n = d1.size(); // n´umero de elementos de d1

bool b = d1.empty(); // (d1.size() == 0)

Taman˜o del contenedor:

n = d1.max_size(); // tama~no del mayor deque posible

// s´olo vector deque list

d1.resize(nuevo_tam); // redimensiona el deque al nuevo_tam con valor por defecto
d1.resize(nuevo_tam, valor); // redimensiona el deque. utiliza valor.

Otras operaciones:

d1 == d2 , d1 != d2 , d1 < d2 , d1 <= d2 , d1 > d2 , d1 >=

d2 d1.swap(d2);
swap(d1 , d2);

24.6. Stack
Proporciona el “Tipo Abstracto de Datos Pila”, y se implementa sobre un deque. No propor-
ciona iteradores.

#include <stack>

typedef std::stack<char> pila_c;

int
main()
{
pila_c p1; // []

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.7. QUEUE 295

p1.push(’a’); // [a]
p1.push(’b’); // [a b]
p1.push(’c’); // [a b c]

if (p1.size() != 3) {
// imposible
}

if (p1.top() != ’c’) {
// imposible
}
p1.top() = ’C’; // [a b C]

if (p1.size() != 3) {
// imposible
}

p1.pop(); // [a b]
p1.pop(); // [a]
p1.pop(); // []

if (! p1.empty()) {
// imposible
}
}

24.7. Queue
Proporciona el “Tipo Abstracto de Datos Cola”, y se implementa sobre un deque. No propor-
ciona iteradores.

#include <queue>

typedef std::queue<char> cola_c;

int
main()
{
cola_c c1; // []

c1.push(’a’); // [a]
c1.push(’b’); // [a b]
c1.push(’c’); // [a b c]

if (c1.size() != 3) {
// imposible
}

if (c1.front() != ’a’) {
// imposible
}
c1.front() = ’A’; // [A b c]

if (c1.back() != ’c’) {
// imposible
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
if (c1.size() != 3) {
// imposible
}

c1.pop(); // [b c]
c1.pop(); // [c]
c1.pop(); // []

if (! c1.empty()) {
// imposible
}
}

24.8. Priority-Queue
Proporciona el “Tipo Abstracto de Datos Cola con Prioridad”, y se implementa sobre un
vector. No proporciona iteradores.
#include <queue>
//#include <functional>

using namespace std;

//typedef std::priority_queue< int, std::vector<int>, std::less<int> > pcola_i;

typedef std::priority_queue<int> pcola_i; // ordenaci´on <

int
main()
{
pcola_i c1; // []

c1.push(5); // [5]
c1.push(3); // [5 3]
c1.push(7); // [7 5 3]
c1.push(4); // [7 5 4 3]

if (c1.size() != 4) {
// imposible
}

if (c1.top() != 7) {
// imposible
}

c1.pop(); // [5 4 3]
c1.pop(); // [4 3]
c1.pop(); // [3]
c1.pop(); // []

if (! c1.empty()) {
// imposible
}
}

24.9. Map
Secuencia de pares <clave, valor> optimizada para el acceso r´apido basado en clave. Clave
u´ nica. Proporciona iteradores bidireccionales.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.10. MULTIMAP 297

#include <map>
//#include <functional>

//typedef std::map< std::string, int, std::less<std::string> > map_str_int;

typedef std::map<std::string, int> map_str_int;

map_str_int m1;

n = m1.size();
n = m1.max_size();
bool b = m1.empty();
m1.swap(m2);

int x = m1["pepe"]; // crea nueva entrada. devuelve 0.

m1["juan"] = 3; // crea nueva entrada a 0 y le asigna 3.
int y = m1["juan"]; // devuelve 3
m1["pepe"] = 4; // asigna nuevo valor

it = m1.find("pepe"); // encontrar el elemento con una determinada clave

int n = m1.count("pepe"); // cuenta el n´umero de elementos con clave "pepe"
it = m1.lower_bound("pepe"); // primer elemento con clave "pepe"
it = m1.upper_bound("pepe"); // primer elemento con clave mayor que "pepe"
pair<it,it> pit = m1.equal_range("pepe"); // rango de elementos con clave "pepe"

clave = it->first;
valor = it->second;

pair<it, bool> p = m1.insert(make_pair(clave, val));

it = m1.insert(it_pos, make_pair(clave, val));
m1.insert(it_ini, it_fin);
m1.erase(it_pos);
int n = m1.erase(clave);
m1.erase(it_ini, it_fin);
m1.clear();

#include <utility>
pair<clave, valor> p = make_pair(f, s);
p.first // clave
p.second // valor

24.10. Multimap
Secuencia de pares <clave, valor> optimizada para el acceso r´apido basado en clave. Permite
claves duplicadas. Proporciona iteradores bidireccionales.

#include <map>
//#include <functional>

//typedef std::multimap< std::string, int, std::less<std::string> > mmap_str_int;

typedefstd:: multimap<std::string, int> mmap_str_int;

mmap_str_int m1;

n = m1.size();
n = m1.max_size();
bool b = m1.empty();
m1.swap(m2);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
it = m1.find("pepe"); // encontrar el elemento con una determinada clave
int n = m1.count("pepe"); // cuenta el n´umero de elementos con clave "pepe"
it = m1.lower_bound("pepe"); // primer elemento con clave "pepe"
it = m1.upper_bound("pepe"); // primer elemento con clave mayor que "pepe"
pair<it,it> pit = m1.equal_range("pepe"); // rango de elementos con clave "pepe"

it = m1.insert(make_pair(clave, val));
it = m1.insert(it_pos, make_pair(clave, val));
m1.insert(it_ini, it_fin);
m1.erase(it_pos);
int n = m1.erase(clave);
m1.erase(it_ini, it_fin);
m1.clear();

#include <utility>
std::pair<clave, valor> p = std::make_pair(f, s);
p.first // clave
p.second // valor

24.11. Set
Como un map donde los valores no importan, s´ol o aparecen las claves. Proporciona iteradores
bidireccionales.

#include <set>
//#include <functional>

//typedef std::set< std::string, std::less<std::string> > set_str;

typedef std::set<std::string> set_str;

set_str s1;

n = s1.size();
n = s1.max_size();
bool b = s1.empty();
s1.swap(s2);

it = s1.find("pepe"); // encontrar el elemento con una determinada clave

int n = s1.count("pepe"); // cuenta el n´umero de elementos con clave "pepe"
it = s1.lower_bound("pepe"); // primer elemento con clave "pepe"
it = s1.upper_bound("pepe"); // primer elemento con clave mayor que "pepe"
pair<it,it> pit = s1.equal_range("pepe"); // rango de elementos con clave "pepe"

pair<it, bool> p = s1.insert(elem);

it = s1.insert(it_pos, elem);
s1.insert(it_ini, it_fin);
s1.erase(it_pos);
int n = s1.erase(clave);
s1.erase(it_ini, it_fin);
s1.clear();

#include <utility>
std::pair<tipo1, tipo2> p = std::make_pair(f, s);
p.first
p.second

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.12. MULTISET 299

24.12. Multiset
Como set, pero permite elementos duplicados. Proporciona iteradores bidireccionales.
#include <set>
//#include <functional>

//typedef std::multiset< std::string, std::less<std::string> > mset_str;

typedef std::multiset<std::string> mset_str;

mset_str s1;

n = s1.size();
n = s1.max_size();
bool b = s1.empty();
s1.swap(s2);

it = s1.find("pepe"); // encontrar el elemento con una determinada clave

int n = s1.count("pepe"); // cuenta el n´umero de elementos con clave "pepe"
it = s1.lower_bound("pepe"); // primer elemento con clave "pepe"
it = s1.upper_bound("pepe"); // primer elemento con clave mayor que "pepe"
pair<it,it> pit = s1.equal_range("pepe"); // rango de elementos con clave "pepe"

it = s1.insert(elem);
it = s1.insert(it_pos, elem);
s1.insert(it_ini, it_fin);
s1.erase(it_pos);
int n = s1.erase(clave);
s1.erase(it_ini, it_fin);
s1.clear();

#include <utility>
std::pair<tipo1, tipo2> p = std::make_pair(f, s);
p.first
p.second

24.13. Bitset
Un bitset<N> es un array de N bits.
#include <bitset>

typedef std::bitset<16> mask;

mask m1; // 16 bits todos a 0

mask m2 = 0xaa; // 0000000010101010
mask m3 = "110100"; // 0000000000110100

m3[2] == 1;

m3 &= m2; // m3 = m3 & m2; // and

m3 |= m2; // m3 = m3 | m2; // or
m3 ^= m2; // m3 = m3 ^ m2; // xor

mask m4 = "0100000000110100";
m4 <<= 2; // 0000000011010000
m4 >>= 5; // 0000000000000110

m3.set(); // 1111111111111111

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
m4.set(5); // 0000000000100110
m4.set(2, 0); // 0000000000100010

m2.reset(); // 0000000000000000
m4.reset(5); // 0000000000000010
m4.flip(); // 1111111111111101
m4.flip(3); // 1111111111110101

m1 = ~(m4 << 3);

unsigned long val = m1.to_ulong();

std::string str = m1.to_string();

int n = m1.size(); // n´umero de bits

int n = m1.count(); // n´umero de bits a 1
bool b = m1.any(); // (m1.count() > 0)
bool b = m1.none(); // (m1.count() == 0)
bool b = m1.test(3);// (m1[3] == 1)

std::cout << m1 << std::endl;

24.14. Iteradores
Proporcionan el nexo de uni´on entre los contenedores y los algoritmos, proporcionando
una visi´on abstracta de los datos de forma que un determinado algoritmo sea independiente
de los detalles concernientes a las estructuras de datos.
Los iteradores proporcionan la visi´on de los contenedores como secuencias de objetos.
Los iteradores proporcionan, entre otras, las siguientes operaciones:

Obtener el objeto asociado al iterador

*it it->campo it->miembro()

Moverse al siguiente elemento de la secuencia

++it (-- + - += -=) advance(it, n)

Comparaci´on entre iteradores

== != (< <= > >=) n = distance(first, last)

#include <iterator>

24.15. Directos
typedef std::vector<int> vect_int;
typedef vect_int::iterator vi_it;
typedef vect_int::const_iterator vi_cit;

const int MAX = 10;

vect_int vi(MAX);

vi_it inicio_secuencia = vi.begin();

vi_it fin_secuencia = vi.end();

int n = 0;
for (vi_it i = vi.begin(); i != vi.end(); ++i) {
*i = n;

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.16. INVERSOS 301

++n;
}
// vi = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 }

vi_cit inicio_secuencia_const = vi.begin();

vi_cit fin_secuencia_const = vi.end();

for (vi_cit i = vi.begin(); i != vi.end(); ++i) {

// *i = n; // error. i es un const_iterator
cout << *i << " ";
}
// 0 1 2 3 4 5 6 7 8 9

typedef std::map<std::string, unsigned> MapStrUint;

for (MapStrUint::const_iterator it = mapa.begin(); it != mapa.end();++it)
{ std::cout << "Clave: " << it->first << " Valor: " << it->second << std::endl;
}

24.16. Inversos
typedef std::vector<int> vect_int;
typedef vect_int::iterator vi_it;
typedef vect_int::reverse_iterator vi_rit;
typedef vect_int::const_reverse_iterator vi_crit;

const int MAX = 10;

vect_int vi(MAX);

vi_rit inicio_secuencia_inversa = vi.rbegin();

vi_rit fin_secuencia_inversa = vi.rend();

int n = 0;
for (vi_rit i = vi.rbegin(); i != vi.rend(); ++i) {
*i = n;
++n;
}
// vi = { 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 }

vi_crit inicio_secuencia_inversa_const = vi.rbegin();

vi_crit fin_secuencia_inversa_const = vi.rend();

for (vi_crit i = vi.rbegin(); i != vi.rend(); ++i) {

// *i = n; // error. i es un const_iterator
cout << *i << " ";
}
// 0 1 2 3 4 5 6 7 8 9

vi_rit rit = ...;

template <typename IT, typename RIT>

inline void
reverse_to_direct(IT& it, const RIT& rit)
{
it = rit.base();
--it;
}

Un puntero a un elemento de un agregado es tambi´en un iterador para dicho agregado, y puede

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.18. STREAM ITERATORS 1

ser utilizado como tal el los algoritmos que lo requieran.

24.17. Inserters
“Inserters” producen un iterador que al ser utilizado para asignar objetos, alojan espacio para
´el en el contenedor, aumentando as´ı su taman˜o.

typedef std::back_insert_iterator<contenedor> biic;

typedef std::front_insert_iterator<contenedor> fiic;
typedef std::insert_iterator<contenedor> iic;

bit = std::back_inserter(contenedor); // a~nade elementos al final del contenedor

fiit = std::front_inserter(contenedor); // a~nade elementos al inicio del contenedor
iit = std::inserter(contenedor, it_pos); // a~nade elementos en posici´on

24.18. Stream Iterators

ostream_iterator<int> os(cout, "delimitador_de_salida");
ostream_iterator<int> os(cout);
*os = 7;
++os;
*os = 79;

istream_iterator<int> is(cin);
istream_iterator<int> fin_entrada;
int i1 = *is;
++is;
int i2 = *is;
copy(is, fin_entrada, back_inserter(v));

Ejemplo que imprime el contenido de un vector de dos dimensiones:

//------------------------------------
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
namespace std{
template <typename Tipo>
inline ostream& operator<<(ostream& out, const vector<Tipo>& v) {
copy(v.begin(), v.end(), ostream_iterator<Tipo>(out, " "));
return out;
}
}
using namespace std;
int main()
{
vector<int> libros(5, 33);
vector< vector<int> > bib(2, libros);
cout << bib << ’;’<< endl;

bib[1].erase(bib[1].begin());
cout << bib << ’;’<< endl;
}
//------------------------------------

Ejemplo que lee nu´meros de un string y los pasa a un vector:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

2 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <sstream>

using namespace std;

void str2vect(const string& entrada, vector<unsigned>& salida)

{
salida.clear();
istringstream str_entrada(entrada);
istream_iterator<unsigned> input_string_stream_it(str_entrada);
istream_iterator<unsigned> fin_input_string_stream_it;
copy(input_string_stream_it, fin_input_string_stream_it,
back_inserter(salida));
}

Ejemplo que copia el contenido de un fichero a otro:

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>

using namespace std;

void
copiar_fichero(const string& salida, const string& entrada, bool& ok)
{
typedef istream_iterator<char> Iterador_Entrada;
typedef ostream_iterator<char> Iterador_Salida;

ok = false;

ifstream f_ent(entrada.c_str());
if (f_ent) {
ofstream f_sal(salida.c_str());
if (f_sal) {
entrada.unsetf(ios::skipws);

Iterador_Entrada it_ent(f_ent);
Iterador_Entrada fit_ent;

Iterador_Salida it_sal(f_sal);

copy(it_ent, fit_ent, f_sal);

f_sal.close(); // no es necesario
}
f_ent.close(); // no es necesario
}
}

Ejemplo que carga el contenido de un fichero a un contenedor, y salva dicho contenedor a un

fichero:

#include <iostream>
#include <fstream>
#include <string>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.18. STREAM ITERATORS 3

#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

//------------------------------------
struct FileNotFound : public FileIOError {
explicit FileNotFound(const char* w) : FileIOError(w) {}
explicit FileNotFound(const string& w) : FileIOError(w) {}
};
struct FileFormatError : public FileIOError {
explicit FileFormatError(const char* w) : FileIOError(w) {}
explicit FileFormatError(const string& w) : FileIOError(w) {}
};
struct FileIOError : public std::runtime_error {
explicit FileIOError(const char* w) : std::runtime_error(w) {}
explicit FileIOError(const string& w) : std::runtime_error(w) {}
};
//------------------------------------
template <typename Contenedor>
void cargar(const string& filename, Contenedor& c)
throw(FileNotFound, FileFormatError)
{
typedef istream_iterator<typename Contenedor::value_type> InputIt;
ifstream in(filename.c_str());
if (in.fail()) { throw FileNotFound(filename); }
InputIt entrada(in);
InputIt fin_entrada;
//c.assign(entrada, fin_entrada);
//c.clear();
std::copy(entrada, fin_entrada, back_inserter(c));
if (!in.eof()) { throw FileFormatError(filename); }
}
template <typename Contenedor, typename Predicate1>
void cargar(const string& filename, Contenedor& c, const Predicate1& pred1)
throw(FileNotFound, FileFormatError)
{
typedef istream_iterator<typename Contenedor::value_type> InputIt;
ifstream in(filename.c_str());
if (in.fail()) { throw FileNotFound(filename); }
InputIt entrada(in);
InputIt fin_entrada;
//c.clear();
std::remove_copy_if(entrada, fin_entrada, back_inserter(c), not1(pred1));
if (!in.eof()) { throw FileFormatError(filename); }
}
template <typename Procedure1>
void aplicar(const string& filename, const Procedure1& proc1)
throw(FileNotFound, FileFormatError)
{
typedef istream_iterator<typename Procedure1::argument_type> InputIt;
ifstream in(filename.c_str());
if (in.fail()) { throw FileNotFound(filename); }
InputIt entrada(in);
InputIt fin_entrada;
std::for_each(entrada, fin_entrada, proc1);
if (!in.eof()) { throw FileFormatError(filename); }
}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

4 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
%-------------------------------------
template <typename Tipo>
struct AreaEq : public std::unary_function<Tipo, bool> {
string val;
explicit AreaEq(const string& a) : val(a) {}
bool operator()(const Tipo& v) const {
return val == v.get_area();
}
};
template <typename TipoB, typename TipoE>
struct Apply : public std::unary_function<TipoE, void>
{ typedef void (TipoB::*PtrFun)(const TipoE&);
TipoB& obj;
PtrFun ptr_fun;
explicit Apply(TipoB& o, PtrFun f) : obj(o), ptr_fun(f ) {}
void operator()(const TipoE& e) const {
(obj.*ptr_fun)(e);
}
};
template <typename TipoB, typename TipoE, typename Predicate1>
struct ApplyIf : public std::unary_function<TipoE, void> {
typedef void (TipoB::*PtrFun)(const TipoE&);
TipoB& obj;
PtrFun ptr_fun;
Predicate1 pred1;
explicit ApplyIf(TipoB& o, PtrFun f, const Predicate1& p) : obj(o), ptr_fun(f), pred1(p) {}
void operator()(const TipoE& e) const {
if (pred1(e)) {
(obj.*ptr_fun)(e);
}
}
};
//------------------------------------
template <typename Contenedor>
void salvar(const string& filename, const Contenedor& c)
throw(FileNotFound, FileFormatError)
{
typedef ostream_iterator<typename Contenedor::value_type> OutputIt;
ofstream out(filename.c_str());
if (out.fail()) { throw FileNotFound(filename); }
OutputIt salida(out, " ");
copy(c.begin(), c.end(), salida);
if (out.fail()) { throw FileFormatError(filename); }
}
template <typename Contenedor, typename Predicate1>
void salvar(const string& filename, const Contenedor& c, const Predicate1& pred1)
throw(FileNotFound, FileFormatError)
{
typedef ostream_iterator<typename Contenedor::value_type> OutputIt;
ofstream out(filename.c_str());
if (out.fail()) { throw FileNotFound(filename); }
OutputIt salida(out, " ");
remove_copy_if(c.begin(), c.end(), salida, not1(pred1));
if (out.fail()) { throw FileFormatError(filename); }
}
template <typename Tipo>
struct MayorQue : public std::unary_function<Tipo, bool>
{ Tipo base;
explicit MayorQue(const Tipo& x) : base(x) {}

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 24.18. STREAM ITERATORS 5

bool operator()(const Tipo& x) const

{ return x > base;
}
}
//------------------------------------
int main()
{
vector<int> cnt;
cargar(cnt, "entrada.txt");
salvar(cnt, "salida.txt", MayorQue(5));

cargar(filename, profesores, AreaEq<Profesor>(cfg.area));

aplicar(filename, ApplyIf<Asignaturas,AsgNAT,AreaEq<AsgNAT> >(asignaturas,&Asignaturas::set_sin_pri

24.19. Operaciones sobre Iteradores

Operaciones sobre Iteradores
|Salida |Entrada|Avance |Bidir |Random
------------+-------+-------+-------+-------+--------------------- -
Leer | | =*p | =*p | =*p | =*p
Acceso | | -> | -> | -> | -> []
Escribir | *p= | | *p= | *p= | *p=
Iteraci´on | ++ | ++ | ++ | ++ -- | ++ -- + - += -=
Comparac | | == != | == != | == != | == != < > >= <=
------------+-------+-------+-------+-------+--------------------- -

24.20. Objetos Funcio´n y Predicados

#include <functional>

using namespace std;

bool pred1(obj);
bool pred2(obj1, obj2);
bool cmp2(obj1, obj2); // bool less<Tipo>(o1, o2)

void proc1(obj);
void proc2(obj1, obj2);
tipo func1(obj);
tipo func2(obj1, obj2);

//Objetos funci´on => res operator() (t1 a1, t2 a2) const {}

//base de los objetos
unary_function<argument_type, result_type>
binary_function<first_argument_type, second_argument_type, result_type>

template <typename Tipo>

struct logical_not : public unary_function < Tipo , bool >
{ bool operator() (const Tipo& x) const { return !x; }
};
template <typename Tipo>
struct less : public binary_function < Tipo , Tipo , bool > {
bool operator() (const Tipo& x, const Tipo& y) const { return x < y; }
};

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.20. OBJETOS FUNCIO´ N Y PREDICADOS 307

pair<it1,it2> p1 = mismatch(vi.begin(), vi.end(), li.begin(), less<int>());

struct persona {
string nombre;
. . .
};

class persona_eq : public unary_function< persona , bool > {

public:
explicit persona_eq(const string& n) : _nm(n) {}
bool operator() (const persona& p) const { return _nm == p.nombre; }
private:
const string _nm;
};

it = find_if(lc.begin(), lc.end(), persona_eq("pepe"));

Creaci´on de Objetos funci´on a partir de existentes

Binder: permite que una funci´on de 2 argumentos se utilice como una funci´on de 1 argumento,
ligando un argumento a un valor fijo.

objeto_funcion_unario = bind1st(operacion_binaria, argumento_fijo_1);

objeto_funcion_unario = bind2nd(operacion_binaria, argumento_fijo_2);

it = find_if(c.begin(), c.end(), bind2nd(less<int>(), 7));

Adapter: convierte la llamada a una funci´on con un objeto como argumento a una
llamada a un m´etodo de dicho objeto. Ej: of(obj) se convierte a obj->m1().

objeto_funcion_unario = mem_fun(ptr_funcion_miembro_0_arg);
objeto_funcion_unario = mem_fun_ref(ptr_funcion_miembro_0_arg);

// l es un contenedor<Shape*>
for_each(l.begin(), l.end(), mem_fun(&Shape::draw)); // elem->draw()
// l es un contenedor<Shape>
for_each(l.begin(), l.end(), mem_fun_ref(&Shape::draw)); // elem.draw()
// l es un contenedor<string>
it = find_if(l.begin(), l.end(), mem_fun_ref(&string::empty)); // elem.empty()

objeto_funcion_binario = mem_fun1(ptr_funcion_miembro_1_arg);
objeto_funcion_binario = mem_fun1_ref(ptr_funcion_miembro_1_arg);

// l es un contenedor<Shape*> elem->rotate(30)
for_each(l.begin(), l.end(), bind2nd(mem_fun1(&Shape::rotate), 30));
// l es un contenedor<Shape> elem.rotate(30)
for_each(l.begin(), l.end(), bind2nd(mem_fun1_ref(&Shape::rotate), 30));

Un adaptador de puntero a funci´on crea un objeto funci´on equivalente a una funci´on. Para
utilizar funciones con los “binders” y “adapters”.

objeto_funcion_unario = ptr_fun(ptr_funcion_1_arg);
objeto_funcion_binario = ptr_fun(ptr_funcion_2_arg);

it = find_if(l.begin(), l.end(), not1(bind2nd(ptr_fun(strcmp), "pepe")));

Negater: permite expresar la negaci´on de un predicado.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
objeto_funcion_unario = not1(predicado_unario);
objeto_funcion_binario = not2(predicado_binario);

it = find_if(l.begin(), l.end(), not1(bind2nd(ptr_fun(strcmp), "pepe")));

p1 = mismatch(l.begin(), l.end(), li.begin(), not2(less<int>()));

Ejemplo:

#include <iostream>
#include <string>
#include <list>
#include <algorithm>

using namespace std;

typedef list<const char*> List_str;

/*
* Busca la primera ocurrencia de ’cad’ en lista
*/
const char*
buscar(const List_str& ls, const char* cad)
{
typedef List_str::const_iterator LI;
LI p = find_if(ls.begin(), ls.end(),
not1(bind2nd(ptr_fun(strcmp), cad)) );
/*
* LI p = find_if(ls.begin(), ls.end(),
* bind2nd(equal_to<string>(), cad) );
*/
if (p == ls.end())
{ return NULL;
} else {
return *p;
}
}
int
main()
{
List_str lista;
lista.push_back("mar´ıa");
lista.push_back("lola");
lista.push_back("pepe");
lista.push_back("juan");
const char* nm = buscar(lista, "lola");
if (nm == NULL) {
cout << "No encontrado" << endl;
} else {
cout << nm << endl;
}
}

Objetos Predicados

equal_to <tipo> (x, y)

not_equal_to <tipo> (x, y)
greater <tipo> (x, y)
less <tipo> (x, y)
greater_equal <tipo> (x, y)
less_equal <tipo> (x, y)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.21. ALGORITMOS 309

logical_and <tipo> (b, b)

logical_or <tipo> (b, b)
logical_not <tipo> (b)

Objetos Operaciones Aritm´eticas

plus <tipo> (x, y)

minus <tipo> (x, y)
multiplies <tipo> (x, y)
divides <tipo> (x, y)
modulus <tipo> (x, y)
negate <tipo> (x)

24.21. Algoritmos
#include <algorithm>

Operaciones que no modifican la secuencia

for_each(f, l, proc1) // aplica proc1 a [f:l)

it = find(f, l, x) // busca x en [f:l)
it = find_if(f, l, pred1) // busca si pred es true en [f:l)
it = find_first_of(f, l, p, u) // busc prim [p:u) en [f:l)
it = find_first_of(f, l, p, u, pred2) //
it = adjacent_find(f, l) // encuentra adyacentes iguales
it = adjacent_find(f, l, pred2) //
n = count(f, l, x) // cuenta cuantas veces aparece x en [f:l)
n = count_if(f, l, pred1) //
b = equal(f, l, f2) // compara 2 secuencias
b = equal(f, l, f2, pred2) //
p = mismatch(f, l, f2) // busca la primera diferencia
p = mismatch(f, l, f2, pred2) //
it = search(f, l, p, u) // buscan una subsecuencia en otra
it = search(f, l, p, u, pred2) //
it = find_end(f, l, p, u) // search hacia atras
it = find_end(f, l, p, u, pred2)//
it = search_n(f, l, n, x) // busca la sec "x n veces" en [f:l)
it = search_n(f, l, n, x, pred2)//

Operaciones que modifican la secuencia

transform(f, l, d, func1) // copia [f:l) a d aplicando func1

transform(f, l, ff, d, func2) // copia [f:l) a d aplicando func2

copy(f, l, d) // copia [f:l) a d

copy_backward(f, l, d) // copia [f:l) a d (hacia atras)

swap(a, b) // intercambia los elementos a y b

iter_swap(ita, itb) // intercambia los elementos *ita y *itb
swap_ranges(f, l, d) // swap [f:l) por [d:dd)

replace(f, l, v, nv) // reemplaza v por nv en [f:l)

replace_if(f, l, pred1, nv) // reemplaza si pred1 por nv en [f:l)
replace_copy(f, l, d, v, nv) // reemplaza v por nv de [f:l) en d
replace_copy_if(f, l, d, pred1, nv)

fill(f, l, v) // pone los valores de [f:l) a v

fill_n(f, n, v) // pone n valores a partir de f a v

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
generate(f, l, g) // pone los valores de [f:l) a g()
generate_n(f, n, g) // pone n valores a partir de f a g()

it = remove(f, l, v) // elimina elementos de [f:l) iguales a v

it = remove_if(f, l, pred1)
remove_copy(f, l, d, v)
remove_copy_if(f, l, d, pred1)

it = unique(f, l) // elimina copias adyacentes de [f:l)

it = unique(f, l, pred1) // elimina copias adyacentes de [f:l)
unique_copy(f, l, d) // copia sin duplicaciones de [f:l) a d

reverse(f, l) // invierte el orden de los elementos

reverse_copy(f, l, d) // invierte el orden de los elementos

rotate(f, m, l) // rota [f:l) hasta que m sea el primero

rotate_copy(f, m, l, d)

random_shuffle(f, l) // baraja aleatoriamente

random_shuffle(f, l, g)

donde aparece d => back_inserter(c)

para eliminar en el mismo contenedor:

sort(c.begin(), c.end());
it p = unique(c.begin(), c.end());
c.erase(p, c.end());

Ordenaciones

sort(f, l) // ordena [f:l) (O(n*log(n)), O(n*n) peorcaso )

sort(f, l, cmp2) // ordena [f:l) seg´un cmp2
stable_sort(f, l) // ordena [f:l) (O(n*log(n)*log(n)))
partial_sort(f, m, l) // ordena [f:m)
partial_sort(f, m, l, cmp2) // ordena [f:m)
partial_sort_copy(f, l, ff, ll) //
partial_sort_copy(f, l, ff, ll, cmp2)//
nth_element(f, n , l) // pone el n-´esimo elemento en su posici
´on nth_element(f, n , l, cmp2) // pone el n-´esimo elemento en su posici
´on it = lower_bound(f, l, v) // primer elemento mayor o igual a v
it = upper_bound(f, l, v) // primer elemento mayor a v
parit = equal_range(f, l, v) // rango de elementos igual a v
b = binary_search(f, l, v) // b´usqueda binaria (si esta)
b = binary_search(f, l, v, cmp2)//
merge(f, l , ff, ll, d) // mezcla ordenada
inplace_merge(f, m ,l) // mezcla ordenada
partition(f, l , pred1) // mueve los elementos que satisfacen pred1
stable_partition(f, l , pred1) // mueve los elementos que satisfacen pred1

Conjuntos

b = includes(f, l, ff, ll)

set_union(f, l, ff, ll, d)
set_intersection(f, l, ff, ll, d)
set_difference(f, l, ff, ll, d)
set_symmetric_difference(f, l, ff, ll, d)

Heap

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.22. GARANT´IAS (EXCEPCIONES) DE OPERACIONES SOBRE CONTENEDORES 311

make_heap(f, l)
push_heap(f, l)
pop_heap(f, l)
sort_heap(f, l)

Comparaciones

x = min(a, b)
x = min(a, b, cmp2)
x = max(a, b)
x = max(a, b, cmp2)
x = min_element(f, l)
x = min_element(f, l, cmp2)
x = max_element(f, l)
x = max_element(f, l, cmp2)
b = lexicographical_compare(f, l, ff, ll) // <
b = lexicographical_compare(f, l, ff, ll, cmp2)

Permutaciones

b = next_permutation(f, l)
b = next_permutation(f, l, cmp2)
b = prev_permutation(f, l)
b = prev_permutation(f, l, cmp2)

24.22. Garant´ıas (Excepciones) de Operaciones sobre

Con- tenedores
| vector | deque | list | map
-------------------+----------------------------------------------------- -
clear() | nothrow nothrow nothrow nothrow
| (copy) (copy)
erase() | nothrow nothrow nothrow nothrow
| (copy) (copy)
1-element insert() | strong strong strong strong
| (copy) (copy)
N-element insert() | strong strong strong basic
| (copy) (copy)
merge() | ----- ------ nothrow -----
| (comparison)
push_back() | strong strong strong -----
|
push_front() | ----- strong strong -----
|
pop_back() | nothrow nothrow nothrow -----
|
pop_front() | ----- nothrow nothrow -----
|
remove() | ----- ----- nothrow -----
| (comparison)
remove_if() | ----- ----- nothrow -----
| (predicate)
reverse() | ----- ----- nothrow -----
|
splice() | ----- ----- nothrow -----
|
swap() | nothrow nothrow nothrow nothrow
| (copy-of-comparison)

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL
unique() | ----- ----- nothrow -----
| (comparison)
-------------------+----------------------------------------------------- -

Las siguientes garant´ıas se ofrecen bajo la condici´on de que las operaciones suministradas
por el usuario (asignaciones, swap, etc) no dejen a los elementos del contenedor en un estado inv
´alido, que no pierdan recursos, y que los destructores no eleven excepciones.

basic las invariantes b´asicas de la biblioteca se mantienen y no se producen perdidas de recursos

(como la memoria)
strong adem´as de la b´asica, la operaci´on, o tiene ´exito o no tiene efecto.
nothrow adem´as de la b´asica, se garantiza que no elevar´a excepciones.

24.23. Num´ericos
#include <numeric>

v = accumulate(f, l, vi) // v = vi + SUM(*it) ParaTodo it in [f, l)

v = accumulate(f, l, vi, func2) // v = f2(vi, F2(*it)) ParaTodo it in [f, l)

v = inner_product(f, l, ff, vi) // v = vi + SUM(*it1 * *it2) ...

v = inner_product(f, l, ff, vi, f2_1, f2_2) // v = f2_1(vi, F2_2(*it1,*it2)) ...

adjacent_difference(f, l, d) // [a, b, c, ...] -> [a, b-a, c-b, ...]

adjacent_difference(f, l, d, func2)

partial_sum(f, l, d) // [a, b, c, ...] -> [a, a+b, a+b+c, ...]

partial_sum(f, l, d, func2)

24.24. L´ımites
#include <limits>

numeric_limits<char>::is_specialized = true;
numeric_limits<char>::digits = 7; // d´ıgitos excluyendo signo
numeric_limits<char>::is_signed = true;
numeric_limits<char>::is_integer = true;
numeric_limits<char>::min() { return -128; }
numeric_limits<char>::max() { return 128; }

numeric_limits<float>::is_specialized = true;
numeric_limits<float>::radix = 2; // base del exponente
numeric_limits<float>::digits = 24; // n´umero de d´ıgitos (radix) en mantisa
numeric_limits<float>::digits10 = 6; // n´umero de d´ıgitos (base10) en mantisa
numeric_limits<float>::is_signed = true;
numeric_limits<float>::is_integer = false;
numeric_limits<float>::is_exact = false;
numeric_limits<float>::min() { return 1.17549435E-38F; }
numeric_limits<float>::max() { return 3.40282347E+38F; }
numeric_limits<float>::epsilon() { return 1.19209290E-07F; } // 1+epsilon-1
numeric_limits<float>::round_error() { return 0.5; }
numeric_limits<float>::infinity() { return xx; }
numeric_limits<float>::quiet_NaN() { return xx; }
numeric_limits<float>::signaling_NaN() { return xx; }
numeric_limits<float>::denorm_min() { return min(); }

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

24.25. RUN TIME TYPE INFORMATION (RTTI) 313

numeric_limits<float>::min_exponent = -125;
numeric_limits<float>::min_exponent10 = -37;
numeric_limits<float>::max_exponent = +128;
numeric_limits<float>::max_exponent10 = +38;
numeric_limits<float>::has_infinity = true;
numeric_limits<float>::has_quiet_NaN = true;
numeric_limits<float>::has_signaling_NaN = true;
numeric_limits<float>::has_denorm = denorm_absent;
numeric_limits<float>::has_denorm_loss = false;
numeric_limits<float>::is_iec559 = true;
numeric_limits<float>::is_bounded = true;
numeric_limits<float>::is_modulo = false;
numeric_limits<float>::traps = true;
numeric_limits<float>::tinyness_before = true;
numeric_limits<float>::round_style = round_to_nearest;

24.25. Run Time Type Information (RTTI)

#include <typeinfo>

class type_info {
public:
virtual ~type_info();

bool operator== (const type_info&) const;

bool operator!= (const type_info&) const;
bool before (const type_info&) const;

const char* name() const;

};
const type_info& typeid(type_name) throw();
const type_info& typeid(expression) throw(bad_typeid);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 CAP´ITULO 24. BIBLIOTECA ESTA´ NDAR DE C++.
STL

1
Ap´endice A

Precedencia de Operadores en C

+----------------------------------------------------------------------- +
| Precedencia de Operadores y Asociatividad |
+-----------------------------------------------+----------------------- +
| Operador | Asociatividad |
+-----------------------------------------------+----------------------- +
| () [] -> . | izq. a dch. |
| ! ~ ++ -- - (tipo) * & sizeof | [[[ dch. a izq. ]]] |
| * / % | izq. a dch. |
| + - | izq. a dch. |
| << >> | izq. a dch. |
| < <= > >= | izq. a dch. |
| == != | izq. a dch. |
| & | izq. a dch. |
| ^ | izq. a dch. |
| | | izq. a dch. |
| && | izq. a dch. |
| || | izq. a dch. |
| ?: | [[[ dch. a izq. ]]] |
| = += -= *= /= %= &= ^= |= <<= >>= | [[[ dch. a izq. ]]] |
| , | izq. a dch. |
+-----------------------------------------------+----------------------- +

+----------------------------------------------------------------------- +
| Orden de Evaluaci´on |
+----------------------------------------------------------------------- +
| Pag. 58-59 K&R 2 Ed. |
| Como muchos lenguajes, C no especifica el orden en el cual |
| Los operandos de un operador seran evaluados (excepciones |
| son && || ?: ,). La coma se evalua de izda a dcha y el valor |
| que toma es el de la derecha. |
| Asi mismo, el orden en que se evaluan los argumentos de una |
| funci´on no esta especificado. |
+----------------------------------------------------------------------- +

+----------------------------------------------------------------------- +
| Constantes Car´acter: |
| [\n=NL] [\t=TAB] [\v=VTAB] [\b=BS] [\r=RC] [\f=FF] [\a=BEL] |
+----------------------------------------------------------------------- +

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 APE´ NDICE A. PRECEDENCIA DE OPERADORES EN
C

1
Ap´endice B

Precedencia de Operadores en
C++

===============================================================================
nombre_clase::miembro Resoluci´on de ambito
nombre_esp_nombres::miembro Resoluci´on de ambito
::nombre Ambito global
::nombre_calificado Ambito global

objeto.miembro Selecci´on de miembro

puntero->miembro Selecci´on de miembro
puntero[expr] Indexaci´on
expr(list_expr) Llamada a funci´on
tipo(list_expr) Construcci´on de valor
valor_i++ Post-incremento
valor_i-- Post-decremento
typeid(tipo) Identificaci´on de tipo
typeid(expr) Identificaci´on de tipo en tiempo de ejecuci´on
dynamic_cast<tipo>(expr) Conversi´on en TEjecuci´on con verificaci´on
static_cast<tipo>(expr) Conversi´on en TCompilaci´on con verificaci´on
reinterpret_cast<tipo>(expr) Conversi´on sin verificaci´on
const_cast<tipo>(expr) Conversi´on const

sizeof expr Tama~no del objeto

sizeof(tipo) Tama~no del tipo
++valor_i Pre-incremento
--valor_i Pre-decremento
~expr Complemento
!expr Negaci´on logica
-expr Menos unario
+expr Mas unario
&valor_i Direcci´on de
*expr Desreferencia
new tipo Creaci´on (asignaci´on de memoria)
new tipo(list_expr) Creaci´on (asignaci´on de memoria e iniciaci´on)
new tipo [expr] Creaci´on de array (asignaci´on de memoria)
new (list_expr) tipo Creaci´on (emplazamiento)
new (list_expr) tipo(list_expr) Creaci´on (emplazamiento e iniciaci´on)
delete puntero Destrucci´on (liberaci´on de memoria)
delete [] puntero Destrucci´on de un array
(tipo) expr Conversi´on de tipo

objeto.*puntero_a_miembro Selecci´on de miembro

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 APE´ NDICE B. PRECEDENCIA DE OPERADORES EN C+
+
puntero->*puntero_a_miembro Selecci´on de miembro

expr * expr Multiplicaci´on

expr / expr Divisi´on
expr % expr M´odulo

expr + expr Suma

expr - expr Resta

expr << expr Desplazamiento a izquierda

expr >> expr Desplazamiento a derecha

expr < expr Menor que

expr <= expr Menor o igual que
expr > expr Mayor que
expr >= expr Mayor o igual que

expr == expr Igual

expr != expr No igual

expr & expr AND de bits

expr ^ expr XOR de bits

expr | expr OR de bits

expr && expr AND logico

expr || expr OR logico

expr ? expr : expr Expresi´on condicional

valor_i = expr Asignaci´on simple

valor_i *= expr Multiplicaci´on y asignaci´on
valor_i /= expr Divisi´on y asignaci´on
valor_i %= expr M´odulo y asignaci´on
valor_i += expr Suma y asignaci´on
valor_i -= expr Resta y asignaci´on
valor_i <<= expr Despl izq y asignaci´on
valor_i >>= expr Despl dch y asignaci´on
valor_i &= expr AND bits y asignaci´on
valor_i ^= expr XOR bits y asignaci´on
valor_i |= expr OR bits y asignaci´on

throw expr Lanzar una excepci´on

expr , expr Secuencia

===============================================================================

===============================================================================
Notas

Cada casilla contine operadores con la misma precedencia.

Los operadores de casillas mas altas tienen mayor precedencia que los
operadores de casillas mas bajas.

Los operadores unitarios, los operadores de asignaci´on y el

operador condicional son asociativos por la derecha.

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 319

Todos los demas son asociativos por la izquierda.

Sacado de "El Lenguaje de Programaci´on C++" de B. Stroustrup. pg. 124

===============================================================================

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 APE´ NDICE B. PRECEDENCIA DE OPERADORES EN C+
+

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 Ap´endice C

Biblioteca B´asica ANSI-C (+

conio)

En este ap´endice veremos superficialmente algunas de las funciones m ´a s importantes de

la biblioteca est´andar de ANSI-C y C++.

C.1. cassert
#include <cassert>

void assert(bool expresion);

// macro de depuraci´on. Aborta y mensaje si expresi´on es falsa
// si NDEBUG esta definido, se ignora la macro

C.2. cctype
#include <cctype>

bool isalnum(char ch); // (isalpha(ch) || isdigit(ch))

bool isalpha(char ch); // (isupper(ch) || islower(ch))
bool iscntrl(char ch); // caracteres de control
bool isdigit(char ch); // d´ıgito decimal
bool isgraph(char ch); // caracteres imprimibles excepto espacio
bool islower(char ch); // letra min´uscula
bool isprint(char ch); // caracteres imprimibles incluyendo espacio
bool ispunct(char ch); // carac. impr. excepto espacio, letra o d´ıgito
bool isspace(char ch); // esp, \r, \n, \t, \v, \f
bool isupper(char ch); // letra may´uscula
bool isxdigit(char ch); // d´ıgito hexadecimal

char tolower(char ch); // convierte ch a min´uscula

char toupper(char ch); // convierte ch a may´uscula

C.3. cmath
#include <cmath>

double sin(double rad); // seno de rad (en radianes)

double cos(double rad); // coseno de rad (en radianes)
double tan(double rad); // tangente de rad (en radianes)

321
 1 APE´ NDICE C. BIBLIOTECA BA´ SICA ANSI-C (+
CONIO)
double asin(double x); // arco seno de x, x en [-1,1]
double acos(double x); // arco coseno de x, x en [-1,1]
double atan(double x); // arco tangente de x
double atan2(double y, double x); // arco tangente de y/x
double sinh(double rad); // seno hiperb´olico de rad
double cosh(double rad); // coseno hiperb´olico de rad
double tanh(double rad); // tangente hiperb´olica de rad
double exp(double x); // e elevado a x
double log(double x); // logaritmo neperiano ln(x), x > 0
double log10(double x); // logaritmo decimal log10(x), x > 0
double pow(double x, double y); // x elevado a y
double sqrt(double x); // raiz cuadrada de x, x >= 0
double ceil(double x); // menor entero >= x
double floor(double x); // mayor entero <= x
double fabs(double x); // valor absoluto de x
double ldexp(double x, int n); // x * 2 elevado a n
double frexp(double x, int* exp); // inversa de ldexp
double modf(double x, double* ip); // parte entera y fraccionaria
double fmod(double x, double y); // resto de x / y

C.4. cstdlib
#include <cstdlib>

double atof(const char orig[]); // cadena a double

int atoi(const char orig[]); // cadena a int
long atol(const char orig[]); // cadena a long

double strtod(const char orig[], char** endp);

long strtol(const char orig[], char** endp, int base);
unsigned long strtoul(const char orig[], char** endp, int base);

void srand(unsigned semilla); // srand(time(0));

int rand();// devuelve un aleatorio entre 0 y RAND_MAX (ambos inclusive)

/* Devuelve un n´umero aleatorio entre 0 y max (exclusive) */

inline unsigned aleatorio(int max) { return unsigned(max*double(rand())/(RAND_MAX+1.0)); }

void abort(); // aborta el programa como error

void exit(int estado); // terminaci´on normal del programa
int atexit(void (*fcn)(void));
// funci´on a ejecutar cuando el programa termina normalmente

int system(const char orden[]);

// orden a ejecutar por el sistema operativo

char* getenv(const char nombre[]);

// devuelve el valor de la variable de entorno ’nombre’

int abs(int n); // valor absoluto

long labs(long n); // valor absoluto

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*));
void *bsearch(const void *key, const void *base, size_t nitems, size_t size,
int (*compar)(const void *, const void *));

void *malloc(size_t size);

void *realloc(void *ptr, size_t size);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 C.5. CLIMITS 323

void *calloc(size_t nitems, size_t size);

void free(void *ptr);

C.5. climits
#include <climits>

CHAR_BIT = 8

CHAR_MAX | SHRT_MAX | INT_MAX | LONG_MAX | LONG_LONG_MAX

CHAR_MIN | SHRT_MIN | INT_MIN | LONG_MIN | LONG_LONG_MIN
UCHAR_MAX | USHRT_MAX | UINT_MAX | ULONG_MAX | ULONG_LONG_MAX
SCHAR_MAX |
SCHAR_MIN |

C.6. cfloat
#include <cfloat>

FLT_EPSILON // menor n´umero float X tal que 1.0+X != 1.0

FLT_MAX // m´aximo n´umero de punto flotante
FLT_MIN // m´ınimo n´umero normalizado de punto flotante

DBL_EPSILON // menor n´umero double X tal que 1.0+X != 1.0

DBL_MAX // m´aximo n´umero double de punto flotante
DBL_MIN // m´ınimo n´umero double normalizado de punto flotante

LDBL_EPSILON // menor n´umero long double X tal que 1.0+X != 1.0

LDBL_MAX // m´aximo n´umero long double de punto flotante
LDBL_MIN // m´ınimo n´umero long double normalizado de punto flotante

C.7. ctime
#include <ctime>

clock_t clock();
// devuelve el tiempo de procesador empleado por el programa
// para pasar a segundos: double(clock())/CLOCKS_PER_SEC
// en un sistema de 32 bits donde CLOCKS_PER_SEC = 1000000
// tiene un rango de 72 minutos aproximadamente. (c2-c1)
time_t time(time_t* tp);
// devuelve la fecha y hora actual del calendario
double difftime(time_t t2, time_t t1);
// devuelve t2 - t1 en segundos
time_t mktime(struct tm* tp);
struct tm* gmtime(const time_t* tp);

C.8. cstring
#include <cstring>

unsigned strlen(const char s1[]);

// devuelve la longitud de la cadena s1

char* strcpy(char dest[], const char orig[]);

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

 1 APE´ NDICE C. BIBLIOTECA BA´ SICA ANSI-C (+
CONIO)
char* strncpy(char dest[], const char orig[], unsigned n);
// Copia la cadena orig a dest (incluyendo el terminador ’\0’).
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// (si alcanza el l´ımite, no incluye el terminador ’\0’)

char* strcat(char dest[], const char orig[]);

char* strncat(char dest[], const char orig[], unsigned n);
// Concatena la cadena orig a la cadena dest.
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// (si alcanza el l´ımite, no incluye el terminador ’\0’)

int strcmp(const char s1[], const char s2[]);

int strncmp(const char s1[], const char s2[], unsigned n);
// Compara lexicogr´aficamente las cadenas s1 y s2.
// Si aparece ’n’, hasta como m´aximo ’n’ caracteres
// devuelve <0 si s1<s2, 0 si s1==s2, >0 si s1>s2

const char* strchr(const char s1[], char ch);

// devuelve un apuntador a la primera ocurrencia de ch en s1
// NULL si no se encuentra
const char* strrchr(const char s1[], char ch);
// devuelve un apuntador a la ´ultima ocurrencia de ch en s1
// NULL si no se encuentra

unsigned strspn(const char s1[], const char s2[]);

// devuelve la longitud del prefijo de s1 de caracteres
// que se encuentran en s2
unsigned strcspn(const char s1[], const char s2[]);
// devuelve la longitud del prefijo de s1 de caracteres
// que NO se encuentran en s2

const char* strpbrk(const char s1[], const char s2[]);

// devuelve un apuntador a la primera ocurrencia en s1
// de cualquier car´acter de s2. NULL si no se encuentra

const char* strstr(const char s1[], const char s2[]);

// devuelve un apuntador a la primera ocurrencia en s1
// de la cadena s2. NULL si no se encuentra

void* memcpy(void* dest, const void* origen, unsigned n);

// copia n caracteres de origen a destino. NO V´alido si se solapan

void* memmove(void* dest, const void* origen, unsigned n);

// copia n caracteres de origen a destino. V´alido si se solapan

int memcmp(const void* m1, const void* m2, unsigned n);

// Compara lexicogr´aficamente ’n’ caracteres de m1 y m2
// devuelve <0 si m1<m2, 0 si m1==m2, >0 si m1>m2

const void* memchr(const void* m1, char ch, unsigned n);

// devuelve un apuntador a la primera ocurrencia de ch
// en los primeros n caracteres de m1. NULL si no se encuentra
void* memset(void* m1, char ch, unsigned n);
// coloca el car´acter ch en los primeros n caracteres de m1

C.9. cstdio
#include <cstdio>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

C.10. CSTDARG 325

int remove(const char filename[]); // elimina filename. Si fallo -> != 0

int rename(const char oldname[], const char newname[]);

FILE *fopen(const char *filename, const char *mode); // mode: "rwab+"

FILE *freopen(const char *filename, const char *mode, FILE *stream);
int fclose(FILE *stream);

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

int fflush(FILE *stream);

int fgetpos(FILE *stream, fpos_t *pos);

int fsetpos(FILE *stream, const fpos_t *pos);

long ftell(FILE *stream);

int fseek(FILE *stream, long offset, int whence); // SEEK_SET, SEEK_CUR, SEEK_END
void rewind(FILE *stream);

int ferror(FILE *stream);

int feof(FILE *stream);
void clearerr(FILE *stream);

void setbuf(FILE *stream, char *buffer);

int setvbuf(FILE *stream, char *buffer, int mode, size_t size);

FILE *tmpfile(void);
char *tmpnam(char *str);

int printf(const char *format,.......);

int fprintf(FILE *stream, const char *format,........);
int sprintf(char *str, const char *format,........);
int vprintf(const char *format, va_list arg);
int vfprintf(FILE *stream, const char *format, va_list arg);
int vsprintf(char *str, const char *format, va_list arg);

int scanf(const char *format,........);

int fscanf(FILE *stream, const char *format,........);
int sscanf(const char *str, const char *format,........);

int putchar(int char);

int putc(int char, FILE *stream);
int fputc(int char, FILE *stream);
int fputs(const char *str, FILE *stream);

int getchar(void); // EOF is returned

int getc(FILE *stream); // EOF is returned
int fgetc(FILE *stream); // EOF is returned
char *fgets(char *str, int n, FILE *stream);

int ungetc(int char, FILE *stream);

void perror(const char *str);

C.10. cstdarg
#include <cstdarg>

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 APE´ NDICE C. BIBLIOTECA BA´ SICA ANSI-C (+
CONIO)

void va_start(va_list ap, last_arg);

type va_arg(va_list ap, type);
void va_end(va_list ap);

int acumular(int num_args, ...)

{
int i;
int sum=0;
va_list ap;
va_start(ap,num_args);
for(i = 0; i < num_args; ++i) {
sum += va_arg(ap, int);
}
va_end(ap);
return sum;
}

C.11. conio.h
#include <conio.h> (no es estandar ANSI)

- Salida y entrada de texto

int cprintf(const char* fmt, ...);
// envia texto formateado a la pantalla
int cputs(const char* _str);
// envia una cadena de caracteres a pantalla
int putch(int _c);
// envia un car´acter simple a pantalla
int cscanf(const char* fmt, ...);
// entrada formateada de datos de consola
char* cgets(char* _str);
// entrada de una cadena de caracteres de consola
int getche(void);
// lee un car´acter (con eco)
int getch(void);
// lee un car´acter (sin eco)
int kbhit(void);
// comprueba si hay pulsaciones de teclado
int ungetch(int);
// devuelve el car´acter al buffer de teclado

- Manipulaci´on de texto (y cursor) en pantalla

void clrscr(void);
// borra e inicializa la pantalla
void clreol(void);
// borra la l´ınea desde el cursor al final
void delline(void);
// elimina la l´ınea donde se encuentra el cursor
void gotoxy(int x, int y);
// posiciona el cursor
void insline(void);
// inserta una l´ınea en blanco
int movetext(int _left, int _top, int _right, int _bottom,
int _destleft, int _desttop);
// copia texto de una zona de pantalla a otra

- Movimientos de bloques

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

C.11. CONIO.H 327

int gettext(int _left, int _top, int _right, int _bottom, void*_destin);
// copia texto de pantalla a memoria
int puttext(int _left, int _top, int _right, int _bottom, void*_source);
// copia texto de memoria a pantalla

- Control de ventanas
void textmode(int _mode);
// pone el modo texto
void window(int _left, int _top, int _right, int _bottom);
// define una ventana de texto
void _set_screen_lines(int nlines);
void _setcursortype(int _type); // _NOCURSOR, _SOLIDCURSOR, _NORMALCURSOR

- Ajuste de color del texto y del fondo

void textcolor(int _color);
// actualiza el color de texto
void textbackground(int _color);
// actualiza el color de fondo
void textattr(int _attr);
// actualiza el color de texto y el de fondo al mismo tiempo

- Control de intensidad
void intensevideo(void);
void highvideo(void);
// alta intensidad
void lowvideo(void);
// baja intensidad
void normvideo(void);
// intensidad normal
void blinkvideo(void);
// parpadeo

- Informaci´on
void gettextinfo(struct text_info *_r);
// informaci´on sobre la ventana actual
int wherex(void);
// valor de la coordenada x del cursor
int wherey(void);
// valor de la coordenada y del cursor

struct text_info {
unsigned char winleft;
unsigned char wintop;
unsigned char winright;
unsigned char winbottom;
unsigned char attribute;
unsigned char normattr;
unsigned char currmode;
unsigned char screenheight; // N´umero de l´ıneas de la pantalla
unsigned char screenwidth; // N´umero de columnas de la pantalla
unsigned char curx; // Columna donde se encuentra el cursor
unsigned char cury; // Fila donde se encuentra el cursor
};

La esquina superior izquierda se corresponde con las coordenadas [1,1].

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

1 APE´ NDICE C. BIBLIOTECA BA´ SICA ANSI-C (+
CONIO)

1
Ap´endice D

El Preprocesador

Directivas de pre-procesamiento:
#include <system_header>
#include "user_header"

#line xxx
#error mensaje
#pragma ident

#define mkstr_2(xxx) #xxx

#define mkstr(xxx) mkstr_2(xxx)
#define concat(a,b) a##b
#define concatenar(a,b) concat(a,b)
#undef xxx

//-- Simbolos predefinidos estandares -------------------------------------

NDEBUG
LINE
FILE
DATE
TIME
STDC
STDC_VERSION
func
cplusplus
// Simbolos predefinidos en GCC
GNUC
GNUC_MINOR
GNUC_PATCHLEVEL
GNUG
STRICT_ANSI
BASE_FILE
INCLUDE_LEVEL
VERSION
OPTIMIZE [-O -O1 -O2 -O3 -Os]
OPTIMIZE_SIZE [-Os]
NO_INLINE
FUNCTION
PRETTY_FUNCTION
//------------------------------------------------------------------- -
linux
unix
MINGW32
WIN32

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

330 APE´ NDICE D. EL PREPROCESADOR

//------------------------------------------------------------------- -

#ifndef STDC
#ifdef cplusplus
#ifndef NDEBUG
#if ! ( defined( GNUC ) \
&& ( ( GNUC >= 4) || (( GNUC == 3)&&( GNUC_MINOR >= 2))) \
&& ( defined linux || defined MINGW32 ))
#error "Debe ser GCC versi´on 3.2 o superior sobre GNU/Linux o MinGW/Windows "
#error "para usar tipos_control"
#elif defined STDC_VERSION && STDC_VERSION >= 199901L
#else
#endif

331
Ap´endice E

Errores M´as Comunes

utilizar = (asignaci´on) en vez de == (igualdad) en comparaciones.

if (x = y) { // error: asignaci´on en vez de comparaci´on
...
}

Utilizaci´on de operadores relacionales.

if (0 <= x <= 99) { // error:

...
}

debe ser:

if ((0 <= x) && (x <= 99)) {

...
}

Olvidar poner la sentencia break; tras las acciones de un case en un switch.

switch (x)
{ case 0:
case 1:
cout << "Caso primero" << endl;
break;
case 2:
cout << "Caso segundo" << endl;
// error: no hemos puesto el break
default:
cout << "Caso por defecto" << endl;
break;
}

debe ser:

switch (x)
{ case 0:
case 1:
cout << "Caso primero" << endl;
break;
case 2:
cout << "Caso segundo" << endl;
break;
default:

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

332 APE´ NDICE E. ERRORES M A´ S COMUNES

cout << "Caso por defecto" << endl;

break;
}

Al alojar agregados din´amicos para contener cadenas de caracteres, no solicitar espacio para
contener el terminador ’\0’
char cadena[] = "Hola Pepe";

char* ptr = new char[strlen(cadena)]; // error. sin espacio para ’\0’

strcpy(ptr, cadena); // error, copia sin espacio

debe ser:

char* ptr = new char[strlen(cadena)+1]; // OK. espacio para ’\0’

strcpy(ptr, cadena);

Al alojar con

tipo* p = new tipo[30];

desalojar con

delete p;

en vez de con

delete [] p;

Overflow en Arrays y en Cadenas de Caracteres (al estilo-C)

333
Ap´endice F

Caracter´ısticas no Contempladas

Paso de par´ametros variable

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

334 APE´ NDICE F. CARACTER´ISTICAS NO CONTEMPLADAS

335
Ap´endice G

Bibliograf´ıa

El Lenguaje de Programaci´on C.
2.Ed. B.Kernighan, D. Ritchie
Prentice Hall 1991

The C++ Programming Language. Special Edition

B. Stroustrup
Addison Wesley 2000

C++ FAQ-Lite
M. Cline http://www.parashift.com/c+
+-faq-lite/

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

´Indice alfab´etico

::, 137 garant´ıas, 311

´ambito de visibilidad, 34 iteradores, 286
A, 9
operaciones, 287
OBS , 9 operaciones asociativas, 288
operaciones de lista, 287
agregado, 62, 63 operaciones de pila y cola, 287
acceso, 64 operaciones sobre iteradores, 288
multidimensional, 68 resumen, 288
predefinido, 87 tipos, 286
acceso, 88 bloque, 33
multidimensional, 92 buffer, 30, 265
size, 64 de entrada, 30
taman˜o, 64 de salida, 30
array, 62, 63
acceso, 64 cadenas de caracteres estilo-C, 98
multidimensional, 68 acceso, 98
predefinido, 87 terminador, 98
acceso, 88 campos de bits, 105
multidimensional, 92 catch, 148
par´ametros, 95 cerr, 27
size, 64 cin, 29
taman˜o, 64 comentarios, 15
compilaci´on separada, 135
bu´squeda constantes
binaria, 78 literales, 20
lineal, 77 simb´olicas, 20
biblioteca declaraci´on, 21
ansic constantes literales, 15
cassert, 321 conversiones aritm´eticas, 23
cctype, 111, 321 conversiones de tipo
cfloat, 323 autom´aticas, 23
climits, 323 expl´ıcitas, 23
cmath, 111, 321 conversiones enteras, 23
cstdarg, 325 cout, 27
cstdio, 324
cstdlib, 112, 322 declaraci´on
cstring, 323 global, 33
ctime, 323 ´ambito de visibilidad, 33
conio.h, 326 local, 33
stl ´ambito de visibilidad, 33
acceso, 287 vs. definici´on, 17
asignaci´on, 288 declaracion adelantada, 198
constructores, 287 definici´on
contenedores, 286 vs. declaraci´on, 17
ficheros, 285 delete, 193, 280

336
´INDICE ALFABE´ TICO 337

delete [], 241 enlaces, 198

delimitadores, 15 excepciones, 207
listas enlazadas, 200
ejecuci´on secuencial, 33 new, 193
enlazado, 135 new T[], 241
entrada, 29
espacios de nombre new, 193, 280
using, 137 new T[], 241
espacios de nombre, 136, 137
::, 137 operador de direcci´on, 218
an´onimos, 136 operadores, 15, 21
using namespace, 137 aritm´eticos, 22
espacios en blanco, 15 bits, 22
estructura, 59 condicional, 22
excepciones, 147 l´ogicos, 22
catch, 148 relacionales, 22 ordenaci
throw, 148 ´on
try, 148 burbuja, 79
inserci´on, 80
fichero de encabezamiento inserci´on binaria, 81
guardas, 134 intercambio, 79
ficheros, 268 selecci´on, 80
ejemplo, 269
entrada, 268 palabras reservadas, 14 par
entrada/salida, 130, 270 ´ametros de entrada, 43 par
salida, 269 ´ametros de entrada/salida, 44
flujos par´ametros de salida, 44
entrada, 263 paso por referencia, 44
cadena, 270 paso por referencia constante, 44
excepci´on, 32, 265 paso por valor, 43
jerarqu´ıa de clases, 271 procedimientos, 41
salida, 263 declaraci´on, 46
cadena, 270 definici´on, 42
funciones, 41 inline, 46
declaraci´on, 46 programa C++, 13
definici´on, 42 promociones, 23
inline, 46 prototipo, 46
return, 43 put, 30
guardas, 134 registro, 59
return, 43 s
identificadores, 15
inline, 46 ´ımbolo
A, 9
listas enlazadas
declaracion adelantada, 198 OBS , 9
salida, 27
m´odulo secuencia de sentencias, 33
implementaci´on, 133 sentencia
interfaz, 133 asignaci´on, 34
main, 13 incremento/decremento, 34
memoria din´amica, 193 iteraci´on, 37
abstraccion, 197 do while, 39
agregados, 241 for, 38
delete, 193 while, 37
delete [], 241 selecci´on, 35

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga

338 ´INDICE ALFABE´ TICO

if, 35
switch, 36

throw, 148
tipo, 17
tipos
cuadro resumen, 19
puntero, 192
a subprogramas, 242
acceso, 194
operaciones, 194
par´ametros, 196
punteroagregado
par´ametros, 241
tipos compuestos, 17, 51
array, 62, 63
acceso, 64
multidimensional, 68
predefinido, 87
size, 64
cadenas estilo-C,
98 campos de bits,
105 par´ametros,
51
struct, 59
uniones, 104
tipos simples, 17
enumerado, 19
escalares, 18
ordinales, 18
predefinidos, 17
bool, 17
char, 17
double, 18
float, 18
int, 18
long, 18
long long, 18
short, 18
unsigned, 18
try, 148

uni´on, 104
using, 137
using namespace, 137

variables
declaraci´on, 21

Dpto. Lenguajes y Ciencias de la Computaci´on Universidad de M´alaga