C++
Si necesitas aprender C++, ¡no busques más! Esta completa guía tiene todo lo que necesitas para dominar el lenguaje moderno C++23, desde los fundamentos de la sintaxis hasta conceptos avanzados de desarrollo. Sigue ejemplos prácticos de código mientras aprendes programación orientada a objetos, trabajas con contenedores de bibliotecas estándar, programas aplicaciones concurrentes y mucho más. No te limites a aprender a programar: aprende a programar mejor con consejos de expertos y orientación sobre las reglas del código compacto, seguro y eficiente.
- Tu guía completa sobre el C++ moderno
- Trabaja con el lenguaje C++, desde la sintaxis y las funciones básicas hasta características más avanzadas, como punteros y macros.
- Aprenda a utilizar la biblioteca estándar y los contenedores.
Aprenderás sobre:
- Programación básica a avanzada:
Domina la programación en C++ desde cero. Aprende a programar con elementos básicos como comentarios, variables y funciones, y luego adéntrate en la programación orientada a objetos. Pasa a conceptos avanzados, como punteros y plantillas.
- La biblioteca estándar:
Sumérgete en la biblioteca estándar de C++, incluida una guía detallada sobre contenedores: qué pueden hacer, qué no pueden hacer y cómo elegir el más adecuado para tu caso. Trabaja con flujos y archivos, explora una sintaxis única e implementa la concurrencia mediante subprocesos.
- Buenas prácticas de programación:
Escribe código eficaz y sostenible. Los capítulos dedicados a este tema proporcionan directrices, técnicas y consejos para una buena codificación. Pon la teoría en práctica con numerosos programas de ejemplo que puedes descargar para ayudarte a poner en marcha tus propios proyectos.
Aspectos Destacados:
- Conceptos básicos del lenguaje
- Declaraciones y expresiones
- Estructuras y clases
- Programación orientada a objetos
- Contenedores
- Roscado
- Manejo de errores
- Pruebas
- Punteros
- Interfaz con C
- Plantillas
- Mejores prácticas
Ver Tabla de Contenidos Completa
- Prefacio
- PARTE I Fundamentos
- 1 C++: La guía completa
- 1.1 Nuevo y moderno
- 1.2 Capítulos de «Dan»
- 1.3 Presentación en este libro
- 1.4 Formato utilizado
- 1.5 Hablemos de jerga
- 2 Programación en C++
- 2.1 Compilación
- 2.2 Fases de la traducción
- 2.3 Compiladores actuales
- 2.3.1 Gnu C++
- 2.3.2 Clang++ de LLVM
- 2.3.3 Microsoft Visual C++
- 2.3.4 Compilador en el contenedor
- 2.4 Entornos de desarrollo
- 2.5 La línea de comandos en Ubuntu
- 2.5.1 Crear un programa
- 2.5.2 Automatizar con Makefile
- 2.6 El IDE Visual Studio Code en Windows
- 2.7 Acelerar el programa de muestra
- 3 C++ para principiantes
- 4 Los componentes básicos de C++
- 4.1 Resumen rápido
- 4.1.1 Comentarios
- 4.1.2 La directiva «include»
- 4.1.3 La biblioteca estándar
- 4.1.4 La función «main()»
- 4.1.5 Tipos
- 4.1.6 Variables
- 4.1.7 Inicialización
- 4.1.8 Salida en la consola
- 4.1.9 Declaraciones
- 4.2 Una guía detallada
- 4.2.1 Espacios, identificadores y tokens
- 4.2.2 Comentarios
- 4.2.3 Funciones y argumentos
- 4.2.4 Operadores de efectos secundarios
- 4.2.5 La función «main»
- 4.2.6 Declaraciones
- 4.2.7 Expresiones
- 4.2.8 Asignaciones
- 4.2.9 Tipos
- 4.2.10 Variables: declaración, definición e inicialización
- 4.2.11 Inicializar con «auto»
- 4.2.12 Detalles sobre la directiva Include
- 4.2.13 Módulos
- 4.2.14 Entrada y salida
- 4.2.15 El espacio de nombres «std»
- 4.3 Operadores
- 4.3.1 Operadores y operandos
- 4.3.2 Descripción general de los operadores
- 4.3.3 Operadores aritméticos
- 4.3.4 Aritmética bit a bit
- 4.3.5 Asignación compuesta
- 4.3.6 Incremento y decremento posterior y anterior
- 4.3.7 Operadores relacionales
- 4.3.8 Operadores lógicos
- 4.3.9 Operadores de puntero y desreferenciación
- 4.3.10 Operadores especiales
- 4.3.11 Operadores similares a funciones
- 4.3.12 Secuencia del operador
- 4.4 Tipos de datos integrados
- 4.4.1 Resumen general
- 4.4.2 Inicializar tipos de datos integrados
- 4.4.3 Números enteros
- 4.4.4 Números de punto flotante
- 4.4.5 Valores de verdad
- 4.4.6 Tipos de caracteres
- 4.4.7 Números complejos
- 4.5 Comportamiento indefinido
- 5 Código bueno, 1.º Dan: escribir código legible
- 5.1 Comentarios
- 5.2 Documentación
- 5.3 Sangrados y longitud de línea
- 5.4 Líneas por función y archivo
- 5.5 Paréntesis y espacios
- 5.6 Nombres
- 6 Tipos de datos superiores
- 6.1 El tipo de cadena «string»
- 6.1.1 Inicialización
- 6.1.2 Funciones y métodos
- 6.1.3 Otros tipos de cadenas
- 6.1.4 Solo para visualización: «string_view»
- 6.2 Corrientes
- 6.2.1 Operadores de entrada y salida
- 6.2.2 «getline»
- 6.2.3 Archivos para entrada y salida
- 6.2.4 Manipuladores
- 6.2.5 El manipulador «endl»
- 6.3 Contenedor y puntero
- 6.3.1 Contenedor
- 6.3.2 Tipos parametrizados
- 6.4 Los contenedores de secuencia simple
- 6.4.1 «matriz»
- 6.4.2 «vector»
- 6.5 Algoritmos
- 6.6 Punteros y matrices C
- 6.6.1 Tipos de punteros
- 6.6.2 Matrices C
- 7 funciones
- 7.1 Declaración y definición de una función
- 7.2 Tipo de función
- 7.3 Uso de funciones
- 7.4 Definición de una función
- 7.5 Más información sobre los parámetros
- 7.5.1 Llamada por valor
- 7.5.2 Llamada por referencia
- 7.5.3 Referencias constantes
- 7.5.4 ¿Llamada como valor, referencia o referencia constante?
- 7.6 Cuerpo funcional
- 7.7 Conversión de parámetros
- 7.8 Sobrecarga de funciones
- 7.9 Parámetro predeterminado
- 7.10 Número arbitrario de argumentos
- 7.11 Notación alternativa para la declaración de funciones
- 7.12 Especialidades
- 7.12.1 «noexcept»
- 7.12.2 Funciones en línea
- 7.12.3 «constexpr»
- 7.12.4 Funciones eliminadas
- 7.12.5 Especialidades en métodos de clase
- 8 Declaraciones detalladas
- 8.1 El bloque de instrucciones
- 8.1.1 Bloques independientes y ámbito de las variables
- 8.2 La declaración vacía
- 8.3 Declaración
- 8.3.1 Enlace estructurado
- 8.4 La instrucción Expression
- 8.5 La instrucción «if»
- 8.5.1 «if» con inicializador
- 8.5.2 «if» en tiempo de compilación
- 8.6 El bucle «while»
- 8.7 El bucle «do-while»
- 8.8 El bucle «for»
- 8.9 El bucle «for» basado en un rango
- 8.10 La instrucción «switch»
- 8.11 La instrucción «break»
- 8.12 La instrucción «continuar»
- 8.13 La instrucción «return»
- 8.14 La instrucción «goto»
- 8.15 El bloque «try-catch» y «throw»
- 8.16 Resumen
- 9 expresiones en detalle
- 9.1 Cálculos y efectos secundarios
- 9.2 Tipos de expresiones
- 9.3 Literales
- 9.4 Identificadores
- 9.5 Paréntesis
- 9.6 Llamada a funciones y acceso a índices
- 9.7 Cesión
- 9.8 Tipo de casting
- 10 Manejo de errores
- 10.1 Manejo de errores con códigos de error
- 10.2 ¿Qué es una excepción?
- 10.2.1 Lanzamiento y manejo de excepciones
- 10.2.2 Desenrollar la pila de llamadas
- 10.3 Manejo de errores menores
- 10.4 Volver a lanzar la excepción: «rethrow»
- 10.5 El orden en «captura»
- 10.5.1 No «definitivamente»
- 10.5.2 Excepciones de la biblioteca estándar
- 10.6 Tipos para excepciones
- 10.7 Cuando una excepción sale de «main»
- 11 Buen código, 2.º Dan: modularización
- 11.1 Programa, biblioteca, archivo de objetos
- 11.2 Módulos
- 11.3 Funcionalidades separadas
- 11.4 Un ejemplo de proyecto modular
- 11.4.1 Espacios de nombres
- 11.4.2 Implementación
- 11.4.3 Uso de la biblioteca
- PARTE II Programación orientada a objetos y más
- 12 De la estructura a la clase
- 12.1 Inicialización
- 12.2 Devolución de tipos personalizados
- 12.3 Métodos en lugar de funciones
- 12.4 La mejor «impresión»
- 12.5 Una salida como cualquier otra
- 12.6 Definición de métodos en línea
- 12.7 Implementación y definición separadas
- 12.8 Inicialización mediante el constructor
- 12.8.1 Valores predeterminados de los miembros en la declaración
- 12.8.2 Delegación del constructor
- 12.8.3 Valores predeterminados para los parámetros del constructor
- 12.8.4 No llame al método «init» en el constructor.
- 12.8.5 Excepciones en el constructor
- 12.9 ¿Estructura o clase?
- 12.9.1 Encapsulación
- 12.9.2 «público» y «privado», estructura y clase
- 12.9.3 Datos con «struct», comportamiento con «class»
- 12.9.4 Inicialización de tipos con datos privados
- 12.10 Resumen provisional
- 12.11 Uso de tipos de datos personalizados
- 12.11.1 Uso de clases como valores
- 12.11.2 Uso de constructores
- 12.11.3 Conversiones de tipos
- 12.11.4 Encapsular y descapsular
- 12.11.5 Asignar un nombre local a los tipos
- 12.12 Inferencia de tipos con «auto»
- 12.13 Clases personalizadas en contenedores estándar
- 12.13.1 Comparación triple: el operador de la nave espacial
- 13 Espacios de nombres y calificadores
- 13.1 El espacio de nombres «std»
- 13.2 Espacio de nombres anónimo
- 13.3 «static» hace que sea local
- 13.4 «Estático» Le gusta compartir
- 13.5 Inicialización remota o campos de datos «estáticos en línea»
- 13.6 Inicialización garantizada en tiempo de compilación con «constinit»
- 13.7 «Estático» lo hace permanente
- 13.8 «Espacio de nombres en línea»
- 13.9 Resumen provisional
- 13.10 «const»
- 13.10.1 Parámetros Const
- 13.10.2 Métodos Const
- 13.10.3 Variables «const»
- 13.10.4 Retornos Const
- 13.10.5 «const» junto con «static»
- 13.10.6 Aún más constante con «constexpr»
- 13.10.7 «if constexpr» para decisiones en tiempo de compilación
- 13.10.8 C++20: «consteval»
- 13.10.9 «si consteval»
- 13.10.10 No «const» con «mutable»
- 13.10.11 Corrección de Const
- 13.10.12 Resumen
- 13.11 Volátil con «volátil»
- 14 Código Correcto, 3.º Dan: Pruebas
- 14.1 Tipos de pruebas
- 14.1.1 Reestructuración
- 14.1.2 Pruebas unitarias
- 14.1.3 Social o solitario
- 14.1.4 Doppelgangers
- 14.1.5 Suites
- 14.2 Marcos
- 14.2.1 Organizar, actuar, afirmar
- 14.2.2 Marcos entre los que elegir
- 14.3 Prueba de impulso.
- 14.4 Macros auxiliares para aserciones
- 14.5 Un ejemplo de proyecto con pruebas unitarias
- 14.5.1 Pruebas privadas y públicas
- 14.5.2 Un módulo de prueba automático
- 14.5.3 Prueba de compilación
- 14.5.4 Ensamble usted mismo el conjunto de pruebas
- 14.5.5 Prueba de miembros privados
- 14.5.6 Pruebas parametrizadas
- 15 Herencia
- 15.1 Relaciones
- 15.1.1 Composición «tiene»
- 15.1.2 Agregación «tiene»
- 15.1.3 Herencia «es un»
- 15.1.4 Relación de instancia frente a relación de tipo
- 15.2 Herencia en C++
- 15.3 «Tiene un» frente a «Es un»
- 15.4 Encontrar puntos en común
- 15.5 Tipos derivados Extender
- 15.6 Métodos de anulación
- 15.7 Cómo funcionan los métodos
- 15.8 Métodos virtuales
- 15.9 Constructores en jerarquías de clases
- 15.10 Conversión de tipos en jerarquías de clases
- 15.10.1 Conversión ascendente de la jerarquía de herencia
- 15.10.2 Conversión descendente de la jerarquía de herencia
- 15.10.3 Las referencias también conservan la información sobre el tipo
- 15.11 ¿Cuándo utilizar Virtual?
- 15.12 Otros diseños para la extensibilidad
- 16 El ciclo de vida de las clases
- 16.1 Creación y destrucción
- 16.2 Temporal: valores efímeros
- 16.3 Del destructor al constructor
- 16.3.1 No se necesita destructor
- 16.3.2 Recursos en el destructor
- 16.4 Condición Yoda
- 16.5 Construcción, destrucción y excepciones
- 16.6 Copia
- 16.7 Operador de asignación
- 16.8 Métodos de eliminación
- 16.9 Operaciones de traslado
- 16.9.1 Lo que genera el compilador
- 16.10 Operadores
- 16.11 Operadores personalizados en un tipo de datos
- 16.12 Formularios para clases especiales
- 16.12.1 Clases y métodos abstractos
- 16.12.2 Clases de enumeración
- 17 Buen código, 4.º dan: seguridad, calidad y sostenibilidad
- 17.1 La regla del cero
- 17.1.1 Los cinco grandes
- 17.1.2 Construcción auxiliar por prohibición
- 17.1.3 La regla del cero y su aplicación
- 17.1.4 Excepciones a la regla del cero
- 17.1.5 Regla del cero, regla del tres, regla del cinco, regla del cuatro y medio
- 17.2 La adquisición de recursos es la inicialización
- 17.2.1 Un ejemplo con C
- 17.2.2 Poseer punteros sin formato
- 17.2.3 De C a C++
- 17.2.4 No siempre tiene que ser una excepción
- 17.2.5 Constructores múltiples
- 17.2.6 Inicialización multifásica
- 17.2.7 Definir dónde se necesita
- 17.2.8 «Nuevo» sin excepciones
- 18 ofertas especiales para clases
- 18.1 Se permite ver todo: clases «amigo»
- 18.1.1 Ejemplo de «clase amiga»
- 18.2 Herencia no pública
- 18.2.1 Impacto en el mundo exterior
- 18.2.2 La herencia no pública en la práctica
- 18.3 Clases de firma como interfaces
- 18.4 Herencia múltiple
- 18.4.1 La herencia múltiple en la práctica
- 18.4.2 Precaución con las conversiones de tipos de puntero
- 18.4.3 El patrón observador como ejemplo práctico
- 18.5 Herencia múltiple en forma de diamante: «virtual» para jerarquías de clases
- 18.6 Tipos de datos literales: «constexpr» para constructores
- 19 Código bueno, 5.º dan: diseño orientado a objetos clásico
- 19.1 Objetos en C++
- 19.2 Diseño orientado a objetos
- 19.2.1 SÓLIDO
- 19.2.2 No seas ESTÚPIDO
- PARTE III Temas avanzados
- 20 consejos
- 20.1 Direcciones
- 20.2 Puntero
- 20.3 Peligros del aliasing
- 20.4 Memoria de pila y memoria de pila
- 20.4.1 La pila
- 20.4.2 El montón
- 20.5 Punteros inteligentes
- 20.5.1 «unique_ptr»
- 20.5.2 «shared_ptr»
- 20.6 Punteros sin formato
- 20.7 Matrices C
- 20.7.1 Cálculos con punteros
- 20.7.2 Descomposición de matrices C
- 20.7.3 Matrices C dinámicas
- 20.7.4 Literales de cadena
- 20.8 Iteradores
- 20.9 Punteros como iteradores
- 20.10 Punteros en contenedores
- 20.11 La excepción: cuando no es necesario realizar una limpieza
- 21 macros
- 21.1 El preprocesador
- 21.2 Cuidado con los paréntesis que faltan
- 21.3 Macros de funciones
- 21.4 Información sobre el código fuente
- 21.5 Advertencia sobre ejecuciones múltiples
- 21.6 Variabilidad de tipos de macros
- 21.7 Resumen
- 22 Interfaz con C
- 22.1 Trabajar con bibliotecas
- 22.2 Encabezado C
- 22.3 Recursos C
- 22.4 Punteros «nulos»
- 22.5 Lectura de datos
- 22.6 El programa principal
- 22.7 Resumen
- 23 plantillas
- 23.1 Plantillas de funciones
- 23.1.1 Sobrecarga
- 23.1.2 Un tipo como parámetro
- 23.1.3 Cuerpo de una plantilla de función
- 23.1.4 Valores como parámetros de plantilla
- 23.1.5 Muchas funciones
- 23.1.6 Parámetros con extras
- 23.1.7 Las plantillas de método son simplemente plantillas de función
- 23.2 Plantillas de funciones en la biblioteca estándar
- 23.2.1 Rangos en lugar de contenedores como parámetros de plantilla
- 23.2.2 Ejemplo: Información sobre números
- 23.3 Una clase como función
- 23.3.1 Valores para un parámetro «Función»
- 23.3.2 Puntero a función C
- 23.3.3 La función algo diferente
- 23.3.4 Functores prácticos
- 23.3.5 Algoritmos con funtores
- 23.3.6 Funciones anónimas: también conocidas como expresiones lambda.
- 23.3.7 Funciones de plantilla sin «template», pero con «auto»
- 23.4 Conceptos de C++
- 23.4.1 Cómo leer conceptos
- 23.4.2 Cómo utilizar los conceptos
- 23.4.3 Cómo redactar conceptos
- 23.4.4 Restricciones semánticas
- 23.4.5 Resumen provisional
- 23.5 Clases de plantilla
- 23.5.1 Implementación de plantillas de clase
- 23.5.2 Implementación de métodos de plantillas de clase
- 23.5.3 Creación de objetos a partir de plantillas de clase
- 23.5.4 Plantillas de clase con múltiples tipos de datos formales
- 23.5.5 Plantillas de clase con parámetros no de tipo
- 23.5.6 Plantillas de clase con valores predeterminados
- 23.5.7 Plantillas de clases especializadas
- 23.6 Plantillas con número variable de argumentos
- 23.6.1 Operador «sizeof ...»
- 23.6.2 Convertir paquete de parámetros a tupla
- 23.7 Literales personalizados
- 23.7.1 ¿Qué son los literales?
- 23.7.2 Reglas para nombrar
- 23.7.3 Fases del procesamiento literal
- 23.7.4 Variantes de sobrecarga
- 23.7.5 Literal definido por el usuario utilizando una plantilla
- 23.7.6 Crudo o cocido
- 23.7.7 Fusionado automáticamente
- 23.7.8 Literales Unicode
- PARTE IV La biblioteca estándar
- 24 contenedores
- 24.1 Conceptos básicos
- 24.1.1 Recurrente
- 24.1.2 Resumen
- 24.1.3 Operaciones
- 24.1.4 Complejidad
- 24.1.5 Contenedores y sus iteradores
- 24.1.6 Rangos Simplificar iteradores
- 24.1.7 Rangos, vistas, conceptos, adaptadores, generadores y algoritmos
- 24.1.8 Algoritmos
- 24.2 Conceptos básicos sobre iteradores
- 24.2.1 Iteradores de contenedores
- 24.2.2 Más funcionalidad con iteradores
- 24.3 Asignadores: problemas de memoria
- 24.4 Características comunes de los contenedores
- 24.5 Descripción general de las clases de contenedores estándar
- 24.5.1 Alias de tipos de contenedores
- 24.6 Las clases de contenedores secuenciales
- 24.6.1 Similitudes y diferencias
- 24.6.2 Métodos de los contenedores de secuencias
- 24.6.3 «vector»
- 24.6.4 «matriz»
- 24.6.5 «deque»
- 24.6.6 «lista»
- 24.6.7 «forward_list»
- 24.7 Asociativo y ordenado
- 24.7.1 Similitudes y diferencias
- 24.7.2 Métodos de contenedores asociativos ordenados
- 24.7.3 «establecer»
- 24.7.4 «mapa»
- 24.7.5 «multiconjunto»
- 24.7.6 «multimapa»
- 24.8 Solo asociativo y sin garantía
- 24.8.1 Tablas hash
- 24.8.2 Similitudes y diferencias
- 24.8.3 Métodos de contenedores asociativos no ordenados
- 24.8.4 «unordered_set»
- 24.8.5 «unordered_map»
- 24.8.6 «unordered_multiset»
- 24.8.7 «unordered_multimap»
- 24.9 Adaptadores de contenedores
- 24.10 Casos especiales: «string», «basic_string» y «vector<char>»
- 24.11 Casos especiales: «vector<bool>», «array<bool,n>» y «bitset<n>»
- 24.11.1 Dinámico y compacto: «vector<bool>»
- 24.11.2 Estático: «array<bool,n>» y «bitset<n>»
- 24.12 Caso especial: matriz de valores con «valarray<>»
- 24.12.1 Propiedades de los elementos
- 24.12.2 Inicializar
- 24.12.3 Cesión
- 24.12.4 Insertar y eliminar
- 24.12.5 Acceso
- 24.12.6 Especialidad: Manipular todos los datos
- 24.12.7 Especialidad: Corte y enmascaramiento
- 25 Soporte para contenedores
- 25.1 Algoritmos
- 25.2 Iteradores y rangos
- 25.3 Adaptador iterador
- 25.4 Algoritmos de la biblioteca estándar
- 25.5 Ejecución paralela
- 25.6 Listas de funciones de algoritmos y adaptadores de rango
- 25.6.1 Adaptadores de rango y vistas
- 25.6.2 Rangos como parámetros (y más)
- 25.6.3 Lista de algoritmos no modificadores
- 25.6.4 Algoritmos de modificación inherente
- 25.6.5 Algoritmos para particiones
- 25.6.6 Algoritmos para ordenar y realizar búsquedas rápidas en rangos ordenados
- 25.6.7 Algoritmos de conjuntos representados por un rango ordenado
- 25.6.8 Algoritmos de pila
- 25.6.9 Mínimo y máximo
- 25.6.10 Varios algoritmos
- 25.7 Algoritmos de vinculación de elementos a partir de «<numérico>» y «<rangos>»
- 25.8 Copia en lugar de asignación: valores en áreas de memoria no inicializadas
- 25.9 Algoritmos personalizados
- 25.10 Creación de vistas personalizadas y adaptadores de rango
- 26 Buen código, 6.º dan: el contenedor adecuado para cada tarea
- 26.1 Todos los contenedores ordenados por aspectos
- 26.1.1 ¿Cuándo un «vector» no es la mejor opción?
- 26.1.2 Siempre ordenados: «set», «map», «multiset» y «multimap»
- 26.1.3 En memoria de forma contigua: «vector», «matriz»
- 26.1.4 Inserción barata: «lista»
- 26.1.5 Baja sobrecarga de memoria: «vector», «matriz»
- 26.1.6 Dinámica de tamaño: todos excepto «matriz»
- 26.2 Recetas para contenedores
- 26.2.1 ¿Dos fases? «vector» como un buen sustituto de «conjunto»
- 26.2.2. Salida del contenido de un contenedor a un flujo
- 26.2.3 Por lo tanto, «array» no es tan estático.
- 26.3 Implementación de algoritmos especializados en función del contenedor
- 27 Flujos, archivos y formato
- 27.1 Concepto de entrada y salida con flujos
- 27.2 Flujos estándar globales predefinidos
- 27.2.1 Operadores de flujo << y >>
- 27.3 Métodos para la entrada y salida de flujos
- 27.3.1 Métodos para salida sin formato
- 27.3.2 Métodos para entradas sin formato
- 27.4 Manejo de errores y estados de flujo
- 27.4.1 Métodos para manejar errores de flujo
- 27.5 Manipulación y formato de flujos
- 27.5.1 Manipuladores
- 27.5.2 Creación de manipuladores personalizados sin argumentos
- 27.5.3 Creación de manipuladores personalizados con argumentos
- 27.5.4 Cambiar directamente los indicadores de formato
- 27.6 Flujos para la entrada y salida de archivos
- 27.6.1 Los flujos «ifstream», «ofstream» y «fstream»
- 27.6.2 Conexión a un archivo
- 27.6.3 Lectura y escritura
- 27.6.4 Acceso aleatorio
- 27.6.5 Flujos sincronizados para subprocesos
- 27.7 Flujos para cadenas
- 27.7.1 Diferencia con respecto a «to_string»
- 27.7.2 «to_chars» y «format» son más flexibles que «to_string»
- 27.7.3 Lectura desde una cadena
- 27.8 Búferes de flujo
- 27.8.1 Acceso al búfer de flujo de los objetos «iostream»
- 27.8.2 «filebuf»
- 27.8.3 «stringbuf»
- 27.9 «sistema de archivos»
- 27.10 Formato
- 27.10.1 Formato simple
- 27.10.2 Formateo de tipos personalizados
- 28 Biblioteca estándar: Extras
- 28.1 «par» y «tupla»
- 28.1.1 Devolución de varios valores
- 28.2 Expresiones regulares
- 28.2.1 Coincidencia y búsqueda
- 28.2.2 El resultado y sus partes
- 28.2.3 Sustitución encontrada
- 28.2.4 Rico en variantes
- 28.2.5 Iteradores
- 28.2.6 Partidos
- 28.2.7 Opciones
- 28.2.8 Velocidad
- 28.2.9 Sintaxis estándar, ligeramente abreviada
- 28.2.10 Notas sobre expresiones regulares en C++
- 28.3 Aleatoriedad
- 28.3.1 Lanzar un dado
- 28.3.2 Aleatoriedad verdadera
- 28.3.3 Otros generadores
- 28.3.4 Distribuciones
- 28.4 Matemáticas
- 28.4.1 Fracción y tiempo: «<ratio>» y «<chrono>»
- 28.4.2 Sufijos predefinidos para literales definidos por el usuario
- 28.5 Manejo de errores del sistema con «system_error»
- 28.5.1 Descripción general
- 28.5.2 Principios
- 28.5.3 «error_code» y «error_condition»
- 28.5.4 Categorías de errores
- 28.5.5 Códigos de error personalizados
- 28.5.6 Excepción «system_error»
- 28.6 Información de tipo en tiempo de ejecución: «<typeinfo>» y «<typeindex>»
- 28.7 Clases auxiliares relacionadas con los funtores: «<functional>»
- 28.7.1 Objetos de función
- 28.7.2 Generadores de funciones
- 28.8 «opcional» para un valor único o sin valor
- 28.9 «Variante» para uno de varios tipos
- 28.10 «Cualquier» retiene cualquier tipo
- 28.11 Funciones matemáticas especiales
- 28.12 Conversión rápida con «<charconv>»
- 29 hilos: Programación con concurrencia
- 29.1 Conceptos básicos sobre subprocesos en C++
- 29.1.1 Inicio de subprocesos puros
- 29.1.2 Terminación prematura de un hilo
- 29.1.3 Esperando un hilo
- 29.1.4 Considerar excepciones en el hilo de inicio
- 29.1.5 Pasar parámetros a una función de subproceso
- 29.1.6 Mover un hilo
- 29.1.7 ¿Cuántos subprocesos iniciar?
- 29.1.8 ¿Qué hilo soy?
- 29.2 Datos compartidos
- 29.2.1 Conflictos de datos
- 29.2.2 Pestillo
- 29.2.3 Barreras
- 29.2.4 Mutexes
- 29.2.5 Diseño de interfaces para multihilos
- 29.2.6 Los bloqueos pueden provocar interbloqueos
- 29.2.7 Bloqueo más flexible con «unique_lock»
- 29.3 Otras opciones de sincronización
- 29.3.1 Llamar solo una vez con «once_flag» y «call_once»
- 29.3.2 Bloqueo con «recursive_mutex»
- 29.4 En su propio almacenamiento con «thread_local»
- 29.5 Esperando eventos con «condition_variable»
- 29.5.1 «notificar_a_todos»
- 29.5.2 Sincronizar salida
- 29.6 Esperar una vez con «futuro»
- 29.6.1 Políticas de lanzamiento
- 29.6.2 Esperar hasta una hora determinada
- 29.6.3 Manejo de excepciones con «future»
- 29.6.4 «promesa»
- 29.7 Atómicos
- 29.7.1 Resumen de las operaciones
- 29.7.2 Orden de la memoria
- 29.7.3 Ejemplo
- 29.8 Corrutinas
- 29.8.1 Corrutinas en el compilador
- 29.8.2 Generador
- 29.8.3 Corrutinas con «promise_type»
- 29.9 Resumen
- 29.9.1 Encabezado «<thread>»
- 29.9.2 Encabezados «<latch>» y «<barrier>»
- 29.9.3 Encabezados «<mutex>» y «<shared mutex>»
- 29.9.4 Encabezado «<variable de condición>»
- 29.9.5 Encabezado «<future>»
- 29.9.6 Encabezado «<atomic>»
- 29.9.7 Encabezado «<coroutine>»
- 30 Código ético, 7.º dan: directrices
- 30.1 Biblioteca de apoyo a las directrices
- 30.2 Directrices básicas de C++
- 30.2.1 Motivación
- 30.2.2 Seguridad de tipos
- 30.2.3 Utilizar RAII
- 30.2.4 Jerarquías de clases
- 30.2.5 Programación genérica
- 30.2.6 No se deje confundir por los anacronismos
- Anexos
- Una hoja de trucos
- B El autor
- Índice
C++
If you need to know C++, look no further! This comprehensive guide has everything you need to master the modern C++23 language, from syntax fundamentals to advanced development concepts. Follow practical code examples as you learn object-oriented programming, work with standard library containers, program concurrent applications, and more. Don’t just learn how to code—learn how to code better with expert tips and guidance on the rules of compact, secure, and efficient code.
- Your all in one guide to modern C++
- Work with the C++ language, from basic syntax and functions to more advanced features such as pointers and macros
- Learn to use the standard library and containers
You'll learn about:
- Basic to Advanced Programming:
Master C++ programming from the ground up. Learn how to code with building blocks such as comments, variables, and functions, and then walk through object-oriented programming. Graduate to advanced concepts, including pointers and templates.
- The Standard Library:
Dive into the C++ standard library, including an in-depth guide to containers: what they can do, what they can’t do, and how to choose the right one for your scenario. Work with streams and files, explore unique syntax, and implement concurrency using threads.
- Good Coding Practices:
Write effective, sustainable code. Dedicated chapters provide guidelines, techniques, and tips for good coding. Put theory into practice with numerous sample programs that you can download to help jump-start your own projects.
Key Highlights:
- Language basics
- Statements and expressions
- Structures and classes
- Object-oriented programming
- Containers
- Threading
- Error handling
- Testing
- Pointers
- Interface to C
- Templates
- Best practices
View Full Table of Contents
- Preface
- PART I Fundamentals
- 1 C++: The Comprehensive Guide
- 1.1 New and Modern
- 1.2 “Dan” Chapters
- 1.3 Presentation in This Book
- 1.4 Formatting Used
- 1.5 Let’s Talk Lingo
- 2 Programming in C++
- 2.1 Compiling
- 2.2 Translation Phases
- 2.3 Current Compilers
- 2.3.1 Gnu C++
- 2.3.2 Clang++ from LLVM
- 2.3.3 Microsoft Visual C++
- 2.3.4 Compiler in the Container
- 2.4 Development Environments
- 2.5 The Command Line under Ubuntu
- 2.5.1 Create a Program
- 2.5.2 Automate with Makefile
- 2.6 The Visual Studio Code IDE under Windows
- 2.7 Speed Up the Sample Program
- 3 C++ for Newcomers
- 4 The Basic Building Blocks of C++
- 4.1 A Quick Overview
- 4.1.1 Comments
- 4.1.2 The “include” Directive
- 4.1.3 The Standard Library
- 4.1.4 The “main()” Function
- 4.1.5 Types
- 4.1.6 Variables
- 4.1.7 Initialization
- 4.1.8 Output on the Console
- 4.1.9 Statements
- 4.2 A Detailed Walkthrough
- 4.2.1 Spaces, Identifiers, and Tokens
- 4.2.2 Comments
- 4.2.3 Functions and Arguments
- 4.2.4 Side Effect Operators
- 4.2.5 The “main” Function
- 4.2.6 Statements
- 4.2.7 Expressions
- 4.2.8 Allocations
- 4.2.9 Types
- 4.2.10 Variables: Declaration, Definition, and Initialization
- 4.2.11 Initialize with “auto”
- 4.2.12 Details on the Include Directive
- 4.2.13 Modules
- 4.2.14 Input and Output
- 4.2.15 The “std” Namespace
- 4.3 Operators
- 4.3.1 Operators and Operands
- 4.3.2 Overview of Operators
- 4.3.3 Arithmetic Operators
- 4.3.4 Bit-by-Bit Arithmetic
- 4.3.5 Composite Assignment
- 4.3.6 Post- and Preincrement and Post- and Predecrement
- 4.3.7 Relational Operators
- 4.3.8 Logical Operators
- 4.3.9 Pointer and Dereference Operators
- 4.3.10 Special Operators
- 4.3.11 Function-Like Operators
- 4.3.12 Operator Sequence
- 4.4 Built-In Data Types
- 4.4.1 Overview
- 4.4.2 Initialize Built-In Data Types
- 4.4.3 Integers
- 4.4.4 Floating-Point Numbers
- 4.4.5 Truth Values
- 4.4.6 Character Types
- 4.4.7 Complex Numbers
- 4.5 Undefined Behavior
- 5 Good Code, 1st Dan: Writing Readable Code
- 5.1 Comments
- 5.2 Documentation
- 5.3 Indentations and Line Length
- 5.4 Lines per Function and File
- 5.5 Brackets and Spaces
- 5.6 Names
- 6 Higher Data Types
- 6.1 The String Type “string”
- 6.1.1 Initialization
- 6.1.2 Functions and Methods
- 6.1.3 Other String Types
- 6.1.4 For Viewing Only: “string_view”
- 6.2 Streams
- 6.2.1 Input and Output Operators
- 6.2.2 “getline”
- 6.2.3 Files for Input and Output
- 6.2.4 Manipulators
- 6.2.5 The “endl” Manipulator
- 6.3 Container and Pointer
- 6.3.1 Container
- 6.3.2 Parameterized Types
- 6.4 The Simple Sequence Containers
- 6.4.1 “array”
- 6.4.2 “vector”
- 6.5 Algorithms
- 6.6 Pointers and C-Arrays
- 6.6.1 Pointer Types
- 6.6.2 C-Arrays
- 7 Functions
- 7.1 Declaration and Definition of a Function
- 7.2 Function Type
- 7.3 Using Functions
- 7.4 Defining a Function
- 7.5 More about Parameters
- 7.5.1 Call-by-Value
- 7.5.2 Call-by-Reference
- 7.5.3 Constant References
- 7.5.4 Call as Value, Reference, or Constant Reference?
- 7.6 Functional Body
- 7.7 Converting Parameters
- 7.8 Overloading Functions
- 7.9 Default Parameter
- 7.10 Arbitrary Number of Arguments
- 7.11 Alternative Notation for Function Declaration
- 7.12 Specialties
- 7.12.1 “noexcept”
- 7.12.2 Inline Functions
- 7.12.3 “constexpr”
- 7.12.4 Deleted Functions
- 7.12.5 Specialties in Class Methods
- 8 Statements in Detail
- 8.1 The Statement Block
- 8.1.1 Standalone Blocks and Variable Scope
- 8.2 The Empty Statement
- 8.3 Declaration Statement
- 8.4 The Expression Statement
- 8.5 The “if” Statement
- 8.5.1 “if” with Initializer
- 8.5.2 Compile-Time “if”
- 8.6 The “while” Loop
- 8.7 The “do-while” Loop
- 8.8 The “for” Loop
- 8.9 The Range-Based “for” Loop
- 8.10 The “switch” Statement
- 8.11 The “break” Statement
- 8.12 The “continue” Statement
- 8.13 The “return” Statement
- 8.14 The “goto” Statement
- 8.15 The “try-catch” Block and “throw”
- 8.16 Summary
- 9 Expressions in Detail
- 9.1 Calculations and Side Effects
- 9.2 Types of Expressions
- 9.3 Literals
- 9.4 Identifiers
- 9.5 Parentheses
- 9.6 Function Call and Index Access
- 9.7 Assignment
- 9.8 Type Casting
- 10 Error Handling
- 10.1 Error Handling with Error Codes
- 10.2 What Is an Exception?
- 10.2.1 Throwing and Handling Exceptions
- 10.2.2 Unwinding the Call Stack
- 10.3 Minor Error Handling
- 10.4 Throwing the Exception Again: “rethrow”
- 10.5 The Order in “catch”
- 10.5.1 No “finally”
- 10.5.2 Standard Library Exceptions
- 10.6 Types for Exceptions
- 10.7 When an Exception Falls Out of “main”
- 11 Good Code, 2nd Dan: Modularization
- 11.1 Program, Library, Object File
- 11.2 Modules
- 11.3 Separating Functionalities
- 11.4 A Modular Example Project
- 11.4.1 Namespaces
- 11.4.2 Implementation
- 11.4.3 Using the Library
- PART II Object-Oriented Programming and More
- 12 From Structure to Class
- 12.1 Initialization
- 12.2 Returning Custom Types
- 12.3 Methods Instead of Functions
- 12.4 The Better “print”
- 12.5 An Output Like Any Other
- 12.6 Defining Methods Inline
- 12.7 Separate Implementation and Definition
- 12.8 Initialization via Constructor
- 12.8.1 Member Default Values in Declaration
- 12.8.2 Constructor Delegation
- 12.8.3 Default Values for Constructor Parameters
- 12.8.4 Do Not Call the “init” Method in the Constructor
- 12.8.5 Exceptions in the Constructor
- 12.9 Struct or Class?
- 12.9.1 Encapsulation
- 12.9.2 “public” and “private”, Struct and Class
- 12.9.3 Data with “struct”, Behavior with “class”
- 12.9.4 Initialization of Types with Private Data
- 12.10 Interim Recap
- 12.11 Using Custom Data Types
- 12.11.1 Using Classes as Values
- 12.11.2 Using Constructors
- 12.11.3 Type Conversions
- 12.11.4 Encapsulate and Decapsulate
- 12.11.5 Give Types a Local Name
- 12.12 Type Inference with “auto”
- 12.13 Custom Classes in Standard Containers
- 12.13.1 Three-Way Comparison: The Spaceship Operator
- 13 Namespaces and Qualifiers
- 13.1 The “std” Namespace
- 13.2 Anonymous Namespace
- 13.3 “static” Makes Local
- 13.4 “static” Likes to Share
- 13.5 Remote Initialization or “static inline” Data Fields
- 13.6 Guaranteed to Be Initialized at Compile Time with “constinit”
- 13.7 “static” Makes Permanent
- 13.8 “inline namespace”
- 13.9 Interim Recap
- 13.10 “const”
- 13.10.1 Const Parameters
- 13.10.2 Const Methods
- 13.10.3 “const” Variables
- 13.10.4 Const Returns
- 13.10.5 “const” Together with “static”
- 13.10.6 Even More Constant with “constexpr”
- 13.10.7 “if constexpr” for Compile-Time Decisions
- 13.10.8 C++20: “consteval”
- 13.10.9 “if consteval”
- 13.10.10 Un-“const” with “mutable”
- 13.10.11 Const-Correctness
- 13.10.12 Summary
- 13.11 Volatile with “volatile”
- 14 Good Code, 3rd Dan: Testing
- 14.1 Types of Tests
- 14.1.1 Refactoring
- 14.1.2 Unit Tests
- 14.1.3 Social or Solitary
- 14.1.4 Doppelgangers
- 14.1.5 Suites
- 14.2 Frameworks
- 14.2.1 Arrange, Act, Assert
- 14.2.2 Frameworks to Choose From
- 14.3 Boost.Test
- 14.4 Helper Macros for Assertions
- 14.5 An Example Project with Unit Tests
- 14.5.1 Private and Public Testing
- 14.5.2 An Automatic Test Module
- 14.5.3 Compile Test
- 14.5.4 Assemble the Test Suite Yourself
- 14.5.5 Testing Private Members
- 14.5.6 Parameterized Tests
- 15 Inheritance
- 15.1 Relationships
- 15.1.1 Has-a Composition
- 15.1.2 Has-a Aggregation
- 15.1.3 Is-a Inheritance
- 15.1.4 Instance-of versus Is-a Relationship
- 15.2 Inheritance in C++
- 15.3 Has-a versus Is-a
- 15.4 Finding Commonalities
- 15.5 Derived Types Extend
- 15.6 Overriding Methods
- 15.7 How Methods Work
- 15.8 Virtual Methods
- 15.9 Constructors in Class Hierarchies
- 15.10 Type Conversion in Class Hierarchies
- 15.10.1 Converting Up the Inheritance Hierarchy
- 15.10.2 Downcasting the Inheritance Hierarchy
- 15.10.3 References Also Retain Type Information
- 15.11 When to Use Virtual?
- 15.12 Other Designs for Extensibility
- 16 The Lifecycle of Classes
- 16.1 Creation and Destruction
- 16.2 Temporary: Short-Lived Values
- 16.3 The Destructor to the Constructor
- 16.3.1 No Destructor Needed
- 16.3.2 Resources in the Destructor
- 16.4 Yoda Condition
- 16.5 Construction, Destruction, and Exceptions
- 16.6 Copy
- 16.7 Assignment Operator
- 16.8 Removing Methods
- 16.9 Move Operations
- 16.9.1 What the Compiler Generates
- 16.10 Operators
- 16.11 Custom Operators in a Data Type
- 16.12 Special Class Forms
- 16.12.1 Abstract Classes and Methods
- 16.12.2 Enumeration Classes
- 17 Good Code, 4th Dan: Security, Quality, and Sustainability
- 17.1 The Rule of Zero
- 17.1.1 The Big Five
- 17.1.2 Helper Construct by Prohibition
- 17.1.3 The Rule of Zero and Its Application
- 17.1.4 Exceptions to the Rule of Zero
- 17.1.5 Rule of Zero, Rule of Three, Rule of Five, Rule of Four and a Half
- 17.2 Resource Acquisition Is Initialization
- 17.2.1 An Example with C
- 17.2.2 Owning Raw Pointers
- 17.2.3 From C to C++
- 17.2.4 It Doesn't Always Have to Be an Exception
- 17.2.5 Multiple Constructors
- 17.2.6 Multiphase Initialization
- 17.2.7 Define Where It Is Needed
- 17.2.8 “new” without Exceptions
- 18 Specials for Classes
- 18.1 Allowed to See Everything: “friend” Classes
- 18.1.1 “friend class” Example
- 18.2 Nonpublic Inheritance
- 18.2.1 Impact on the Outside World
- 18.2.2 Nonpublic Inheritance in Practice
- 18.3 Signature Classes as Interfaces
- 18.4 Multiple Inheritance
- 18.4.1 Multiple Inheritance in Practice
- 18.4.2 Caution with Pointer Type Conversions
- 18.4.3 The Observer Pattern as a Practical Example
- 18.5 Diamond-Shaped Multiple Inheritance: “virtual” for Class Hierarchies
- 18.6 Literal Data Types: “constexpr” for Constructors
- 19 Good Code, 5th Dan: Classical Object-Oriented Design
- 19.1 Objects in C++
- 19.2 Object-Oriented Design
- 19.2.1 SOLID
- 19.2.2 Don't Be STUPID
- PART III Advanced Topics
- 20 Pointers
- 20.1 Addresses
- 20.2 Pointer
- 20.3 Dangers of Aliasing
- 20.4 Heap Memory and Stack Memory
- 20.4.1 The Stack
- 20.4.2 The Heap
- 20.5 Smart Pointers
- 20.5.1 “unique_ptr”
- 20.5.2 “shared_ptr”
- 20.6 Raw Pointers
- 20.7 C-Arrays
- 20.7.1 Calculating with Pointers
- 20.7.2 Decay of C-Arrays
- 20.7.3 Dynamic C-Arrays
- 20.7.4 String Literals
- 20.8 Iterators
- 20.9 Pointers as Iterators
- 20.10 Pointers in Containers
- 20.11 The Exception: When Cleanup Is Not Necessary
- 21 Macros
- 21.1 The Preprocessor
- 21.2 Beware of Missing Parenthesis
- 21.3 Feature Macros
- 21.4 Information about the Source Code
- 21.5 Warning about Multiple Executions
- 21.6 Type Variability of Macros
- 21.7 Summary
- 22 Interface to C
- 22.1 Working with Libraries
- 22.2 C Header
- 22.3 C Resources
- 22.4 “void” Pointers
- 22.5 Reading Data
- 22.6 The Main Program
- 22.7 Summary
- 23 Templates
- 23.1 Function Templates
- 23.1.1 Overloading
- 23.1.2 A Type as Parameter
- 23.1.3 Function Body of a Function Template
- 23.1.4 Values as Template Parameters
- 23.1.5 Many Functions
- 23.1.6 Parameters with Extras
- 23.1.7 Method Templates are Just Function Templates
- 23.2 Function Templates in the Standard Library
- 23.2.1 Ranges instead of Containers as Template Parameters
- 23.2.2 Example: Information about Numbers
- 23.3 A Class as a Function
- 23.3.1 Values for a “Function” Parameter
- 23.3.2 C Function Pointer
- 23.3.3 The Somewhat Different Function
- 23.3.4 Practical Functors
- 23.3.5 Algorithms with Functors
- 23.3.6 Anonymous Functions: a.k.a. Lambda Expressions
- 23.3.7 Template Functions without “template”, but with “auto”
- 23.4 C++ Concepts
- 23.4.1 How to Read Concepts
- 23.4.2 How to Use Concepts
- 23.4.3 How to Write Concepts
- 23.4.4 Semantic Constraints
- 23.4.5 Interim Recap
- 23.5 Template Classes
- 23.5.1 Implementing Class Templates
- 23.5.2 Implementing Methods of Class Templates
- 23.5.3 Creating Objects from Class Templates
- 23.5.4 Class Templates with Multiple Formal Data Types
- 23.5.5 Class Templates with Nontype Parameters
- 23.5.6 Class Templates with Defaults
- 23.5.7 Specializing Class Templates
- 23.6 Templates with Variable Argument Count
- 23.6.1 “sizeof ...” Operator
- 23.6.2 Convert Parameter Pack to Tuple
- 23.7 Custom Literals
- 23.7.1 What Are Literals?
- 23.7.2 Naming Rules
- 23.7.3 Literal Processing Phases
- 23.7.4 Overloading Variants
- 23.7.5 User-Defined Literal Using Template
- 23.7.6 Raw or Cooked
- 23.7.7 Automatically Merged
- 23.7.8 Unicode Literals
- PART IV The Standard Library
- 24 Containers
- 24.1 Basics
- 24.1.1 Recurring
- 24.1.2 Abstract
- 24.1.3 Operations
- 24.1.4 Complexity
- 24.1.5 Containers and Their Iterators
- 24.1.6 Ranges Simplify Iterators
- 24.1.7 Ranges, Views, Concepts, Adapters, Generators, and Algorithms
- 24.1.8 Algorithms
- 24.2 Iterator Basics
- 24.2.1 Iterators from Containers
- 24.2.2 More Functionality with Iterators
- 24.3 Allocators: Memory Issues
- 24.4 Container Commonalities
- 24.5 An Overview of the Standard Container Classes
- 24.5.1 Type Aliases of Containers
- 24.6 The Sequential Container Classes
- 24.6.1 Commonalities and Differences
- 24.6.2 Methods of Sequence Containers
- 24.6.3 “vector”
- 24.6.4 “array”
- 24.6.5 “deque”
- 24.6.6 “list”
- 24.6.7 “forward_list”
- 24.7 Associative and Ordered
- 24.7.1 Commonalities and Differences
- 24.7.2 Methods of Ordered Associative Containers
- 24.7.3 “set”
- 24.7.4 “map”
- 24.7.5 “multiset”
- 24.7.6 “multimap”
- 24.8 Only Associative and Not Guaranteed
- 24.8.1 Hash Tables
- 24.8.2 Commonalities and Differences
- 24.8.3 Methods of Unordered Associative Containers
- 24.8.4 “unordered_set”
- 24.8.5 “unordered_map”
- 24.8.6 “unordered_multiset”
- 24.8.7 “unordered_multimap”
- 24.9 Container Adapters
- 24.10 Special Cases: “string”, “basic_string”, and “vector<char>”
- 24.11 Special Cases: “vector<bool>”, “array<bool,n>”, and “bitset<n>”
- 24.11.1 Dynamic and Compact: “vector<bool>”
- 24.11.2 Static: “array<bool,n>” and “bitset<n>”
- 24.12 Special Case: Value Array with “valarray<>”
- 24.12.1 Element Properties
- 24.12.2 Initialize
- 24.12.3 Assignment
- 24.12.4 Insert and Delete
- 24.12.5 Accessing
- 24.12.6 Specialty: Manipulate All Data
- 24.12.7 Specialty: Slicing and Masking
- 25 Container Support
- 25.1 Algorithms
- 25.2 Iterators and Ranges
- 25.3 Iterator Adapter
- 25.4 Algorithms of the Standard Library
- 25.5 Parallel Execution
- 25.6 Lists of Algorithm Functions and Range Adapters
- 25.6.1 Range Adapters and Views
- 25.6.2 Ranges as Parameters (and More)
- 25.6.3 List of Nonmodifying Algorithms
- 25.6.4 Inherently Modifying Algorithms
- 25.6.5 Algorithms for Partitions
- 25.6.6 Algorithms for Sorting and Fast Searching in Sorted Ranges
- 25.6.7 Set Algorithms Represented by a Sorted Range
- 25.6.8 Heap Algorithms
- 25.6.9 Minimum and Maximum
- 25.6.10 Various Algorithms
- 25.7 Element-Linking Algorithms from “<numeric>” and “<ranges>”
- 25.8 Copy instead of Assignment: Values in Uninitialized Memory Areas
- 25.9 Custom Algorithms
- 25.10 Writing Custom Views and Range Adapters
- 26 Good Code, 6th Dan: The Right Container for Each Task
- 26.1 All Containers Arranged by Aspects
- 26.1.1 When Is a “vector” Not the Best Choice?
- 26.1.2 Always Sorted: “set”, “map”, “multiset”, and “multimap”
- 26.1.3 In Memory Contiguously: “vector”, “array”
- 26.1.4 Cheap Insertion: “list”
- 26.1.5 Low Memory Overhead: “vector”, “array”
- 26.1.6 Size Dynamic: All Except “array”
- 26.2 Recipes for Containers
- 26.2.1 Two Phases? “vector” as a Good “set” Replacement
- 26.2.2 Output the Contents of a Container to a Stream
- 26.2.3 So “array” Is Not That Static
- 26.3 Implementing Algorithms That Are Specialized Depending on the Container
- 27 Streams, Files, and Formatting
- 27.1 Input and Output Concept with Streams
- 27.2 Global, Predefined Standard Streams
- 27.2.1 Stream Operators << and >>
- 27.3 Methods for Stream Input and Output
- 27.3.1 Methods for Unformatted Output
- 27.3.2 Methods for Unformatted Input
- 27.4 Error Handling and Stream States
- 27.4.1 Methods for Handling Stream Errors
- 27.5 Manipulating and Formatting Streams
- 27.5.1 Manipulators
- 27.5.2 Creating Custom Manipulators without Arguments
- 27.5.3 Creating Custom Manipulators with Arguments
- 27.5.4 Directly Change Format Flags
- 27.6 Streams for File Input and Output
- 27.6.1 The “ifstream”, “ofstream”, and “fstream” Streams
- 27.6.2 Connecting to a File
- 27.6.3 Reading and Writing
- 27.6.4 Random Access
- 27.6.5 Synchronized Streams for Threads
- 27.7 Streams for Strings
- 27.7.1 Difference from “to_string”
- 27.7.2 “to_chars” and “format” Are More Flexible than “to_string”
- 27.7.3 Reading from a String
- 27.8 Stream Buffers
- 27.8.1 Access to the Stream Buffer of “iostream” Objects
- 27.8.2 “filebuf”
- 27.8.3 “stringbuf”
- 27.9 “filesystem”
- 27.10 Formatting
- 27.10.1 Simple Formatting
- 27.10.2 Formatting Custom Types
- 28 Standard Library: Extras
- 28.1 “pair” and “tuple”
- 28.1.1 Returning Multiple Values
- 28.2 Regular Expressions
- 28.2.1 Matching and Searching
- 28.2.2 The Result and Parts of It
- 28.2.3 Found Replacement
- 28.2.4 Rich in Variants
- 28.2.5 Iterators
- 28.2.6 Matches
- 28.2.7 Options
- 28.2.8 Speed
- 28.2.9 Standard Syntax, Slightly Shortened
- 28.2.10 Notes on Regular Expressions in C++
- 28.3 Randomness
- 28.3.1 Rolling a Die
- 28.3.2 True Randomness
- 28.3.3 Other Generators
- 28.3.4 Distributions
- 28.4 Mathematical
- 28.4.1 Fraction and Time: “<ratio>” and “<chrono>”
- 28.4.2 Predefined Suffixes for User-Defined Literals
- 28.5 System Error Handling with “system_error”
- 28.5.1 Overview
- 28.5.2 Principles
- 28.5.3 “error_code” and “error_condition”
- 28.5.4 Error Categories
- 28.5.5 Custom Error Codes
- 28.5.6 “system_error” Exception
- 28.6 Runtime Type Information: “<typeinfo>” and “<typeindex>”
- 28.7 Helper Classes around Functors: “<functional>”
- 28.7.1 Function Objects
- 28.7.2 Function Generators
- 28.8 “optional” for a Single Value or No Value
- 28.9 “variant” for One of Several Types
- 28.10 “any” Holds Any Type
- 28.11 Special Mathematical Functions
- 28.12 Fast Conversion with “<charconv>”
- 29 Threads: Programming with Concurrency
- 29.1 C++ Threading Basics
- 29.1.1 Starting Pure Threads
- 29.1.2 Terminating a Thread Prematurely
- 29.1.3 Waiting for a Thread
- 29.1.4 Consider Exceptions in the Starting Thread
- 29.1.5 Passing Parameters to a Thread Function
- 29.1.6 Moving a Thread
- 29.1.7 How Many Threads to Start?
- 29.1.8 Which Thread Am I?
- 29.2 Shared Data
- 29.2.1 Data Races
- 29.2.2 Latch
- 29.2.3 Barriers
- 29.2.4 Mutexes
- 29.2.5 Interface Design for Multithreading
- 29.2.6 Locks Can Lead to Deadlock
- 29.2.7 More Flexible Locking with “unique_lock”
- 29.3 Other Synchronization Options
- 29.3.1 Call Only Once with “once_flag” and “call_once”
- 29.3.2 Locking with “recursive_mutex”
- 29.4 In Its Own Storage with “thread_local”
- 29.5 Waiting for Events with “condition_variable”
- 29.5.1 “notify_all”
- 29.5.2 Synchronize Output
- 29.6 Waiting Once with “future”
- 29.6.1 Launch Policies
- 29.6.2 Wait Until a Certain Time
- 29.6.3 Exception Handling with “future”
- 29.6.4 “promise”
- 29.7 Atomics
- 29.7.1 Overview of the Operations
- 29.7.2 Memory Order
- 29.7.3 Example
- 29.8 Coroutines
- 29.8.1 Coroutines in the Compiler
- 29.8.2 Generator
- 29.8.3 Coroutines with “promise_type”
- 29.9 Summary
- 29.9.1 “<thread>” Header
- 29.9.2 “<latch>” and “<barrier>” Headers
- 29.9.3 “<mutex>” and “<shared mutex>” Headers
- 29.9.4 “<condition variable>” Header
- 29.9.5 “<future>” Header
- 29.9.6 “<atomic>” Header
- 29.9.7 “<coroutine>” Header
- 30 Good Code, 7th Dan: Guidelines
- 30.1 Guideline Support Library
- 30.2 C++ Core Guidelines
- 30.2.1 Motivation
- 30.2.2 Type Safety
- 30.2.3 Use RAII
- 30.2.4 Class Hierarchies
- 30.2.5 Generic Programming
- 30.2.6 Do Not Be Confused by Anachronisms
- Appendices
- A Cheat Sheet
- B The Author
- Index
