Page 1
Curso de programació n en C++
EUI (UPV)
Valencia, 17 al 28 de Julio de 1995
Apuntes de clase
Sergio Talens Oliag

Page 2

Page 3
Contenidos
BASES TEÓRICAS. INTRODUCCIÓN A LA POO.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
INTRODUCCIÓN ...............................................................................................................................1
PARADIGMAS DE PROGRAMACIÓN .....................................................................................................1
PROGRAMACIÓN IMPERATIVA ..........................................................................................................2
Tipos de datos .............................................................................................................................2
Operadores y expresiones...............................................................................................................3
Algoritmos y estructuras de control .................................................................................................4
Funciones y procedimientos...........................................................................................................4
Constantes y variables ..................................................................................................................5
PROGRAMACIÓN MODULAR .............................................................................................................6
TIPOS ABSTRACTOS DE DATOS..........................................................................................................6
PROGRAMACIÓN ORIENTADA A OBJETOS ...........................................................................................7
Objetos y mensajes ......................................................................................................................7
Clases........................................................................................................................................7
Herencia y polimorfismo...............................................................................................................7
Programació n con objetos..............................................................................................................7
EL LENGUAJE C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
INTRODUCCIÓN ...............................................................................................................................9
CONCEPTOS BÁSICOS ......................................................................................................................9
Estructura de los programas............................................................................................................9
Tipos de datos y operadores.......................................................................................................... 10
Estructuras de control.................................................................................................................. 11
Funciones................................................................................................................................. 12
Soporte a la programació n modular................................................................................................ 12
Soporte a los Tipos de Datos Abstractos......................................................................................... 13
Soporte a la programació n Orientada a Objetos................................................................................ 13
TIPOS DE DATOS, OPERADORES Y EXPRESIONES................................................................................. 13
Tipos de datos ........................................................................................................................... 13
Tipos elementales ...................................................................................................................... 13
Tipos enumerados ...................................................................................................................... 14
Tipos derivados.......................................................................................................................... 15
Tipos compuestos...................................................................................................................... 16
Constantes (literales) .................................................................................................................. 18
Variables.................................................................................................................................. 19
Conversiones de tipos................................................................................................................. 20
Operadores y expresiones............................................................................................................. 21
ESTRUCTURAS DE CONTROL ........................................................................................................... 24
Estructuras de selecció n............................................................................................................... 24
Estructuras de repetició n.............................................................................................................. 26
Estructuras de salto..................................................................................................................... 27
FUNCIONES.................................................................................................................................. 28
Declaració n de funciones.............................................................................................................. 28
Definició n de funciones............................................................................................................... 28
Paso de parámetros..................................................................................................................... 29
Parámetros array........................................................................................................................ 29
Retorno de valores...................................................................................................................... 30
Sobrecarga de funciones............................................................................................................... 30
Parámetros por defecto................................................................................................................ 30
Parámetros indefinidos................................................................................................................ 31
Recursividad.............................................................................................................................. 32
Punteros a funciones................................................................................................................... 33
La funció n main()...................................................................................................................... 33
VARIABLES DINÁMICAS ................................................................................................................. 34
Punteros y direcciones................................................................................................................. 34
El puntero NULL....................................................................................................................... 35
Punteros void............................................................................................................................ 35
Aritmé tica con punteros .............................................................................................................. 36
Punteros y parámetros de funciones ............................................................................................... 37
iii

Page 4
Punteros y arrays........................................................................................................................37
Operadores new y delete...............................................................................................................38
Punteros y estructuras .................................................................................................................39
Punteros a punteros ....................................................................................................................39
PROGRAMACIÓN EFICIENTE ............................................................................................................40
Estructura de los programas..........................................................................................................40
El preprocesador.........................................................................................................................42
Funciones inline ........................................................................................................................43
Inclusió n de rutinas en ensamblador ...............................................................................................43
Eficiencia y claridad de los programas.............................................................................................44
CLASES........................................................................................................................................44
Introducció n..............................................................................................................................44
Clases y miembros.....................................................................................................................45
Mé todos estáticos y funciones amigas ............................................................................................50
Construcció n y destrucció n...........................................................................................................51
HERENCIA Y POLIMORFISMO...........................................................................................................56
Clases derivadas o subclases .........................................................................................................56
Clases abstractas ........................................................................................................................60
Herencia mú ltiple.......................................................................................................................61
Control de acceso .......................................................................................................................63
Gestió n de memoria....................................................................................................................64
SOBRECARGA DE OPERADORES .......................................................................................................64
Funciones operador.....................................................................................................................64
Conversiones de tipos .................................................................................................................66
Operadores y objetos grandes ........................................................................................................67
Asignació n e inicializació n...........................................................................................................67
Subíndices ................................................................................................................................68
Llamadas a funció n.....................................................................................................................68
Dereferencia...............................................................................................................................69
Incremento y decremento..............................................................................................................69
Sobrecarga de new y delete ...........................................................................................................69
Funciones amigas o mé todos........................................................................................................70
TEMPLATES ..................................................................................................................................70
Genericidad................................................................................................................................70
Funciones gené ricas....................................................................................................................71
Clases gené ricas.........................................................................................................................72
MANEJO DE EXCEPCIONES..............................................................................................................73
Programació n y errores................................................................................................................73
Tratamiento de excepciones en C++ (throw - catch - try)....................................................................73
ENTRADA Y SALIDA .......................................................................................................................76
Introducció n..............................................................................................................................76
Objetos Stream..........................................................................................................................76
Entrada y salida..........................................................................................................................76
Ficheros ...................................................................................................................................79
PROGRAMACIÓN EN C++................................................................................................................80
El proceso de desarrollo ...............................................................................................................80
Mantenibilidad y documentació n....................................................................................................80
Diseño e implementació n.............................................................................................................81
Elecció n de clases.......................................................................................................................81
Interfaces e implementació n..........................................................................................................81
LIBRERÍAS DE CLASES....................................................................................................................81
Diseño de librerías......................................................................................................................82
Clases Contenedor......................................................................................................................82
Clases para aplicaciones...............................................................................................................83
Clases de Interface ......................................................................................................................83
Eficiencia temporal y gestió n de memoria.......................................................................................83
Estandarizació n..........................................................................................................................84
RELACIÓN C/C++..........................................................................................................................84
No se puede usar en ANSI C ........................................................................................................84
Diferencias entre C y C++ ...........................................................................................................85
iv

Page 5
Bibliografía básica
— Brian W. Kernighan, Dennis M. Ritchie, The C Programming Language, Second Edition,
Prentice Hall, 1988
— Bjarne Stroustrup, The C++ Programming Language, Second Edition, Addison-Wesley,
1991
— Enrique Hernández Orallo, José Hernández Orallo, Programació n en C++, Paraninfo, 1993
5

Page 6

Page 7
Bases teóricas. Introducción a la POO.
INTRODUCCIÓN
Para comenzar a estudiar cualquier lenguaje de programació n se debe conocer cuales son los
conceptos que soporta, es decir, el tipo de programació n que vamos a poder realizar con é l.
Como el C++ incorpora características nuevas respecto a lenguajes como Pascal o C, en primer
lugar daremos una descripció n a los conceptos a los que este lenguaje da soporte, repasando los
paradigmas de programació n y centrándonos en la evolució n desde la programació n Funcional a
la programació n Orientada a Objetos. Más adelante estudiaremos el lenguaje de la misma
manera, primero veremos sus características funcionales (realmente la parte que el lenguaje
hereda de C) y despué s estudiaremos las extensiones que dan soporte a la programació n
orientada a objetos (el ++ de C++).
PARADIGMAS DE PROGRAMACIÓN
Segú n los conceptos en que se basa un lenguaje de programació n tenemos distintas maneras de
aproximarnos a la resolució n de los problemas y diferentes estilos de programació n. Podemos
clasificar los lenguajes de programació n en varios tipos:
— Imperativos
— Orientados a Objetos
— Funcionales
— Ló gicos
Las dos primeras opciones se basan en la abstracció n de los tipos de datos. Básicamente se trata
de representar las características variables de los objetos mediante tipos que el ordenador pueda
tratar, como por ejemplo nú meros enteros o caracteres alfanumé ricos. Nuestro programa será
una colecció n de algoritmos que opere sobre los datos que hemos modelado. La diferencia entre
las dos aproximaciones se verá en puntos posteriores.
Los lenguajes funcionales, al contrario que los imperativos, eliminan totalmente la idea de tipo
de datos, se limitan a tratar todos los datos como símbolos y hacen hincapié en las operaciones
que podemos aplicar sobre estos símbolos, agrupados en listas o árboles. Es importante indicar
que en estos lenguajes se emplea ú nicamente el concepto de funció n aplicado a símbolos, siendo
una de sus características principales el empleo de las funciones recursivas. Como ejemplo de
este tipo de lenguajes podríamos citar el LISP.
1