Pensar en C++ (Volumen 1)

Traducción (INACABADA) del libro Thinking in C++, Volumen 1

Bruce Eckel

Mindview, Inc.


Tabla de contenidos

Prólogo a la traducción
1. Licencia y normas de distribución
2. El proyecto de traducción
3. Tecnicismos
4. Código fuente
5. Producción
5.1. Código fuente
5.2. Esquemas y diagramas
5.3. Generación de productos
6. El equipo
7. Agradecimientos
Prefacio
1. Material nuevo en la segunda edición
1.1. ¿Qué contiene el volumen 2 de este libro?
1.2. Cómo obtener el volumen 2
2. Requisitos
3. Aprender C++
4. Objetivos
5. Capítulos
6. Ejercicios
6.1. Soluciones a los ejercicios
7. Código fuente
8. Estándares del lenguaje
8.1. Soporte del lenguaje
9. El CD-ROM del libro
10. CD-ROMs, seminarios, y consultoría
11. Errores
12. Sobre la portada
13. Diseño del libro y producción
14. Agradecimientos
1. Introducción a los Objetos
1. El progreso de abstracción
2. Cada objeto tiene una interfaz
3. La implementación oculta
4. Reutilizar la implementación
5. Herencia: reutilización de interfaces
5.1. Relaciones es-un vs. es-como-un
6. Objetos intercambiables gracias al polimorfismo
7. Creación y destrucción de objetos
8. Gestión de excepciones: tratamiento de errores
9. Análisis y diseño
9.1. Fase 0: Hacer un plan
9.2. Fase 1: ¿Qué estamos haciendo?
9.3. Fase 2: ¿Cómo podemos construirlo?
9.4. Fase 3: Construir el núcleo
9.5. Fase 4: Iterar los casos de uso
9.6. Fase 5: Evolución
9.7. Los planes valen la pena
10. Programación Extrema
10.1. Escriba primero las pruebas
10.2. Programación en parejas
11. Porqué triunfa C++
11.1. Un C mejor
11.2. Usted ya está en la curva de aprendizaje
11.3. Eficiencia
11.4. Los sistemas son más fáciles de expresar y entender
11.5. Aprovechamiento máximo con librerías
11.6. Reutilización de código fuente con plantillas
11.7. Manejo de errores
11.8. Programar a lo grande
12. Estrategias de transición
12.1. Directrices
12.2. Obstáculos de la gestión
13. Resumen
2. Construir y usar objetos
1. El proceso de traducción del lenguaje
1.1. Intérpretes
1.2. Compiladores
1.3. El proceso de compilación
2. Herramientas para compilación modular
2.1. Declaraciones vs definiciones
2.2. Enlazado
2.3. Uso de librerías
3. Su primer programa en C++
3.1. Uso de las clases iostream
3.2. Espacios de nombres
3.3. Fundamentos de la estructura de los programa
3.4. Hello, World!
3.5. Utilizar el compilador
4. Más sobre iostreams
4.1. Concatenar vectores de caracteres
4.2. Leer de la entrada
4.3. Llamar a otros programas
5. Introdución a las cadenas
6. Lectura y escritura de ficheros
7. Introducción a los vectores
8. Resumen
9. Ejercicios
3. C en C++
1. Creación de funciones
1.1. Valores de retorno de las funciones
1.2. Uso de funciones de librerías C
1.3. Creación de librerías propias
2. Control de flujo
2.1. Verdadero y falso
2.2. if-else
2.3. while
2.4. do-while
2.5. for
2.6. Las palabras reservadas break y continue
2.7. switch
2.8. Uso y maluso de goto
2.9. Recursividad
3. Introducción a los operadores
3.1. Precedencia
3.2. Auto incremento y decremento
4. Introducción a los tipos de datos
4.1. Tipos predefinidos básicos
4.2. booleano, verdadero y falso
4.3. Especificadores
4.4. Introducción a punteros
4.5. Modificar objetos externos
4.6. Introducción a las referencias de C++
4.7. Punteros y Referencias como modificadores
5. Alcance
5.1. Definición de variables al vuelo
6. Especificar la ubicación del espacio de almacenamiento
6.1. Variables globales
6.2. Variables locales
6.3. Static
6.4. extern
6.5. Constantes
6.6. Volatile
7. Los operadores y su uso
7.1. Asignación
7.2. Operadores matemáticos
7.3. Operadores relacionales
7.4. Operadores lógicos
7.5. Operadores para bits
7.6. Operadores de desplazamiento
7.7. Operadores unarios
7.8. El operador ternario
7.9. El operador coma
7.10. Trampas habituales cuando se usan operadores
7.11. Operadores de moldeado
7.12. Los moldes explícitos de C++
7.13. sizeof - un operador en si mismo
7.14. La palabra reservada asm
7.15. Operadores explícitos
8. Creación de tipos compuestos
8.1. Creación de alias usando typedef
8.2. Usar struct para combinar variables
8.3. Programas más claros gracias a enum
8.4. Cómo ahorrar memoria con union
8.5. Arrays
9. Consejos para depuración
9.1. Banderas para depuración
9.2. Convertir variables y expresiones en cadenas
9.3. La macro C assert()
10. Direcciones de función
10.1. Definición de un puntero a función
10.2. Declaraciones y definiciones complicadas
10.3. Uso de un puntero a función
10.4. Arrays de punteros a funciones
11. Make: cómo hacer compilación separada
11.1. Las actividades de Make
11.2. Los Makefiles de este libro
11.3. Un ejemplo de Makefile
12. Resumen
13. Ejercicios
4. Abstracción de Datos
1. Una librería pequeña al estilo C
1.1. Asignación dinámica de memoria
1.2. Malas suposiciones
2. ¿Qué tiene de malo?
3. El objeto básico
4. ¿Qué es un objeto?
5. Tipos abstractos de datos
6. Detalles del objeto
7. Conveciones para los ficheros de cabecera
7.1. Importancia de los ficheros de cabecera
7.2. El problema de la declaración múltiple
7.3. Las directivas del preprocesador #define, #ifndef y #endif
7.4. Un estándar para los ficheros de cabecera
7.5. Espacios de nombres en los ficheros de cabecera
7.6. Uso de los ficheros de cabecera en proyectos
8. Estructuras anidadas
8.1. Resolución de ámbito global
9. Resumen
10. Ejercicios
5. Ocultar la implementación
1. Establecer los límites
2. Control de acceso en C++
2.1. protected
3. Amigos (friends)
3.1. Amigas anidadas
3.2. ¿Es eso puro?
4. Capa de objetos
5. La clase
5.1. Modificaciones en Stash para usar control de acceso
5.2. Modificar Stack para usar control de acceso
6. Manejo de clases
6.1. Ocultar la implementación
6.2. Reducir la recompilación
7. Resumen
8. Ejercicios
6. Inicialización y limpieza
1. Inicialización garantizada por el constructor
2. Limpieza garantizada por el destructor
3. Eliminación del bloque de definiciones
3.1. Bucles for
3.2. Alojamiento de memoria
4. Stash con constructores y destructores
5. Stack con constructores y destructores
6. Inicialización de tipos agregados
7. Constructores por defecto
8. Resumen
9. Ejercicios
7. Sobrecarga de funciones y argumentos por defecto
1. Más decoración de nombres
1.1. Sobrecarga en el valor de retorno
1.2. Enlace con FIXME:tipos seguros
2. Ejemplo de sobrecarga
3. Uniones
4. Argumentos por defecto
4.1. Argumentos de relleno
5. Elección entre sobrecarga y argumentos por defecto
6. Resumen
7. Ejercicios
8. Constantes
1. Sustitución de valores
1.1. const en archivos de cabecera
1.2. constantes seguras
1.3. Vectores
1.4. Diferencias con C
2. Punteros
2.1. Puntero a constante
2.2. Puntero constante
2.3. Asignación y comprobación de tipos
3. Argumentos de funciones y valores de retorno
3.1. Paso por valor constante
3.2. Retorno por valor constante
3.3. Paso y retorno de direcciones
4. Clases
4.1. const en las clases
4.2. Constantes en tiempo de compilación dentro de clases
4.3. Objetos y métodos constantes
5. Volatile
6. Resumen
7. Ejercicios
9. Funciones inline
1. Los peligros del preprocesador
1.1. Macros y acceso
2. Funciones inline
2.1. inline dentro de clases
2.2. Funciones de acceso
3. Stash y Stack con inlines
4. Funciones inline y el compilador
4.1. Limitaciones
4.2. Referencias adelantadas
4.3. Actividades ocultas en contructores y destructores
5. Reducir el desorden
6. Más características del preprocesador
6.1. Encolado de símbolos
7. Comprobación de errores mejorada
8. Resumen
9. Ejercicios
10. Control de nombres
1. Los elementos estáticos de C
1.1. Variables estáticas dentro de funciones
1.2. Control del enlazado
1.3. Otros especificadores para almacenamiento de clases
2. Espacios de nombres
2.1. Crear un espacio de nombres
2.2. Cómo usar un espacio de nombres
2.3. El uso de los espacios de nombres
3. Miembros estáticos en C++
3.1. Definición del almacenamiento para miembros de datos estáticos
3.2. Clases anidadas y locales
3.3. Métodos estáticos
4. FIXME static initialization dependency
4.1. Qué hacer
5. Especificaciones de enlazado alternativo
6. Resumen
7. Ejercicios
11. Las referencias y el constructor de copia
1. Punteros en C++
2. Referencias en C++
2.1. Referencias en las funciones
2.2. Consejos para el paso de argumentos
3. El constructor de copia
3.1. Paso y retorno por valor
3.2. Construcción por copia
3.3. Constructor copia por defecto
3.4. Alternativas a la construcción por copia
4. Punteros a miembros
4.1. Funciones
5. Resumen
6. Ejercicios
12. Sobrecarga de operadores
1. Precaución y tranquilidad
2. Sintaxis
3. Operadores sobrecargables
3.1. Operadores unarios
3.2. Operadores binarios
3.3. Argumentos y valores de retorno
3.4. Operadores poco usuales
3.5. Operadores que no puede sobrecargar
4. Operadores no miembros
4.1. Directrices básicas
5. Sobrecargar la asignación
5.1. Comportamiento del operador =
6. Conversión automática de tipos
6.1. Conversión por constructor
6.2. Conversión por operador
6.3. Ejemplo de conversión de tipos
6.4. Las trampas de la conversión automática de tipos
7. Resumen
8. Ejercicios
13. Creación dinámica de objetos
1. Creación de objetos
1.1. Asignación dinámica en C
1.2. Operador new
1.3. Operador delete
1.4. Un ejemplo sencillo
1.5. Trabajo extra para el gestor de memoria
2. Rediseño de los ejemplos anteriores
2.1. delete void* probablemente es un error
2.2. Responsabilidad de la limpieza cuando se usan punteros
2.3. Stash para punteros
3. new y delete para vectores
3.1. Cómo hacer que un puntero sea más parecido a un vector
3.2. Cuando se supera el espacio de almacenamiento
3.3. Sobrecarga de los operadores new y delete
4. Resumen
5. Ejercicios
14. Herencia y Composición
1. Sintaxis de la composición
2. Sintaxis de la herencia
3. Lista de inicializadores de un constructor
3.1. Inicialización de objetos miembros
3.2. Tipos predefinidos en la lista de inicializadores
3.3. Combinación de composición y herencia
3.4. Orden de llamada de constructores y destructores
4. Ocultación de nombres
5. Funciones que no heredan automáticamente
5.1. Herencia y métodos estáticos
5.2. Composición vs. herencia
6. Protected
6.1. Herencia protegida
7. Herencia y sobrecarga de operadores
8. Herencia múltiple
9. Desarrollo incremental
10. FIXME Upcasting
10.1. ¿Por qué FIXME "upcasting"?
10.2. FIXME Upcasting y el constructor de copia
10.3. Composición vs. herencia FIXME (revisited)
10.4. FIXME Upcasting de punteros y referencias
10.5. Una crisis
11. Resumen
12. Ejercicios
15. Polimorfismo y Funciones virtuales
1. Evolución de los programadores de C++
2. Upcasting
3. El problema
3.1. Ligadura de las llamadas a funciones
4. Funciones virtuales
4.1. Extensibilidad
5. Cómo implementa C++ la ligadura dinámica
5.1. Almacenando información de tipo
5.2. Pintar funciones virtuales
5.3. Detrás del telón
5.4. Instalar el vpointer
5.5. Los objetos son diferentes
6. ¿Por qué funciones virtuales?
7. Clases base abstractas y funciones virtuales puras
7.1. Definiciones virtuales puras
8. Herencia y la VTABLE
8.1. FIXME: Object slicing
9. Sobrecargar y redefinir
9.1. Tipo de retorno variante
10. funciones virtuales y constructores
10.1. Orden de las llamadas a los constructores
10.2. Comportamiento de las funciones virtuales dentro de los constructores
10.3. Destructores y destructores virtuales
10.4. Destructores virtuales puros
10.5. Mecanismo virtual en los destructores
10.6. Creación una jerarquía basada en objetos
11. Sobrecarga de operadores
12. Downcasting
13. Resumen
14. Ejercicios
16. Introducción a las Plantillas
1. Contenedores
1.1. La necesidad de los contenedores
2. Un vistazo a las plantillas
2.1. La solución de la plantilla
3. Sintaxis del Template
3.1. Definiciones de función no inline
3.2. IntStack como plantilla
3.3. Constantes en los Templates
4. Stack y Stash como Plantillas
4.1. Cola de punteros mediante plantillas
5. Activando y desactivando la propiedad
6. Manejando objetos por valor
7. Introducción a los iteradores
7.1. Stack con iteradores
7.2. PStash con iteradores
8. Por qué usar iteradores
8.1. Plantillas Función
9. Resumen
10. Ejercicios
A. Estilo de codificación
1. General
2. Nombres de fichero
3. Marcas comentadas de inicio y fin
4. Paréntesis, llaves e indentación
5. Nombres para identificadores
6. Orden de los #includes
7. Guardas de inclusión en ficheros de cabecera
8. Uso de los espacios de nombres
9. Utilización de require() y assure()
B. Directrices de Programación
C. Lecturas recomendadas
1. Sobre C
2. Sobre C++ en general
2.1. Mi propia lista de libros
3. Los rincones oscuros
4. Sobre Análisis y Diseño

Lista de tablas

3.1. Expresiones que utilizan booleanos
3.2. Moldes explícitos de C++
3.3. Nuevas palabras reservadas para operadores booleanos
12.1. Directrices para elegir entre miembro y no-miembro