Welcome to Scribd. Sign in or start your free trial to enjoy unlimited e-books, audiobooks & documents.Find out more
Download
Standard view
Full view
of .
Look up keyword or section
Like this
1Activity

Table Of Contents

1: Introducción a los Objetos
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
Figura 1.4: Jerarquía de Figura
Figura 1.5: Especialización de Figura
Figura 1.6: Reescritura de métodos
1.5.1. Relaciones es-un vs. es-como-un
1.6. Objetos intercambiables gracias al polimorfis- mo
1.7. Creación y destrucción de objetos
1.8. Gestión de excepciones: tratamiento de erro- res
1.9. Análisis y diseño
1.9.1. Fase 0: Hacer un plan
1.9.2. Fase 1: ¿Qué estamos haciendo?
1.9.3. Fase 2: ¿Cómo podemos construirlo?
Las cinco etapas del diseño de objetos
Directrices para desarrollo de objetos
1.9.5. Fase 4: Iterar los casos de uso
1.9.7. Los planes valen la pena
1.10. Programación Extrema
2.1.2. Compiladores
2.1.3. El proceso de compilación
Comprobación estática de tipos
2.2. Herramientas para compilación modular
Sintaxis de declaración de funciones
Formato de inclusión del estándar C++
2.2.2. Enlazado
2.2.3. Uso de librerías
Cómo busca el enlazador una librería
2.3. Su primer programa en C++
2.3.1. Uso de las clases iostream
2.3.2. Espacios de nombres
2.3.3. Fundamentos de la estructura de los programa
2.3.4. «Hello, World!»
2.4. Más sobre iostreams
2.4.1. Concatenar vectores de caracteres
2.4.2. Leer de la entrada
2.5. Introdución a las cadenas
2.6. Lectura y escritura de ficheros
2.7. Introducción a los vectores
2.8. Resumen
2.9. Ejercicios
3: C en C++
3.1. Creación de funciones
3.1.1. Valores de retorno de las funciones
3.1.2. Uso de funciones de librerías C
3.1.3. Creación de librerías propias
3.2. Control de flujo
3.2.1. Verdadero y falso
3.2.2. if-else
3.2.3. while
3.2.4. do-while
3.2.6. Las palabras reservadas break y continue
3.2.7. switch
3.2.8. Uso y maluso de goto
3.3. Introducción a los operadores
3.3.2. Auto incremento y decremento
3.4. Introducción a los tipos de datos
3.4.1. Tipos predefinidos básicos
3.4.2. booleano, verdadero y falso
Cuadro 3.1: Expresiones que utilizan booleanos
3.4.4. Introducción a punteros
3.6.4. extern
3.6.5. Constantes
3.6.6. Volatile
3.7. Los operadores y su uso
3.7.1. Asignación
Introducción a las macros del preprocesador
3.7.3. Operadores relacionales
3.7.4. Operadores lógicos
3.7.5. Operadores para bits
3.7.6. Operadores de desplazamiento
3.7.7. Operadores unarios
3.7.9. El operador coma
3.7.10. Trampas habituales cuando se usan operadores
3.7.11. Operadores de moldeado
3.7.12. Los moldes explícitos de C++
3.7.13. sizeof - un operador en si mismo
3.7.14. La palabra reservada asm
3.7.15. Operadores explícitos
Cuadro 3.3: Nuevas palabras reservadas para operadores booleanos
3.8. Creación de tipos compuestos
3.8.1. Creación de alias usando typedef
3.8.2. Usar struct para combinar variables
3.8.3. Programas más claros gracias a enum
3.8.4. Cómo ahorrar memoria con union
3.8.5. Arrays
3.9.1. Banderas para depuración
Banderas de depuración para el preprocesador
Banderas para depuración en tiempo de ejecución
3.9.3. La macro C assert()
3.10. Direcciones de función
3.10.1. Definición de un puntero a función
3.10.2. Declaraciones y definiciones complicadas
3.10.3. Uso de un puntero a función
3.10.4. Arrays de punteros a funciones
3.11. Make: cómo hacer compilación separada
3.11.1. Las actividades de Make
3.11.3. Un ejemplo de Makefile
3.13. Ejercicios
4: Abstracción de Datos
4.1.1. Asignación dinámica de memoria
4.1.2. Malas suposiciones
4.2. ¿Qué tiene de malo?
4.3. El objeto básico
4.5. Tipos abstractos de datos
4.6. Detalles del objeto
4.7. Conveciones para los ficheros de cabecera
4.7.1. Importancia de los ficheros de cabecera
4.7.2. El problema de la declaración múltiple
4.7.3. Las directivas del preprocesador #define, #ifndef y #endif
4.7.4. Un estándar para los ficheros de cabecera
4.7.5. Espacios de nombres en los ficheros de cabecera
4.7.6. Uso de los ficheros de cabecera en proyectos
4.8. Estructuras anidadas
4.8.1. Resolución de ámbito global
4.9. Resumen
4.10. Ejercicios
5: Ocultar la implementación
5.1. Establecer los límites
5.2. Control de acceso en C++
5.2.1. protected
5.3. Amigos (friends)
5.3.1. Amigas anidadas
5.3.2. ¿Es eso puro?
5.4. Capa de objetos
5.5. La clase
5.5.2. Modificar Stack para usar control de acceso
5.6. Manejo de clases
5.6.1. Ocultar la implementación
5.7. Resumen
5.8. Ejercicios
6: Inicialización y limpieza
6.2. Limpieza garantizada por el destructor
6.3. Eliminación del bloque de definiciones
6.3.1. Bucles for
6.3.2. Alojamiento de memoria
6.4. Stash con constructores y destructores
6.6. Inicialización de tipos agregados
6.7. Constructores por defecto
6.8. Resumen
6.9. Ejercicios
7: Sobrecarga de funciones y argu- mentos por defecto
7.1. Más decoración de nombres
7.1.1. Sobrecarga en el valor de retorno
7.1.2. Enlace con FIXME:tipos seguros
7.2. Ejemplo de sobrecarga
7.3. Uniones
7.4. Argumentos por defecto
7.4.1. Argumentos de relleno
7.5. Elección entre sobrecarga y argumentos por defecto
7.6. Resumen
8: Constantes
8.1. Sustitución de valores
8.1.1. const en archivos de cabecera
8.1.2. constantes seguras
8.1.3. Vectores
8.1.4. Diferencias con C
8.2.1. Puntero a constante
8.2.2. Puntero constante
8.2.3. Asignación y comprobación de tipos
8.3.2. Retorno por valor constante
8.3.3. Paso y retorno de direcciones
8.4. Clases
8.4.1. const en las clases
La lista de inicialización del constructor
Constructores para los tipos del lenguaje
8.4.2. Constantes en tiempo de compilación dentro de cla- ses
8.4.3. Objetos y métodos constantes
mutable: constancia binaria vs. lógica
8.5. Volatile
8.6. Resumen
8.7. Ejercicios
9: Funciones inline
9.1. Los peligros del preprocesador
9.1.1. Macros y acceso
9.2. Funciones inline
9.2.1. inline dentro de clases
9.2.2. Funciones de acceso
9.4. Funciones inline y el compilador
9.4.1. Limitaciones
9.4.2. Referencias adelantadas
9.4.3. Actividades ocultas en contructores y destructores
9.5. Reducir el desorden
9.6. Más características del preprocesador
9.7. Comprobación de errores mejorada
9.8. Resumen
9.9. Ejercicios
10: Control de nombres
10.1. Los elementos estáticos de C
10.1.1. Variables estáticas dentro de funciones
Objetos estáticos dentro de funciones
Destructores de objetos estáticos
10.1.2. Control del enlazado
10.1.3. Otros especificadores para almacenamiento de cla- ses
10.2. Espacios de nombres
10.2.1. Crear un espacio de nombres
10.2.2. Cómo usar un espacio de nombres
10.2.3. El uso de los espacios de nombres
10.3. Miembros estáticos en C++
10.3.1. Definición del almacenamiento para atributos está- ticos
Inicialización de vectores estáticos
10.3.2. Clases anidadas y locales
10.3.3. Métodos estáticos
10.4.1. Qué hacer
10.6. Resumen
10.7. Ejercicios
11: Las referencias y el constructor de copia
11.1. Punteros en C++
11.2.1. Referencias en las funciones
11.2.2. Consejos para el paso de argumentos
11.3. El constructor de copia
11.3.1. Paso y retorno por valor
Marco de pila para llamadas a función
11.3.2. Construcción por copia
11.3.3. El constructor de copia por defecto
11.3.4. Alternativas a la construcción por copia
Funciones que modifican objetos externos
11.4. Punteros a miembros
11.4.1. Funciones
11.5. Resumen
11.6. Ejercicios
12: Sobrecarga de operadores
12.1. Precaución y tranquilidad
12.2. Sintaxis
12.3. Operadores sobrecargables
12.3.1. Operadores unarios
12.3.2. Operadores binarios
12.3.3. Argumentos y valores de retorno
12.3.4. Operadores poco usuales
12.3.5. Operadores que no puede sobrecargar
12.4. Operadores no miembros
12.4.1. Directrices básicas
Cuadro 12.1: Directrices para elegir entre miembro y no-miembro
12.5.1. Comportamiento del operador =
12.6. Conversión automática de tipos
12.6.1. Conversión por constructor
Evitar la conversión por constructor
12.6.4. Las trampas de la conversión automática de tipos
12.7. Resumen
12.8. Ejercicios
13: Creación dinámica de objetos
13.1.1. Asignación dinámica en C
13.1.2. El operador new
13.1.3. El operador delete
13.1.4. Un ejemplo sencillo
13.1.5. Trabajo extra para el gestor de memoria
13.2. Rediseño de los ejemplos anteriores
13.2.1. delete void* probablemente es un error
13.2.3. Stash para punteros
13.3. new y delete para vectores
13.3.1. Cómo hacer que un puntero sea más parecido a un vector
13.3.2. Cuando se supera el espacio de almacenamiento
13.3.3. Sobrecarga de los operadores new y delete
Sobrecarga global de new y delete
Sobrecarga de new y delete para vectores
13.4. Resumen
13.5. Ejercicios
14: Herencia y Composición
14.1. Sintaxis de la composición
14.2. Sintaxis de la herencia
14.3. Lista de inicializadores de un constructor
14.3.1. Inicialización de objetos miembros
14.3.2. Tipos predefinidos en la lista de inicializadores
14.3.3. Combinación de composición y herencia
Llamadas automáticas al destructor
14.3.4. Orden de llamada de constructores y destructores
14.4. Ocultación de nombres
14.5. Funciones que no heredan automáticamente
14.5.1. Herencia y métodos estáticos
14.5.2. Composición vs. herencia
14.6. Protected
14.6.1. Herencia protegida
14.7. Herencia y sobrecarga de operadores
14.8. Herencia múltiple
14.9. Desarrollo incremental
14.10. Upcasting
14.10.1. ¿Por qué «upcasting»?
14.10.2. FIXME Upcasting y el constructor de copia
14.10.3. Composición vs. herencia FIXME (revisited)
14.10.4. FIXME Upcasting de punteros y referencias
14.10.5. Una crisis
14.12. Ejercicios
15: Polimorfismo y Funciones vir- tuales
15.1. Evolución de los programadores de C++
15.2. Upcasting
15.3. El problema
15.3.1. Ligadura de las llamadas a funciones
15.4. Funciones virtuales
15.4.1. Extensibilidad
15.5.1. Almacenando información de tipo
15.5.2. Pintar funciones virtuales
15.5.3. Detrás del telón
15.5.4. Instalar el vpointer
15.5.5. Los objetos son diferentes
15.10.4. Destructores virtuales puros
15.10.5. Mecanismo virtual en los destructores
15.10.6. Creación una jerarquía basada en objetos
15.11. Sobrecarga de operadores
15.12. Downcasting
15.13. Resumen
15.14. Ejercicios
16: Introducción a las Plantillas
16.1. Contenedores
16.1.1. La necesidad de los contenedores
16.2. Un vistazo a las plantillas
16.2.1. La solución de la plantilla
Figura 16.3: Contenedor de objetos Figura
16.3. Sintaxis del Template
16.3.2. IntStack como plantilla
16.3.3. Constantes en los Templates
16.4. Stack y Stash como Plantillas
16.4.1. Cola de punteros mediante plantillas
16.5. Activando y desactivando la propiedad
16.6. Manejando objetos por valor
16.7. Introducción a los iteradores
16.7.1. Stack con iteradores
16.7.2. PStash con iteradores
16.8. Por qué usar iteradores
16.8.1. Plantillas Función
16.9. Resumen
A: Estilo de codificación
A.1. General
A.2. Nombres de fichero
A.3. Marcas comentadas de inicio y fin
A.4. Paréntesis, llaves e indentación
A.5. Nombres para identificadores
A.6. Orden de los #includes
A.7. Guardas de inclusión en ficheros de cabecera
A.8. Uso de los espacios de nombres
A.9. Utilización de require() y assure()
B: Directrices de Programación
C: Lecturas recomendadas
C.1. Sobre C
C.2. Sobre C++ en general
C.2.1. Mi propia lista de libros
C.3. Los rincones oscuros
C.4. Sobre Análisis y Diseño
0 of .
Results for:
No results containing your search query
P. 1
Pensar en Cpp-Vol1

Pensar en Cpp-Vol1

Ratings:
(0)
|Views: 1|Likes:

More info:

Published by: Николай Николай on Apr 12, 2014
Copyright:Traditional Copyright: All rights reserved

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/17/2015

pdf

text

original

You're Reading a Free Preview
Pages 12 to 65 are not shown in this preview.
You're Reading a Free Preview
Pages 77 to 119 are not shown in this preview.
You're Reading a Free Preview
Pages 131 to 484 are not shown in this preview.
You're Reading a Free Preview
Pages 502 to 582 are not shown in this preview.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->