Pensar en C++ (Volumen 1)

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