Publicado el 22 de Mayo del 2018
635 visualizaciones desde el 22 de Mayo del 2018
4,1 MB
582 paginas
Creado hace 12a (22/07/2011)
i
i
“Volumen1” — 2011/7/22 — 2:27 — page I — #1
i
i
Pensar en C++ (Volumen 1)
Traducción (cuasi-terminada) del libro Thinking in C++, Volumen 1
Bruce Eckel
22 de julio de 2011
Puede encontrar la versión actualizada de este libro e información adicional sobre el proyecto de traducción en
http://arco.esi.uclm.es/~david.villa/pensarC++.html
i
i
i
i
i
i
“Volumen1” — 2011/7/22 — 2:27 — page II — #2
i
i
Pensar en C++ (Volumen 1)
by Bruce Eckel
Copyright © 2000 Bruce Eckel
II
i
i
i
i
i
i
“Volumen1” — 2011/7/22 — 2:27 — page III — #3
i
i
Índice general
1. Introducción a los Objetos
1.9.1.
1.9.2.
1.9.3.
1.5.1. Relaciones es-un vs. es-como-un
1.1. El progreso de abstracción . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2. Cada objeto tiene una interfaz . . . . . . . . . . . . . . . . . . . . . . . .
1.3. La implementación oculta . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4. Reutilizar la implementación . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
1.5. Herencia: reutilización de interfaces
1
1
3
5
6
7
. . . . . . . . . . . . . . . . . 10
1.6. Objetos intercambiables gracias al polimorfismo . . . . . . . . . . . . . 11
1.7. Creación y destrucción de objetos . . . . . . . . . . . . . . . . . . . . . . 15
1.8. Gestión de excepciones: tratamiento de errores . . . . . . . . . . . . . . 16
1.9. Análisis y diseño .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Fase 0: Hacer un plan . . . . . . . . . . . . . . . . . . . . . . . . 18
1.9.1.1. Declaración de objetivos
. . . . . . . . . . . . . . . . . 19
Fase 1: ¿Qué estamos haciendo? . . . . . . . . . . . . . . . . . . 19
Fase 2: ¿Cómo podemos construirlo? . . . . . . . . . . . . . . . 22
1.9.3.1. Las cinco etapas del diseño de objetos
. . . . . . . . . 23
1.9.3.2. Directrices para desarrollo de objetos . . . . . . . . . . 24
1.9.4. Fase 3: Construir el núcleo . . . . . . . . . . . . . . . . . . . . . 25
1.9.5.
Fase 4: Iterar los casos de uso . . . . . . . . . . . . . . . . . . . . 25
1.9.6. Fase 5: Evolución . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.9.7. Los planes valen la pena . . . . . . . . . . . . . . . . . . . . . . . 27
1.10. Programación Extrema . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.10.1. Escriba primero las pruebas . . . . . . . . . . . . . . . . . . . . . 28
1.10.2. Programación en parejas . . . . . . . . . . . . . . . . . . . . . . . 29
1.11. Porqué triunfa C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
. . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.11.1. Un C mejor
. . . . . . . . . . . . . 30
1.11.2. Usted ya está en la curva de aprendizaje
. . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.11.3. Eficiencia .
1.11.4. Los sistemas son más fáciles de expresar y entender . . . . . . . 31
.
. . .
.
. . .
i
i
III
i
i
i
i
Índice general
“Volumen1” — 2011/7/22 — 2:27 — page IV — #4
i
i
.
.
.
1.12.1. Directrices .
1.11.5. Aprovechamiento máximo con librerías . . . . . . . . . . . . . . 31
1.11.6. Reutilización de código fuente con plantillas . . . . . . . . . . . 32
1.11.7. Manejo de errores .
. . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.11.8. Programar a lo grande . . . . . . . . . . . . . . . . . . . . . . . . 32
1.12. Estrategias de transición . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
. . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.12.1.1. Entrenamiento . . . . . . . . . . . . . . . . . . . . . . . 33
1.12.1.2. Proyectos de bajo riesgo . . . . . . . . . . . . . . . . . 33
1.12.1.3. Modelar desde el éxito . . . . . . . . . . . . . . . . . . 33
1.12.1.4. Use librerías de clases existentes . . . . . . . . . . . . . 34
1.12.1.5. No reescriba en C++ código que ya existe . . . . . . . 34
1.12.2. Obstáculos de la gestión . . . . . . . . . . . . . . . . . . . . . . . 34
1.12.2.1. Costes iniciales . . . . . . . . . . . . . . . . . . . . . . . 34
1.12.2.2. Cuestiones de rendimiento . . . . . . . . . . . . . . . . 35
1.12.2.3. Errores comunes de diseño . . . . . . . . . . . . . . . . 35
. . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.13. Resumen .
.
.
.
.
.
.
.
.
2. Construir y usar objetos
.
.
.
.
.
Intérpretes .
Sintaxis de declaración de funciones
2.2. Herramientas para compilación modular
37
2.1. El proceso de traducción del lenguaje . . . . . . . . . . . . . . . . . . . 37
. . . . . . . . . . . . . . . . . . . . . . . . . . 37
.
2.1.1.
2.1.2. Compiladores .
. . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.1.3. El proceso de compilación . . . . . . . . . . . . . . . . . . . . . . 39
2.1.3.1. Comprobación estática de tipos . . . . . . . . . . . . . 40
. . . . . . . . . . . . . . . . . 40
2.2.1. Declaraciones vs definiciones . . . . . . . . . . . . . . . . . . . . 41
2.2.1.1.
. . . . . . . . . . 41
2.2.1.2. Una puntualización . . . . . . . . . . . . . . . . . . . . 42
2.2.1.3. Definición de funciones . . . . . . . . . . . . . . . . . . 42
2.2.1.4.
Sintaxis de declaración de variables . . . . . . . . . . . 42
2.2.1.5.
Incluir ficheros de cabecera . . . . . . . . . . . . . . . . 43
2.2.1.6. Formato de inclusión del estándar C++ . . . . . . . . . 44
. . . . . . . . . . . . . . . . . . . . . . . . . . . 45
. . . . . . . . . . . . . . . . . . . . . . . . . . 45
.
2.2.3.1. Cómo busca el enlazador una librería . . . . . . . . . . 46
2.2.3.2. Añadidos ocultos
. . . . . . . . . . . . . . . . . . . . . 46
2.2.3.3. Uso de librerías C plano . . . . . . . . . . . . . . . . . 47
2.3. Su primer programa en C++ . . . . . . . . . . . . . . . . . . . . . . . . . 47
. . . 47
2.2.2. Enlazado .
.
2.2.3. Uso de librerías .
2.3.1. Uso de las clases iostream . . . . .
. . . . .
. . . . .
. . .
.
.
.
IV
i
i
i
i
i
i
“Volumen1” — 2011/7/22 — 2:27 — page V — #5
i
i
Índice general
2.4. Más sobre iostreams
2.3.2. Espacios de nombres . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.3.3. Fundamentos de la estructura de los programa . . . . . . . . . . 49
2.3.4. «Hello, World!» .
. . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.3.5. Utilizar el compilador . . . . . . . . . . . . . . . . . . . . . . . . 51
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.4.1. Concatenar vectores de caracteres . . . . . . . . . . . . . . . . . 51
2.4.2. Leer de la entrada . .
. . . . . . . . . . . . . . . . . . . . . . . . . 52
2.4.3. Llamar a otros programas . . . . . . . . . . . . . . . . . . . . . . 53
2.5.
. . . . . . . . . . . . . . . . . . . . . . . . . . 53
Introdución a las cadenas
2.6. Lectura y escritura de ficheros . . . . . . . . . . . . . . . . . . . . . . . . 54
2.7.
Introducción a los vectores . . . . . . . . . . . . . . . . . . . . . . . . . . 56
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.8. Resumen .
2.9. Ejercicios .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
. .
. .
.
.
.
.
.
.
.
.
3. C en C++
3.1. Creación de funciones
3.2. Control de flujo .
.
. . .
.
.
.
.
. . . . .
. . . . . . .
. . .
. . .
. . .
. . .
. . . . . .
. . . . .
. . . . . . .
. . . . .
63
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.1.1. Valores de retorno de las funciones . . . . . . . . . . . . . . . . . 65
3.1.2. Uso de funciones de librerías C . . . . . . . . . . . . . . . . . . . 66
3.1.3. Creación de librerías propias . . . . . . . . . . . . . . . . . . . . 66
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
. . . . . . . . . . . . . . . . . . . . . . . . . 67
3.2.1. Verdadero y falso . .
. . . . . . . . . . . . . . . . . . 67
3.2.2. if-else .
. . . . . . . . . . . . . . . . . 68
3.2.3. while .
.
. . . . . . . . . . . . . . . . . 69
3.2.4. do-while . . . .
. . . . . . . . . . . . . . . . . 70
3.2.5. for .
. 70
3.2.6. Las palabras reservadas break y continue . . . . .
. . . . . . . . . . . . . . 72
3.2.7. switch .
3.2.8. Uso y maluso de goto . . . . .
. . . . .
. . . . . . 73
3.2.9. Recursividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Introducción a los operadores . . . . . . . . . . . . . . . . . . . . . . . . 74
3.3.1. Precedencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.3.2. Auto incremento y decremento . . . . . . . . . . . . . . . . . . . 75
Introducción a los tipos de datos . . . . . . . . . . . . . . . . . . . . . . 76
3.4.1. Tipos predefinidos básicos . . . . . . . . . . . . . . . . . . . . . . 76
3.4.2. booleano, verdadero y falso . . . . . . . . . . . . . . . . . . . . . 77
3.4.3. Especificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.4.4.
Introducción a punteros . . . . . . . . . . . . . . . . . . . . . . . 79
3.4.5. Modificar objetos externos . . . . . . . . . . . . . . . . . . . . . . 82
. . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . .
. . .
3.3.
3.4.
i
i
V
i
i
i
i
Índice general
“Volumen1” — 2011/7/22 — 2:27 — page VI — #6
i
i
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3.7.2.1.
3.5. Alcance .
3.6.6. Volatile .
3.6.5. Constantes .
3.7.1. Asignación .
3.7.2. Operadores matemáticos
.
.
.
.
3.6.4.1. Enlazado .
3.6.3. Static .
.
3.6.4. extern .
3.4.6.
Introducción a las referencias de C++ . . . . . . . . . . . . . . . 84
3.4.7. Punteros y Referencias como modificadores . . . . . . . . . . . 85
. . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.5.1. Definición de variables «al vuelo» . . . . . . . . . . . . . . . . . 87
3.6. Especificar la ubicación del espacio de almacenamiento . . . . . . . . . 89
3.6.1. Variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.6.2. Variables locales
. . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.6.2.1. Variables registro . . . . . . . . . . . . . . . . . . . . . 90
. . . . . . . . . . . . . . . . . . . . . . . . . . . 91
. . . . . . . . . . . . . . . . . . . . . . . . . . . 92
. . . . . . . . . . . . . . . . . .
Comentarios de: Pensar en C++ (Volumen 1) (0)
No hay comentarios