EL GRAN LIBRO DE PROGRAMACIÓN EN C++

Prólogo

INTRODUCCION

Pedagogía, ambición, recursos y temario

0.1. ¿Por qué este libro es diferente?
0.2. La pedagogía competencial
0.3. La pedagogía multidisciplinar
0.4. La pedagogía inclusiva
0.5. La pedagogía competencial, multidisciplinar e inclusiva
0.6. Cultura del esfuerzo
0.7. Un libro ambicioso
0.7.1. Descripción breve
0.8. Capítulo 1. Construyendo la programación orientada a objetos
0.8.1. Conceptos tratados
0.8.2. Proyectos prácticos
0.9. Capítulo 2. Tipos de variables, operadores sobrecargados y ámbitos
0.9.1. Descripción breve
0.9.2. Conceptos tratados
0.9.3. Proyectos prácticos
0.10. Capítulo 3. Variables de tipo texto
0.10.1. Descripción breve
0.10.2. Conceptos tratados
0.10.3. Proyectos prácticos y/o ejemplos
0.11. Capítulo 4. Tipos de datos numéricos, coma flotante y binarios
0.11.1. Descripción breve
0.11.2. Conceptos tratados
0.11.3. Proyectos prácticos
0.12. Capítulo 5. Struct, unions y typedefs
0.12.1. Descripción breve
0.12.2. Conceptos tratados
0.12.3. Proyectos prácticos
0.13. Capítulo 6. Diseño de una librería para gráficos
0.13.1. Descripción breve
0.13.2. Conceptos tratados
0.13.3. Proyectos prácticos
0.14. Capítulo 7. Templates (plantillas)
0.14.1. Descripción breve
0.14.2. Conceptos tratados
0.14.3. Proyectos prácticos
0.15. Capítulo 8. Factories combinadas con smart pointers y optionals
0.15.1. Descripción breve
0.15.2. Conceptos tratados
0.15.3. Proyectos prácticos
0.16. Capítulo 9. Threads y funciones lambda
0.16.1. Descripción breve
0.16.2. Conceptos tratados
0.16.3. Proyectos prácticos
0.17. Capítulo 10. Sockets y librería ASIO de Boost
0.17.1. Descripción breve
0.17.2. Conceptos tratados
0.17.3. Proyectos prácticos
0.18. Capítulo 11. Sockets avanzados entre clientes y servidores
0.18.1. Descripción breve
0.18.2. Conceptos tratados
0.18.3. Proyectos prácticos
0.19. Capítulo 12. Árboles de índices AVL equilibrados
0.19.1. Descripción breve
0.19.2. Conceptos tratados
0.19.3. Proyectos prácticos

CAPÍTULO 1

Construyendo la programación orientada a objetos

1.1. Introducción
1.2. Cómo se puede hacer un lenguaje C mejorado
1.2.1. Finalidad: hacer crecer ordenadamente las aplicaciones
1.2.2. Imaginemos una clínica pediátrica
1.3. Cuando el lenguaje C se colapsa
1.3.1. Evitar variables globales peligrosas
1.3.2. Abstracción: un ejemplo en el mundo de la aviación
1.3.3. Herencia (o derivación)
1.3.4. Polimorfismo
1.3.4.1. El polimorfismo ayuda a modelizar objetos reales
1.3.5. Creación dinámica. Ejemplo de una pantalla de radar
1.3.6. Objetos compuestos de otros objetos
1.3.7. Posibilidad de crear arquitecturas de objetos
1.4. Arquitecturas frecuentes, bibliotecas y taxonomías
1.4.1. Metodología de análisis
1.4.2. Taxonomía
1.4.3. Modelo de negocio (o de actividad)
1.4.4. Modelo secuencial de producción o de logística
1.4.5. Otros puntos de vista comunes
1.5. Encapsulación, herencia, polimorfismo
1.5.1. Una segunda aproximación a estas propiedades
1.5.2. La encapsulación partiendo desde C puro
1.5.2.1. ¿Qué datos debemos manejar dentro de un struct?
1.5.2.2. Nomenclatura común en OOP
1.5.2.3. ¿Structs que contienen funciones? ¿Es legal en C?
1.5.2.4. Los punteros a funciones nos vuelven a salvar la vida
1.5.3. Constructores y destructores
1.5.3.1. El constructor por defecto
1.5.3.2. El constructor personalizado
1.5.3.3. El constructor-copia
1.5.3.4. ¿Qué camino seguía Stroustrup?
1.5.3.5. La estrategia del transcompilador
1.5.3.6. Nombres decorados (mangling) para funciones homónimas
1.5.3.7. Cómo ver los nombres decorados de una compilación
1.5.3.8. Usando constructores dinámicamente
1.5.3.9. La asignación de valor de los punteros
1.5.3.10. El código fuente teórico en C++
1.5.3.11. El código fuente proto-C++ en C
1.6. Los operadores new y delete
1.7. El fichero de la protoclase CModelo
1.8. El fichero de la protoclase base CPersona
1.9. El fichero de la protoclase derivada CDoctor
1.9.1. La estrategia de los contadores de uso de objetos
1.9.2. Un segundo ejemplo: los smart pointers
1.9.3. Un tercer ejemplo: los garbage collectors
1.10. La acción conjunta de new + constructor
1.11. El constructor de CDoctor como clase derivada
1.12. El polimorfismo de CDoctor con la función ImprimirFicha
1.12.1. La función ImprimirFicha de CPersona
1.12.2. La función ImprimirFicha desde el lado de CDoctor
1.12.3. Entendiendo qué es virtual override
1.13. El programa principal de demostración
1.14. Conclusiones


CAPÍTULO 2

Tipos de variables, operadores flexibles y ámbitos

2.1. Introducción: de Simula a C++
2.2. Creación dinámica de tipos primitivos
2.3. Objetos
2.4. Operadores
2.4.1. ¿Cómo se redefinen los operadores?
2.4.1.1. Primera fase: reutilizando operadores existentes
2.4.1.2. Fase 2: creando un nuevo operador
2.4.1.3. Fase 3: creando operadores para clases nuevas
2.4.2. Caracteres admitidos como operadores
2.5. Ámbitos
2.5.1. Ámbitos sin nombre
2.5.1.1. ¿Podemos usar las variables del ámbito main desde el ámbito interior?
2.5.1.2. Acceso desde cualquier ámbito al ámbito global
2.5.1.3. Acceso desde fuera hacia dentro de un ámbito
2.5.1.4. Ámbitos con nombre (namespaces)
2.5.2. Uso directo de ámbitos con nombre

CAPÍTULO 3

Variables de tipo de texto

3.1. Variables de tipo texto
3.1.1. Imprimiendo: ¿cómo imprimir un wstring con cout?
3.1.2. La clase string
3.1.2.1. Conversión de string a char y viceversa
3.1.3. La clase wstring
3.1.4. Variables de texto más allá de wstring (súper wide string)
3.1.4.1. Prefijos para especificar cada formato de texto
3.1.5. Funciones implementadas en las clases string
3.1.5.1. Correspondencia de funciones de barrido C K&R y C++
3.1.5.2. Criterios de funcionalidad
3.1.5.3. Ejemplos de constructores y destructores
3.1.5.4. Ejemplo de iteradores
3.1.5.5. Ejemplo de gestión del tamaño en memoria
3.1.5.6. Ejemplo de acceso a los elementos
3.1.5.7. Ejemplo de modificadores
3.1.5.8. Ejemplo de operaciones
3.1.5.9. Ejemplo de sobrecargas de funciones de no miembros de la clase
3.1.5.10. Ejemplo de funciones externas de conversión entre tipos
3.2. El tokenizador de Boost
3.2.1. Instalación de Boost
3.2.2. ¿Qué es un tokenizador?
3.2.3. Los separadores
3.2.4. Los templates como contenedores
3.2.5. El tipo de dato o clase auto

CAPÍTULO 4

Tipos de datos numéricos. Coma flotante y binarios

4.1. Los tipos básicos numéricos
4.1.1. Enteros, punteros a enteros y copias de enteros
4.1.1.1. Límites de cálculo de los enteros normales (int)
4.1.1.2. El tipo numérico entero sin signo
4.1.1.3. Anécdota: un regulador de velocidad, ¿con signo o sin signo?
4.1.2. Modificadores
4.1.2.1. El modificador unsigned
4.1.2.2. El modificador const
4.1.2.3. El modificador constexpr
4.1.2.4. El modificador static
4.1.3. El tipo float y los números decimales
4.1.3.1. Coma fija y coma flotante
4.1.3.2. Estructura de una coma flotante en memoria
4.1.4. El tipo double o doble precisión
4.1.5. El tipo long double o cuádruple precisión
4.1.6. Anécdota histórica: fallo en el cálculo de coma flotante del Pentium de Intel
4.1.7. Tipos numéricos de máscara binaria: BYTE, WORD y DWORD
4.1.7.1. El sistema binario de numeración
4.1.7.2. Conversiones a hexadecimal
4.1.7.3. Álgebra de Bool para números binarios
4.1.8. La operación NOT
4.1.9. La operación OR
4.1.10. La operación NOR
4.1.11. La operación AND
4.1.12. La operación NAND
4.1.13. La operación XOR
4.1.14. Aplicación de puertas XOR y AND para un semisumador de 1 bit
4.1.14.1. La operación de desplazamiento SHL (multiplicación por 2)
4.1.14.2. La operación de desplazamiento SHR (división por 2)
4.1.15. Transformación de puertas OR en puertas AND y viceversa
4.1.16. Llega el transistor para sustituir a la válvula
4.1.17. Comparativa funcional entre válvulas y transistores
4.1.17.1. Puerta NOR construida con transistores
4.1.17.2. Puerta AND construida con transistores
4.2. La tecnología TTL y su historia
4.2.1. La tecnología TTL como estrategia ganadora
4.2.2. La base de la tecnología TTL
4.2.2.1. Las escalas de integración TTL
4.2.2.2. Las series 74 y 54
4.2.3. Volviendo a las máscaras de bits
4.2.4. Orden Endian de los bytes: el pequeño indio y el gran indio
4.2.4.1. Endianidad en el procesador
4.2.5. Cómo dividir un WORD en byte alto y byte bajo
4.2.6. La resta, el signo y el complemento a 1
4.2.6.1. Investigando cómo se hace la resta
4.2.7. El complemento a 1
4.2.8. Operadores de máscara de bits en C
4.2.9. Función en C para hallar el complemento a 1
4.2.9.1. El programa de resta binaria con máscaras binarias en lenguaje C
4.2.10. La directiva asm y las máscaras binarias
4.2.10.1. La arquitectura escalada de Intel y su influencia en los sistemas operativos
4.2.10.2. Nota: el OS/2 y el OS/2 Warp (1991-1992)
4.2.10.3. Memoria y multitarea mejoradas

CAPÍTULO 5

Structs, unions y typedefs

5.1. Introducción
5.1.1. Ejemplo básico de un struct en C++ y en C
5.2. Crear un struct de longitud fija
5.2.1. Ejemplo de creación de un nuevo tipo de dato con typedef struct
5.2.2. Ejemplo de ordenación de una matriz de clientes
5.2.2.1. Función de liberación de cadenas de texto
5.2.2.2. Función de impresión de listado
5.2.2.3. El cuerpo de programa principal
5.2.3. Ejemplo de struct y union: un emulador de dos procesadores a la vez
5.2.3.1. ¡Que vuelven los indios!
5.2.3.2. La instrucción MOV en ensamblador
5.2.3.3. Codificando MOV en lenguaje máquina
5.2.3.4. Simulando un MOV paso a paso
5.2.3.5. ¿Qué hemos conseguido?
5.2.3.6. El programa de prueba de structs y unions
5.2.3.7. El papel de structs, unions y typedefs en la programación del siglo XXI
5.2.3.8. Del sistema operativo a la virtualización y la nube (cloud computing)
5.2.4. El struct como base para crear las clases en C++

CAPÍTULO 6

Diseño de una librería de clases para gráficos

6.1. Qué vamos a aprender en este capítulo
6.2. Cómo vamos a aprenderlo
6.3. Dónde se encuentra el código fuente
6.4. La librería gráfica
6.5. Una clase CPunto para representar un punto
6.5.1. El declarador class
6.5.2. La cláusula public
6.5.3. Variables miembro
6.5.4. Constructores
6.5.4.1. Características de una declaración de constructor
6.5.4.2. El constructor por defecto o default constructor
6.5.4.3. Constructores personalizados
6.5.4.4. El constructor copia
6.5.4.5. El puntero this
6.5.4.6. El constructor virtual no existe
6.5.5. Destructores
6.5.5.1. Sintaxis del destructor
6.5.5.2. Destructores virtuales
6.5.5.3. Inline o no inline
6.5.6. Construcción estática y construcción dinámica
6.5.7. Operadores y sobrecarga de operadores
6.6. Arquitectura de la librería de objetos gráficos
6.7. La clase CLinea
6.7.1. La cláusula private
6.7.2. Getters y setters
6.7.3. Un constructor polar
6.8. La clase CPoligono
6.8.1. Características de CPoligono
6.8.1.1. Dibuja polígonos cerrados
6.8.1.2. Usa un template como contenedor dinámico de puntos
6.8.1.3. Limita y cuenta los puntos del polígono
6.8.1.4. Construcción del objeto por varias vías posibles
6.8.1.5. Control de excepciones propias de la librería
6.8.1.6. Código fuente de la clase CExceptionObjetoGrafico
6.8.1.7. El pintado que lanza las excepciones desde bajo nivel
6.8.1.8. Estilos de lápiz seleccionables
6.8.1.9. Destructor virtual que elimina el lápiz automáticamente
6.8.1.10. Factory del rectángulo mínimo que contiene la figura
6.8.2. El código fuente de la clase CPoligono
6.8.3. Resto de las clases gráficas

CAPÍTULO 7

Templates (plantillas)

7.1. Un template para almacenar elementos gráficos
7.2. La carga de los datos geométricos en el template
7.3. La función de pintado y control de excepciones
7.4. El template de ejemplo CColeccionGrafica
7.4.1. Declaración de una variable template
7.4.2. Declaración de una clase template nueva
7.4.3. Constructores y destructores de la colección
7.4.4. Operador de indexación de la colección
7.4.5. ¿Dónde se declara y dónde se crea el templatecolección?
7.4.6. Cómo queda finalmente la función de dibujo OnDraw
7.5. Estrategias de detección y corrección de problemas de memoria dinámica
7.6. El polimorfismo de la función Dibujar
7.7. Estrategia de detección de memory leakings
7.8. En el próximo capítulo

CAPÍTULO 8

Factories combinadas con smart pointers y optionals (C++17)

8.1. Ejemplo: desayunando en Dunkin? Donuts
8.1.1. Descargar el código fuente
8.1.2. ¿Qué queremos conseguir?
8.1.3. El programa principal, ¿cómo quedará?
8.1.4. Arquitectura del sistema de producción
8.1.4.1. La CoffeeFactory
8.1.4.2. La TeaFactory
8.1.4.3. La ChocolateFactory
8.1.4.4. La RefresherFactory
8.1.5. Las machines o máquinas de producción
8.1.6. La clase ContextDB
8.1.6.1. La plantilla o template map
8.1.6.2. Cómo se codifican las variantes de bebidas
8.1.6.3. La codificación con MakeMask y optional de C++17
8.1.6.4. El código fuente con el que se realiza la máscara de producto
8.1.7. Pasos para construir la factoría más sencilla
8.1.7.1. La función factoría
8.1.7.2. La factory como struct o como clase
8.1.7.3. Declarar las clases hijas
8.1.7.4. Crear e interponer una nueva clase DrinkFactory
8.1.7.5. Crear las machines
8.1.7.6. La palabra clave __parent
8.1.8. Posibilidades futuras de desarrollo para el siguiente capítulo
8.1.8.1. Integración con el hardware (Arduino)
8.1.8.2. Drivers y ciberseguridad
8.1.8.3. Cola de mensajes
8.1.8.4. Threads y sockets TCP/IP
8.2. Pinceladas a posteriori sobre los smart pointers
8.2.1. Historia
8.2.2. Para qué sirven los smart pointers
8.2.3. La controversia de los smart pointers
8.3. Tipos de smart pointers
8.3.1. Scoped_ptr
8.3.2. Scoped_array
8.3.3. Unique_ptr
8.3.4. Shared_ptr

CAPÍTULO 9

Threads (hilos) y funciones lambda

9.1. Introducción a los threads
9.1.1. POSIX y librería estándar de C++
9.1.1.1. Una tarea puede lanzar varios hilos
9.1.2. Ejemplos con threads de POSIX
9.1.3. Threads y argumentos
9.1.4. Identificación de threads
9.1.4.1. Bucles de construcción y de destrucción de threads
9.1.4.2. Cambios en la función incrementa()
9.1.5. El mecanismo de sincronización mediante alternancia
9.1.6. Realizar cálculos en paralelo con threads
9.1.6.1. Los requisitos del ejemplo del barista de café
9.1.6.2. Doce ecuaciones y 12 incógnitas mediante Cramer
9.1.6.3. Aquí es donde entran en juego los threads
9.1.6.4. Dimensiones de la aritmética
9.1.6.5. Datos de entorno de sistema operativo y build de la aplicación
9.1.6.6. Rendimiento de la aplicación
9.1.6.7. Texto de salida de la aplicación
9.1.7. Código fuente comentado del Cramer multithread
9.1.7.1. El bucle de espera
9.1.7.2. Imprimir los resultados del sistema de ecuaciones
9.1.8. Dentro de la clase CCramer
9.1.9. Conclusión
9.1.10. Futuros y promesas
9.1.10.1. Paso 1: declarar la función miembro estática del thread
9.1.10.2. Paso 2: implementar la función en Cramer.cpp
9.1.10.3. Paso 3: modificar la función de ResolverSistema
9.1.11. Timeout de un thread: controlando tiempos de exceso
9.1.12. Funciones Lambda con timeouts
9.1.12.1. ¿Qué es una función lambda?
9.2. Conclusión

CAPÍTULO 10

Sockets y librería ASIO (Boost)

10.1. Introducción
10.2. ASIO
10.2.1. ¿Qué es una cola?
10.2.1.1. Colas LIFO y FIFO
10.2.2. Problemas típicos con colas
10.2.2.1. Problema con colas LIFO
10.2.2.2. Problemas con colas FIFO
10.2.3. Colas con io_service
10.2.4. ¿Qué es una corrutina?
10.2.4.1. El símil de la tienda de alimentación
10.2.4.2. Diferencias entre post y dispatch
10.3. Los pools de threads asíncronos con ASIO
10.3.1. Mutex como precaución de concurrencia
10.3.1.1. Formas de aplicar un mutex
10.3.2. Código fuente del programa
10.3.3. ¿Run o mejor work?
10.3.3.1. ¿Cómo se declara un worker thread?
10.4. Los sockets
10.4.1. Introducción
10.4.2. Breve historia de los sockets
10.4.3. La implementación de sockets de Boost
10.4.4. Relación cliente/servidor
10.4.5. Implementar un cliente y un servidor básicos
10.4.5.1. El cliente de sockets
10.4.5.2. Establecer hacia dónde nos vamos a conectar

¿Busca un método que le haga disfrutar mientras aprende a programar? Descubra un enfoque totalmente renovado de la enseñanza en programación que deja atrás las pedagogías áridas y enfocadas únicamente en la teoría. Este libro apuesta por aprender a dominar el lenguaje de programación en C++ a través de un método ambicioso y diferente: la pedagogía competencial, multidisciplinar e inclusiva. Desde el primer día, le invita a crear su propio programa y a experimentar de primera mano con las bases fundamentales de la informática, guiándole hacia la práctica real antes de sumergirse en los conceptos más abstractos. Con recursos en vídeo para que pueda detenerse y revisar cada detalle a su ritmo, y con código fuente descargable para experimentar, jugar y aprender de los errores, este método hace que la programación sea una experiencia cercana y motivadora. Además, aboga por una visión donde la diversidad de perspectivas en el aula, incluyendo la de personas con autismo, enriquece el proceso de aprendizaje y el resultado de los proyectos. Esta obra va mucho más allá de la simple teoría: le ofrece un recorrido amplio, potente y profundo para adquirir competencias sólidas, desarrolladas paso a paso y respaldadas por la práctica. Desde la mecánica de un sencillo programa hasta los niveles más avanzados de la programación orientada a objetos, este libro rompe las barreras que separan la teoría de la acción. No espere más para adentrarse en este ambicioso libro que le invitará a formar parte de una nueva forma de entender y enseñar la informática. Si desea consolidar sus conocimientos básicos acerca del lenguaje de programación C, no se pierda El gran libro de programación en C, la primera obra del experto en programación Alfons González Pérez, donde descubrirá todo lo que necesita para dominar este potente lenguaje.