Programación Elemental en C++ Manual de Referencia Abreviado

141 Pages·2002·0.45 MB·Spanish

UNIVERSIDADDEMA´LAGA
Dpto.LenguajesyCC.Computaci´on
E.T.S.I.Inform´atica
Ingenier´ıaInforma´tica
Programacio´n Elemental en C++
Manual de Referencia Abreviado
Versi´on 1.0
2
´
Indice general
Pro´logo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1. Un programa C++ 9
2. Tipos simples 11
2.1. Declaraci´on vs. definicio´n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Tipos simples predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3. Tipos simples enumerados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4. Constantes y variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6. Conversiones de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3. Estructuras de control 17
3.1. Sentencia, secuencia y bloque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2. Declaraciones globales y locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3. Sentencias de asignaci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.4. Sentencias de Selecci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.5. Sentencias de Iteraci´on. Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4. Subprogramas. Funciones y procedimientos 23
4.1. Funciones y procedimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2. Definicio´n de subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.3. Para´metros por valor y por referencia . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.4. Subprogramas “en l´ınea”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.5. Declaraci´on de subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5. Entrada / Salida ba´sica 29
5.1. Salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2. Entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6. Tipos compuestos 33
6.1. Registros o estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.2. Agregados o “Arrays” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.3. Agregados multidimensionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.4. Cadenas de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.5. Para´metros de tipos compuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.6. Para´metros de agregados de taman¯o variable . . . . . . . . . . . . . . . . . . . . . 36
6.7. Inicializaci´on de variables de tipo compuesto . . . . . . . . . . . . . . . . . . . . . 37
6.8. Operaciones sobre variables de tipo compuesto . . . . . . . . . . . . . . . . . . . . 37
6.9. Uniones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7. Biblioteca “string” de C++ 39
3
4 ´INDICE GENERAL
8. Memoria din´amica. Punteros 43
8.1. Declaraci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8.2. Desreferenciaci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8.3. Memoria Dina´mica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
8.4. Estructuras autoreferenciadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
8.5. Memoria dina´mica de agregados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
8.6. Paso de para´metros de variables de tipo puntero . . . . . . . . . . . . . . . . . . . 45
8.7. Operaciones sobre variables de tipo puntero . . . . . . . . . . . . . . . . . . . . . . 46
8.8. Operador de indireccio´n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.9. Punteros a subprogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9. Entrada / Salida. Ampliacion, control y ficheros 49
9.1. El “buffer” de entrada y el “buffer” de salida . . . . . . . . . . . . . . . . . . . . . 49
9.2. Los flujos est´andares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
9.3. Control de flujos. Estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
9.4. Entrada/Salida formateada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
9.5. Operaciones de salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.6. Operaciones de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
9.7. Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
9.8. Ficheros de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
9.9. Ficheros de salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
9.10.Ficheros de entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
9.11.Flujo de entrada desde una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
9.12.Flujo de salida a una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9.13.Flujo de entrada desde una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9.14.Flujo de salida a una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
10.M´odulos 59
10.1.Definicio´n e implementaci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
10.2.Espacios de nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11.Manejo de errores. Excepciones 63
12.Sobrecarga de subprogramas y operadores 67
12.1.Sobrecarga de subprogramas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
12.2.Sobrecarga de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
13.Tipos abstractos de datos 71
13.1.M´etodos definidos autom´aticamente por el compilador . . . . . . . . . . . . . . . . 81
13.2.Requisitos de las clases respecto a las excepciones . . . . . . . . . . . . . . . . . . . 81
14.Programaci´on Gen´erica. Plantillas 83
15.Programaci´on orientada a objetos 87
16.Biblioteca Esta´ndar de C++. STL 95
16.1.Contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
16.2.vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
16.3.list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
16.4.deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
16.5.stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
16.6.queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
16.7.priority-queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
16.8.map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
16.9.multimap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
16.10.set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Dpto. LenguajesyCienciasdelaComputaci´on UniversidaddeM´alaga
16.11.multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
16.12.bitset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
16.13.Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
16.14.directos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
16.15.inversos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
16.16.inserters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
16.17.stream iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
16.18.Operaciones sobre Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
16.19.Objetos Funcio´n y Predicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
16.20.Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
16.21.Numericos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
16.22.L´ımites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
16.23.Gesti´on de Memoria Dina´mica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
A. Precedencia de Operadores en C++ 119
B. STL (standard template library) 123
B.1. Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
B.2. Contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
B.3. Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
B.4. Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
B.5. Acceso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
B.6. Operaciones de Pila y Cola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
B.7. Operaciones de Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
B.8. Operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
B.9. Constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
B.10.Asignaci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
B.11.Operaciones Asociativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
B.12.Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
B.13.Operaciones sobre Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
B.14.Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
C. Biblioteca b´asica ANSI-C (+ conio) 131
C.1. cctype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
C.2. cstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
C.3. cstdlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
C.4. cassert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
C.5. cmath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
C.6. ctime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
C.7. climits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
C.8. cfloat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
C.9. conio.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
D.Errores m´as comunes 137
E. Caracter´ısticas no contempladas 139
Bibliograf´ıa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
´Indice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
6 ´INDICE GENERAL
Pr´ologo
Este manual pretende ser una gu´ıa de referencia abreviada para la utilizacio´n del lenguaje
C++ en el desarrollo de programas. Est´a orientada a alumnos de primer curso de programacio´n
de Ingenier´ıa Informa´tica.
No pretende ser una gu´ıa extensa del lenguaje de programaci´on C++. De hecho no considera
ningu´n aspecto del lenguaje enfocado al paradigma de “Programacio´n Orientada a Objetos”.
Adem´as,dadalaamplituddellenguaje,haycaracter´ısticasdelmismoquenohansidocontem-
pladas por exceder lo que entendemos que es un curso de programacio´n elemental.
El lenguaje de programaci´on C++ es un lenguaje muy flexible y vers´atil, y debido a ello, si se
utilizasinrigorpuededarlugaraconstruccionesyestructurasdeprogramacio´ncomplejas,dif´ıciles
de comprender y propensas a errores. Debido a ello, restringiremos tanto las estructuras a utilizar
como la forma de utilizarlas.
Este manual ha sido elaborado en el Dpto. de Lenguajes y Ciencias de la Computaci´on de la
Universidad de M´alaga.
7
8 ´INDICE GENERAL
Cap´ıtulo 1
Un programa C++
En principio, un programa C++ se almacena en un fichero cuya extensi´on ser´a una de las si-
guientes:“.cpp”,“.cxx”,“.cc”,etc.Ma´sadelanteconsideraremosprogramascomplejoscuyoc´odigo
se encuentra distribuido entre varios ficheros (cap. 10).
Dentro de este fichero, normalmente, aparecer´an al principio unas l´ıneas para incluir las defi-
niciones de los m´odulos de biblioteca que utilice nuestro programa. Posteriormente, se realizar´an
declaraciones y definiciones de tipos, de constantes (vease cap´ıtulo 2) y de subprogramas (cap. 4)
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 funcio´n principal, llamada main,
que indica donde comienza la ejecuci´on del programa. Al finalizar, dicha funcio´n devolver´a un
nu´mero entero que indica al Sistema Operativo el estado de terminaci´on tr´as 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 recibira´ por
defecto un valor indicando terminaci´on normal.
Ejemplo de un programa que imprime los nu´meros menores que uno dado por teclado.
//- fichero: numeros.cpp --------------------------------------------
#include <iostream> // biblioteca de entrada/salida
/*
* Imprime los numeros menores a ’n’
*/
void
numeros(int n)
{
for (int i = 0; i < n; ++i) {
cout << i << " "; // escribe el valor de ’i’
}
cout << endl; // escribe ’salto de linea’
}
int
main()
{
int maximo;
cout << "Introduce un numero: ";
cin >> maximo;
numeros(maximo);
// return 0;
9
10 CAP´ITULO 1. UN PROGRAMA C++
}
//- fin: numeros.cpp ------------------------------------------------
En un programa C++ podemos distinguir los siguientes elementos b´asicos:
Palabras reservadas
Son un conjunto de palabras que tienen un significado predeterminado para el compilador, y
s´olo pueden ser utilizadas con dicho sentido.
Identificadores
Son nombres elegidos por el programador para representar entidades (tipos, constantes, va-
riables, funciones, etc) en el programa.
Se construyen mediante una secuencia de letras y d´ıgitos de cualquier longitud, siendo el
primer car´acter una letra. El _ 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.
Constantes literales
Son valores que aparecen expl´ıcitamente en el programa, y podr´an ser num´ericos, caracteres
y cadenas.
Operadores
S´ımbolos con significado propio segu´n el contexto en el que se utilicen.
Delimitadores
S´ımbolos que indican comienzo o fin de una entidad.
Comentarios y espacios en blanco
Los comentarios en C++ se expresan de dos formas diferentes:
Para comentarios cortos en l´ınea con el c´odigo de programa utilizaremos // que
indica comentario hasta el final de la l´ınea.
media = suma / n; // media de ’n’ numeros
Para comentarios largos (de varias lineas) utilizaremos /* que indica comentario
hasta */
/*
* Ordena por el metodo quicksort
* Recibe el array y el numero de elementos que contine
* Devuelve el array ordenado
*/
Los espacios en blanco, tabuladores, nueva l´ınea, retorno de carro, avance de pa´gina y los
comentarios son ignorados, excepto en el sentido en que separan componentes.
Nota: en C++, las letras minu´sculas se consideran diferentes de las mayu´sculas.