PrólogoIntroducción
1. General [intro]
1.1. Campo de aplicación [intro.scope]
1.2. Referencias normativas [intro.refs]
1.3. Definiciones [intro.defs]
1.3.1. Argumento [defns.argument]
1.3.2. Carácter multibyte [defns.multibyte]
1.3.3. Comportamiento dependiente de la implementación [defns.impl.defined]
1.3.4. Comportamiento específico regional [defns.locale.specific]
1.3.5. Comportamiento indefinido [defns.undefined]
1.3.6. Comportamiento no especificado [defns.unspecified]
1.3.7. Firma [defns.signature]
1.3.8. Límites de la implementación [defns.impl.limits]
1.3.9. Mensaje de diagnóstico [defns.diagnostic]
1.3.10. Parámetro [defns.parameter]
1.3.11. Programa correcto [defns.well.formed]
1.3.12. Programa incorrecto [defns.ill.formed]
1.3.13. Tipo dinámico [defns.dynamic.type]
1.3.14. Tipo estático [defns.static.type]
1.4. Conformidad de la implementación [intro.compliance]
1.5. Estructura del Estándar Internacional [intro.structure]
1.6. Notación de la sintaxis [syntax]
1.7. El modelo de memoria C++ [intro.memory]
1.8. El modelo de objetos de C++ [intro.object]
1.9. Ejecución de programas [intro.execution]
1.10. Agradecimientos [intro.ack]
2. Convenciones léxicas [lex]
2.1. Fases de la compilación [lex.phases]
2.2. Conjuntos de caracteres [lex.charset]
2.3. Secuencias de trígrafos [lex.trigraph]
2.4. Tokens de preprocesamiento
2.5. Tokens alternativos [lex.digraph]
2.6. Tokens
2.7. Comentarios [lex.comment]
2.8. Nombres de encabezados [lex.header]
2.9. Números de preprocesamiento [lex.ppnumber]
2.10. Identificadores [lex.name]
2.11. Palabras clave [lex.key]
2.12. Operadores y signos de puntuación [lex.operators]
2.13. Literales [lex.literal]
2.13.1. Literales de entero [lex.icon]
2.13.2. Literales de carácter [lex.ccon]
2.13.3. Literales de punto flotante [lex.fcon]
2.13.4. Literales de cadena [lex.string]
2.13.5. Literales booleanos [lex.bool]
3. Conceptos básicos [basic]
3.1. Declaraciones y definiciones [basic.def]
3.2. Regla de una sola definición [basic.def.odr]
3.3. Regiones declarativas y ámbitos [basic.scope]
3.3.1. Punto de declaración [basic.scope.pdecl]
3.3.2. Ámbito local [basic.scope.local]
3.3.3. Ámbito de función prototipo [basic.scope.proto]
3.3.4. Ámbito de función [basic.funscope]
3.3.5. Ámbito de espacio de nombre [basic.scope.namespace]
3.3.6. Ámbito de clase [basic.scope.class]
3.3.7. Ocultación de nombres [basic.scope.hiding]
3.4. Búsqueda de nombres [basic.lookup]
3.4.1. Búsqueda de nombres sin calificar [basic.lookup.unqual]
3.4.2. Búsqueda de nombres dependiente de argumentos [basic.lookup.koenig]
3.4.3. Búsqueda de nombres calificados [basic.lookup.qual]
3.4.4. Especificadores de tipo elaborado [basic.lookup.elab]
3.4.5. Acceso a los miembros de clase [basic.lookup.classref]
3.4.6. Directivas-using y alias de espacios de nombre[basic.lookup.udir]
3.5. Programa y enlazado [basic.link]
3.6. Inicio y terminación [basic.start]
3.6.1. Función principal o main [basic.start.main]
3.6.2. Inicialización de objetos no locales [basic.start.init]
3.6.3. Terminación [basic.start.term]
3.7. Duración de almacenamiento [basic.stc]
3.7.1. Duración de almacenamiento estática [basic.stc.static]
3.7.2. Duración de almacenamiento automática [basic.stc.auto]
3.7.3. Duración de almacenamiento dinámica [basic.stc.dynamic]
3.7.4. Duración de los subobjetos [basic.stc.inherit]
3.8. Vida de los objetos [basic.life]
3.9. Tipos [basic.types]
3.9.1. Tipos fundamentales [basic.fundamental]
3.9.2. Tipos compuestos [basic.compound]
3.9.3. Calificadores cv [basic.type.qualifier]
3.10. Lvalues y rvalues [basic.lval]
4. Conversiones estándar [conv]
4.1. Conversión de lvalue a rvalue [conv.lval]
4.2. Conversión de matriz a puntero [conv.array]
4.3. Conversión de función a puntero [conv.func]
4.4. Conversiones de calificación [conv.qual]
4.5. Promociones de entero [conv.prom]
4.6. Promoción de punto flotante [conv.fpprom]
4.7. Conversiones de enteros [conv.integral]
4.8. Conversiones de punto flotante [conv.double]
4.9. Conversiones de punto flotante-entero [conv.fpint]
4.10. Conversiones de puntero [conv.ptr]
4.11. Conversión de puntero dirigido a miembro [conv.mem]
4.12. Conversiones booleanas [conv.bool]
5. Expresiones [expr]
5.1. Expresiones primarias [expr.prim]
5.2. Expresiones postfijas [expr.post]
5.2.1. Subíndice [expr.sub]
5.2.2. Llamada a función [expr.call]
5.2.3. Conversión explicita de tipo (notación funcional)[expr.type.conc]
5.2.4. Llamada a pseudodestructor [expr.pseudo]
5.2.5. Acceso a miembro de clase [expr.ref]
5.2.6. Incremento y decremento [expr.post.incr]
5.2.7. Conversión dinámica [expr.dynamic.cast]
5.2.8. Identificación de tipo [expr.typeid]
5.2.9. Conversión estática [expr.static.cast]
5.2.10. Conversión de reinterpretación [expr.reinterpret.cast]
5.2.11. Conversión de const [expr.const.cast]
5.3. Expresiones unarias [expr.unary]
5.3.1. Operadores unarios [expr.unary.op]
5.3.2. Incremento y decremento [expr.pre.incr]
5.3.3. Sizeof [expr.sizeof]
5.3.4. New [expr.new]
5.3.5. Delete [expr.delete]
5.4. Conversión explícita de tipo (notación de cast) [expr.cast]
5.5. Operadores de puntero dirigido a miembro [expr.mptr.oper]
5.6. Operadores multiplicativos [expr.mul]
5.7. Operadores aditivos [expr.add]
5.8. Operadores de desplazamiento [expr.shift]
5.9. Operadores relacionales [expr.rel]
5.10. Operadores de igualdad [expr.eq]
5.11. Operador AND a nivel de bit [expr.bit.and]
5.12. Operador OR exclusivo a nivel de bit [expr.xor]
5.13. Operador OR inclusivo a nivel de bit [expr.or]
5.14. Operador lógico AND [expr.log.and]
5.15. Operador lógico OR [expr.log.or]
5.16. Operador condicional [expr.cond]
5.17. Operadores de asignación [expr.ass]
5.18. Operador coma [expr.comma]
5.19. Expresiones constantes [expr.const]
6. Instrucciones [stmt.stmt]
6.1. Instrucción etiquetada [stmt.label]
6.2. Instrucción de expresión [stmt.expr]
6.3. Instrucción compuesta o bloque [stmt.block]
6.4. Instrucciones de selección [stmt.select]
6.4.1. La instrucción if [stmt.if]
6.4.2. La instrucción switch [stmt.switch]
6.5. Instrucciones de iteración [stmt.iter]
6.5.1. La instrucción while [stmt.while]
6.5.2. La instrucción do [stmt.do]
6.5.3. La instrucción for [stmt.for]
6.6. Instrucciones de salto [stmt.jump]
6.6.1. La instrucción break [stmt.break]
6.6.2. La instrucción continue [stmt.cont]
6.6.3. La instrucción return [stmt.return]
6.6.4. La instrucción goto [stmt.goto]
6.7. Instrucción de declaración [stmt.dcl]
6.8. Resolución de ambigüedad [stmt.ambig]
7. Declaraciones [dcl.dcl]
7.1. Especificadores [dcl.spec]
7.1.1. Especificadores de clase de almacenamiento [dcl.stc]
7.1.2. Especificadores de función [dcl.fct.spec]
7.1.3. El especificador typedef [dcl.typedef]
7.1.4. El especificador friend [dcl.friend]
7.1.5. Especificadores de tipo [dcl.type]
7.2. Declaraciones de enumeración [dcl.enum]
7.3. Espacios de nombre [basic.namespace]
7.3.1. Definición de espacio de nombre [namespace.def]
7.3.2. Alias de espacio de nombre [namespace.alias]
7.3.3. La declaración using [namespace.udecl]
7.3.4. Directiva using [namespace.udir]
7.4. La declaración asm [dcl.asm]
7.5. Especificaciones de enlazado [dcl.link]
8. Declaradores [dcl.decl]
8.1. Nombres de tipo [dcl.name]
8.2. Resolución de la ambigüedad [dcl.ambig.res]
8.3. Significado de los declaradores [dcl.meaning]
8.3.1. Punteros [dcl.ptr]
8.3.2. Referencias [dcl.ref]
8.3.3. Punteros dirigidos a miembros [dcl.mptr]
8.3.4. Matrices [dcl.array]
8.3.5. Funciones [dcl.fct]
8.3.6. Argumentos predeterminados [dcl.fct.default]
8.4. Definiciones de función [dcl.fct.def]
8.5 Inicializadores [dcl.init]
8.5.1 Agregados [dcl.init.aggr]
8.5.2. Matrices de caracteres [dcl.init.string]
8.5.3. Referencias [dcl.init.ref]
9. Clases [class]
9.1. Nombres de clase [class.name]
9.2. Miembros de clase [class.mem]
9.3. Funciones miembro [class.mfct]
9.3.1. Funciones miembro no estáticas [class.mfct.nonstatic]
9.3.2. El puntero this [class.this]
9.4. Miembros estáticos [class.static]
9.4.1. Funciones miembro estáticas [class.static.mfct]
9.4.2. Miembros de datos estáticos [class.static.data]
9.5. Uniones [class.union]
9.6. Campos de bits [class.bit]
9.7. Declaraciones de clases anidadas [class.nest]
9.8. Declaraciones de clases locales [class.local]
9.9. Nombres de tipos anidados [class.nested.type]
10. Clases derivadas [class.derived]
10.1. Múltiples clases base [class.mi]
10.2. Búsqueda de nombres de miembros [class.member.lookup]
10.3. Funciones virtuales [class.virtual]
10.4. Clases abstractas [class.abstract]
11. Control de acceso a miembros [class.access]
11.1. Especificadores de acceso [class.access.spec]
11.2. Accesibilidad de clases base y miembros de clase base[class.access.base]
11.3. Declaraciones de acceso [class.access.dcl]
11.4. Amigas [class.friend]
11.5. Acceso a miembros protegidos [class.protected]
11.6. Acceso a funciones virtuales [class.access.virt]
11.7. Acceso múltiple [class.paths]
11.8. Clases anidadas [class.access.nest]
12. Funciones miembro especiales [special]
12.1. Constructores [class.ctor]
12.2. Objetos temporales [class.temporary]
12.3. Conversiones [class.conv]
12.3.1. Conversión mediante constructor [class.conv.ctor]
12.3.2. Funciones de conversión [class.conv.fct]
12.4. Destructores [class.dtor]
12.5. Liberar almacenamiento [class.free]
12.6. Inicialización [class.init]
12.6.1. Inicialización explícita [class.expl.init]
12.6.2. Inicialización de clases y miembros [class.base.init]
12.7. Construcción y destrucción [class.cdtor]
12.8. Copia de objetos de clase [class.copy]
13. Sobrecarga [over]
13.1. Declaraciones sobrecargables [over.load]
13.2. Coincidencia de declaraciones [over.dcl]
13.3. Resolución de sobrecarga [over.match]
13.3.1. Funciones candidatas y listas de argumentos[over.match.funcs]
13.3.2. Funciones viables [over.match.viable]
13.3.3. Mejor función viable [over.match.best]
13.4. Dirección de función sobrecargada [over.over]
13.5. Operadores sobrecargados [over.oper]
13.5.1. Operadores unarios [over.unary]
13.5.2. Operadores binarios [over.binary]
13.5.3. Asignación [over.ass]
13.5.4. Llamada a función [over.call]
13.5.5. Subíndice [over.sub]
13.5.6. Acceso a miembro de clase [over.ref]
13.5.7. Incremento y decremento [over.inc]
13.6. Operadores incorporados [over.built]
14. Plantillas [temp]
14.1. Parámetros de plantilla [temp.param]
14.2. Nombres de especialización de plantilla [temp.names]
14.3. Argumentos de plantilla [temp.arg]
14.3.1. Argumentos de plantilla de tipo [temp.arg.type]
14.3.2. Argumentos de plantilla no de tipo [temp.arg.nontype]
14.3.3. Argumentos de plantilla de plantilla [temp.arg.template]
14.4. Equivalencia de tipo [temp.type]
14.5. Declaraciones de plantilla [temp.decls]
14.5.1. Plantillas de clases [temp.class]
14.5.2. Plantillas miembro [temp.mem]
14.5.3. Amigas [temp.friend]
14.5.4. Especializaciones parciales de plantillas de clases[temp.class.spec]
14.5.5. Plantillas de funciones [temp.fct]
14.6. Resolución de nombres [temp.res]
14.6.1. Nombres declarados localmente [temp.local]
14.6.2. Nombres dependientes [temp.dep]
14.6.3. Nombres no dependientes [temp.nondep]
14.6.4. Resolución de nombres dependientes [temp.dep.res]
14.6.5. Nombres de amigos declarados dentro de una plantillade clases [temp.inject]
14.7. Instanciación y especialización de plantillas [temp.spec]
14.7.1. Instanciación implícita [temp.inst]
14.7.2. Instanciación explícita [temp.explicit]
14.7.3. Especialización explícita [temp.expl.spec]
14.8. Especializaciones de plantilla de funciones [temp.fct.spec]
14.8.1. Especialización explícita de argumentos de plantilla [temp.arg.explicit]
14.8.2. Deducción de argumentos de plantilla [temp.deduct]
14.8.3. Resolución de sobrecarga [temp.over]
15. Control de las excepciones [except]
15.1. Lanzamiento de una excepción [except.throw]
15.2. Constructores y destructores [except.ctor]
15.3. Controlar una excepción [except.handle]
15.4. Especificaciones de excepción [except.spec]
15.5. Funciones especiales [except.special]
15.5.1. La función terminate() [except.terminate]
15.5.2. La función unexpected() [except.unexpected]
15.5.3. La función uncaught_exception() [except.uncaught]
15.6. Excepciones y acceso [except.access]
16. Directivas de preprocesamiento [cpp]
16.1. Inclusión condicional [cpp.cond]
16.2. Inclusión de archivos de origen [cpp.include]
16.3. Sustitución de macros [cpp.replace]
16.4. Control de líneas [cpp.line]
16.5. Directiva de error [cpp.error]
16.6. Directiva pragma [cpp.pragma]
16.7. Directiva nula [cpp.null]
16.8. Nombres de macro predefinidos [cpp.predefined]
17. Introducción a la biblioteca [lib.library]
17.1. Definiciones [lib.definitions]
17.1.1. carácter [defns.character]
17.1.2. clase de rasgos [defns.traits]
17.1.3. clases iostream orientadas a caracteres anchos
17.1.4. clases iostream orientadas a caracteres estrechos
17.1.5. componente [defns.component]
17.1.6. comportamiento predeterminado [defns.default.behavior]
17.1.7. comportamiento requerido [defns.required.behavior]
17.1.8. estado de objeto [defns.obj.state]
17.1.9. flujo arbitrario-posicional [defns.arbitrary.stream]
17.1.10. flujo reposicional [defns.repositional.stream]
17.1.11. función de comparación [defns.comparison]
17.1.12. función de controlador [defns.handler]
17.1.13. función de sustitución [defns.replacement]
17.1.14. función modificadora [defns.modifier]
17.1.15. función reservada [defns.reserved.function]
17.1.16. funciones observadoras [defns.observer]
17.1.17. NTCTS (secuencia de tipos de carácter terminada en cero) [defns.ntcts]
17.1.18. plantillas de clases iostream [defns.iostream.templates]
17.1.19. tipo de contenedor de caracteres [defns.character.container]
17.2. Definiciones adicionales [defns.additional]
17.3. Método de descripción (Informativo) [lib.description]
17.3.1. Estructura de cada subcláusula [lib.structure]
17.3.2. Otras convenciones [lib.conventions]
17.4. Requisitos para toda la biblioteca [lib.requirements]
17.4.1. Contenido y la organización de la biblioteca [lib.organization]
17.4.2. Utilización de la biblioteca [lib.using]
17.4.3. Restricciones de los programas [lib.constraints]
17.4.4. Implementaciones conformes [lib.conforming]
18. Biblioteca de soporte de lenguaje [lib.language.support]
18.1. Tipos [lib.support.types]
18.2. Propiedades de la implementación [lib.support.limits]
18.2.1. Límites numéricos [lib.limits]
18.2.2. Biblioteca de C [lib.c.limits]
18.3. Inicio y terminación [lib.support.start.term]
18.4. Gestión de la memoria dinámica [lib.support.dynamic]
18.4.1. Asignación y cancelación de asignación de almacenamiento [lib.new.delete]
18.4.2. Errores de asignación de almacenamiento [lib.alloc.errors]
18.5. Identificación de tipos [lib.support.rtti]
18.5.1. Clase type_info [lib.type.info]
18.5.2. Clase bad_cast [lib.bad.cast]
18.5.3. Clase bad_typeid [lib.bad.typeid]
18.6. Control de excepciones [lib.support.exception]
18.6.1. Clase exception [lib.exception]
18.6.2. Infracción de las especificaciones-de-excepción [lib.exception.unexpected]
18.6.3. Terminación anormal [lib.exception.terminate]
18.6.4. uncaught_exception [lib.uncaught]
18.7. Otro soporte en tiempo de ejecución [lib.support.runtime]
19. Biblioteca de diagnóstico [lib.diagnostics]
19.1. Clases de excepción [lib.std.exceptions]
19.1.1. Clase logic_error [lib.logic.error]
19.1.2. Clase domain_error [lib.domain.error]
19.1.3. Clase invalid_argument [lib.invalid.argument]
19.1.4. Clase length_error [lib.length.error]
19.1.5. Clase out_of_range [lib.out.of.range]
19.1.6. Clase runtime_error [lib.runtime.error]
19.1.7. Clase range_error [lib.range.error]
19.1.8. Clase overflow_error [lib.overflow.error]
19.1.9. Clase underflow_error [lib.underflow.error]
19.2. Aserciones [lib.assertions]
19.3. Números de error [lib.errno]
20. Biblioteca de utilidades generales [lib.utilities]
20.1. Requisitos [lib.utility.requirements]
20.1.1. Comparación de igualdad [lib.equalitycomparable]
20.1.2. Comparación Menor que [lib.lessthancomparable]
20.1.3. Construcción de copias [lib.copyconstructible]
20.1.4. Construcción predeterminada [lib.default.con.req]
20.1.5. Requisitos del asignador [lib.allocator.requirements]
20.2. Componentes de utilidades [lib.utility]
20.2.1. Operadores [lib.operators]
20.2.2. Pares [lib.pairs]
20.3. Objetos de función [lib.function.objects]
20.3.1. Base [lib.base]
20.3.2. Operaciones aritméticas [lib.arithmetic.operations]
20.3.3. Comparaciones [lib.comparisons]
20.3.4. Operaciones lógicas [lib.logical.operations]
20.3.5. Negadores [lib.negators]
20.3.6. Enlazadores [lib.binders]
20.3.7. Adaptadores de punteros dirigidos a funciones [lib.function.pointer.adaptors]
20.3.8. Adaptadores de punteros dirigidos a miembros [lib.member.pointer.adaptors]
20.4. Memoria [lib.memory]
20.4.1. El asignador predeterminado [lib.default.allocator]
20.4.2. Iterador de almacenamiento sin procesar [lib.storage.iterator]
20.4.3. Búferes temporales [lib.temporary.buffer]
20.4.4. Algoritmos especializados [lib.specialized.algorithms]
20.4.5. Plantilla de clase auto_ptr [lib.auto.ptr]
20.4.6. Biblioteca C [lib.c.malloc]
20.5. Fecha y hora [lib.date.time]
21. Biblioteca de cadenas [lib.strings]
21.1. Rasgos de carácter [lib.char.traits]
21.1.1. Requisitos de los rasgos de carácter [lib.char.traits.require]
21.1.2. Definiciones de tipo de rasgos [lib.char.traits.typedefs]
21.1.3. Especializaciones de char_traits [lib.char.traits.specializations]
21.1.3.1. struct char_traits[lib.char.traits.specializations.char]
21.1.3.2. struct char_traits [lib.char.traits.specializations.wchar.t]
21.2. Clases de cadena [lib.string.classes]
21.3. Plantilla de clase basic_string [lib.basic.string]
21.3.1. Constructores basic_string [lib.string.cons]
21.3.2. Compatibilidad del iterador basic_string [lib.string.iterators]
21.3.3. Capacidad de basic_string [lib.string.capacity]
21.3.4. Acceso al elemento basic_string [lib.string.access]
21.3.5. Modificadores de basic_string [lib.string.modifiers]
21.3.6. Operaciones de cadena basic_string [lib.string.ops]
21.3.7. Funciones que no son miembro de basic_string [lib.string.nonmembers]
21.4. Utilidades de secuencia terminada en cero [lib.c.strings]22. Biblioteca de localización [lib.localization]
22.1. Configuraciones regionales [lib.locales]
22.1.1. Clase locale [lib.locale]
22.1.2. Globales de locale [lib.locale.global.templates]
22.1.3. Interfaces de conveniencia [lib.locale.convenience]
22.2. Categorías de locale estándar [lib.locale.categories]
22.2.1. La categoría ctype [lib.category.ctype]
22.2.2. La categoría numérica [lib.category.numeric]
22.2.3. El aspecto de puntuación numérica [lib.facet.numpunct]
22.2.4. La categoría de intercalación [lib.category.collate]
22.2.5. La categoría de tiempo [lib.category.time]
22.2.6. La categoría de moneda
22.2.7. La categoría de obtención de mensajes [lib.category.messages]
22.2.8. Aspectos que dependen del programa [lib.facets.examples]
22.3. Configuraciones regionales de la biblioteca C [lib.c.locales]
23. Biblioteca de contenedores [lib.containers]
23.1. Requisitos de contenedor [lib.container.requirements]
23.1.1. Secuencias [lib.sequence.reqmts]
23.1.2. Contenedores asociativos [lib.associative.reqmts]
23.2. Secuencias [lib.sequences]
23.2.1. Plantilla de clases deque [lib.deque]
23.2.2. Plantilla de clases list [lib.list]
23.2.3. Adaptadores de contenedor [lib.container.adaptors]
23.2.4. Plantilla de clases vector [lib.vector]
23.2.5. Clase vector [lib.vector.bool]
23.3. Contenedores asociativos [lib.associative]
23.3.1. Plantilla de clases map [lib.map]
23.3.2. Plantilla de clases multimap [lib.multimap]
23.3.3. Plantilla de clases set [lib.set]
23.3.4. Plantilla de clases multiset [lib.multiset]
23.3.5. Plantilla de clases bitset [lib.template.bitset]24. Biblioteca de iteradores [lib.iterators]
24.1. Requisitos de iterador [lib.iterator.requirements]
24.1.1. Iteradores de entrada [lib.input.iterators]
24.1.2. Iteradores de salida [lib.output.iterators]
24.1.3. Iteradores hacia delante [lib.forward.iterators]
24.1.4. Iteradores bidireccionales [lib.bidirectional.iterators]
24.1.5. Iteradores de acceso aleatorio [lib.random.access.iterators]
24.2. Sinopsis del encabezado [lib.iterator.synopsis]
24.3. Primitivas de iterador [lib.iterator.primitives]
24.3.1. Rasgos de iterador [lib.iterator.traits]
24.3.2. Iterador básico [lib.iterator.basic]
24.3.3. Etiquetas de iterador estándar [lib.std.iterator.tags]
24.3.4. Operaciones de iterador [lib.iterator.operations]
24.4. Iteradores predefinidos [lib.predef.iterators]
24.4.1. Iteradores inversos [lib.reverse.iterators]
24.4.2. Iteradores de inserción [lib.insert.iterators]
24.5. Iteradores de flujo [lib.stream.iterators]
24.5.1. Plantilla de clases istream_iterator [lib.istream.iterator]
24.5.2. Plantilla de clases ostream_iterator [lib.ostream.iterator]
24.5.3. Plantilla de clases istreambuf_iterator [lib.istreambuf.iterator]
24.5.4. Plantilla de clases ostreambuf_iterator [lib.ostreambuf.iterator]25. Biblioteca de algoritmos [lib.algorithms]
25.1. Operaciones de secuencia no modificadora [lib.alg.nonmodifying]
25.1.1. for_each [lib.alg.foreach]
25.1.2. find [lib.alg.find]
25.1.3. find_end [lib.alg.find.end]
25.1.4. find_first [lib.alg.find.first.of]
25.1.5. adjacent_find [lib.alg.adjacent.find]
25.1.6. count [lib.alg.count]
25.1.7. mismatch [lib.mismatch]
25.1.8. equal [lib.alg.equal]
25.1.9. search [lib.alg.search]
25.2. Operaciones de secuencia modificadora
25.2.1. copy [lib.alg.copy]
25.2.2. swap [lib.alg.swap]
25.2.3. transform [lib.alg.transform]
25.2.4. replace [lib.alg.replace]
25.2.5. fill [lib.alg.fill]
25.2.6. generate [lib.alg.generate]
25.2.7. remove [lib.alg.remove]
25.2.8. unique [lib.alg.unique]
25.2.9. reverse [lib.alg.reverse]
25.2.10. rotate [lib.alg.rotate]
25.2.11. random_shuffle [lib.alg.random.shuffle]
25.2.12. partitions [lib.alg.partitions]
25.3. Operaciones de ordenación y relacionadas [lib.alg.sorting]
25.3.1. Ordenación [lib.alg.sort]
25.3.2. nth_element [lib.alg.nth.element]
25.3.3. Búsqueda binaria [lib.alg.binary.search]
25.3.4. merge [lib.alg.merge]
25.3.5. Operaciones de definición en estructuras ordenadas [lib.alg.set.operations]
25.3.6. Operaciones de memoria dinámica [lib.alg.heap.operations]
25.3.7. Mínimo y máximo
25.3.8. Comparación lexicográfica [lib.alg.lex.comparison]
25.3.9. Generadores de permutación [lib.alg.permutation.generators]
25.4. Algoritmos de la biblioteca C [lib.alg.c.library]
26. Biblioteca numérica [lib.numerics]
26.1. Requisitos de tipo numérico [lib.numeric.requirements]
26.2. Números complejos [lib.complex.numbers]
26.2.1. Sinopsis del encabezado [lib.complex.synopsis]
26.2.2. Plantilla de clases complex [lib.complex]
26.2.3. Especializaciones de complex [lib.complex.special)
26.2.4. Funciones de miembro complex [lib.complex.members]
26.2.5. Operadores de miembro complex [lib.complex.member.ops]
26.2.6. Operaciones que no son de miembro complex[lib.complex.ops]
26.2.7. Operaciones del valor complex [lib.complex.value.ops]
26.2.8. Trascendentales de complex [lib.complex.transcendentals]
26.3. Matrices numéricas [lib.numarray]
26.3.1. Sinopsis del encabezado [lib.valarray.synopsis]
26.3.2. Plantilla de clases valarray [lib.template.valarray]
26.3.3. Operaciones que no son de miembro de valarray [lib.valarray.nonmembers]
26.3.4. Clase slice [lib.class.slice]
26.3.5. Plantilla de clases slice_array [lib.template.slice.array]
26.3.6. La clase gslice [lib.class.gslice]
26.3.7. Plantilla de clases gslice_array [lib.template.gslice.array]
26.3.8. Plantilla de clases mask_array [lib.template.mask.array]
26.3.9. Plantilla de clases indirect_array [lib.template.indirect.array]
26.4. Operaciones numéricas generalizadas [lib.numeric.ops]
26.4.1. accumulate [lib.accumulate]
26.4.2. inner_product [lib.inner.product]
26.4.3. partial_sum [lib.partial.sum]
26.4.4. adjacent_difference [lib.adjacent.difference]
26.5. Biblioteca de C [lib.c.math]27. Biblioteca de entrada y salida [lib.input.output]
27.1. Requisitos de iostreams [lib.iostreams.requirements]
27.1.1. Limitaciones implícitas [lib.iostream.limits.imbue]
27.1.2. Limitaciones de posicionamiento de tipo[lib.iostreams.limits.pos]
27.2. Declaraciones adelantadas [lib.iostream.forward]
27.3. Objetos de iostream estándar
27.3.1 Objetos de flujo estrecho [lib.narrow.stream.objects]
27.3.2. Objetos de flujo ancho [lib.wide.stream.objects]
27.4. Clases base de iostream
27.4.1. Tipos [lib.stream.types]
27.4.2. Clase ios_base [lib.ios.base]
27.4.3. Plantilla de clases fpos [lib.fpos]
27.4.4. Plantilla de clases basic_ios [lib.ios]
27.4.5. Manipuladores de ios_base [lib.std.ios.manip]
27.5. Búferes de flujo [lib.stream.buffers]
27.5.1. Requisitos de búfer de flujo [lib.streambuf.reqts]
27.5.2. Plantilla de clases basic_streambuf[lib.streambuf]
27.6. Formato y manipuladores [lib.iostream.format]
27.6.1. Flujos de entrada [lib.input.streams]
27.6.2. Flujos de salida [lib.output.streams]
27.6.3. Manipuladores estándar [lib.std.manip]
27.7. Flujos basados en cadena [lib.string.streams]
27.7.1. Plantilla de clases basic_stringbuf [lib.stringbuf]
27.7.2. Plantilla de clases basic_istringstream [lib.istringstream]
27.7.3. Clase basic_ostringstream [lib.ostringstream]
27.7.4. Plantilla de clases basic_stringstream [lib.stringstream]
27.7.5. Constructores de basicstringstream [lib.stringstream.cons]
27.7.6. Funciones miembro [lib.stringstream.members]
27.8. Flujos basados en archivo [lib.file.streams]
27.8.1. Flujos de archivo [lib.fstreams]
27.8.2. Archivos de la biblioteca de C [lib.c.files]Apéndice A [gram] (informativo). Resumen de la gramática
A.1. Palabras clave [gram.key]
A.2. Convenciones léxicas [gram.lex]
A.3. Conceptos básicos [gram.basic]
A.4. Expresiones [gram.expr]
A.5. Instrucciones [gram.stmt.stmt]
A.6. Declaraciones [gram.dcl.dcl]
A.7. Declaradores [gram.dcl.decl]
A.8. Clases [gram.class]
A.9. Clases derivadas [gram.class.derived]
A.10. Funciones miembro especiales [gram.special]
A.11. Sobrecarga [gram.over]
A.12. Plantillas [gram.temp]
A.13. Control de excepciones [gram.except]
A.14. Directivas de preprocesamiento [gram.cpp]
Apéndice B [limits] (informativo). Cantidades de implementación
Apéndice C [diff] (informativo). Compatibilidad
C.1. C++ e ISO C [diff.iso]
C.1.1. Cláusula 2: Convenciones léxicas
C.1.2. Cláusula 3: Conceptos básicos
C.1.3. Cláusula 5: Expresiones [diff.expr]
C.1.4. Cláusula 6: Instrucciones
C.1.5. Cláusula 7: Declaraciones
C.1.6. Cláusula 8: Declaradores
C.1.7. Cláusula 9: Clases
C.1.8. Cláusula 12: Funciones miembro especiales [diff.special]
C.1.9. Cláusula 16: Directivas de preprocesamiento [diff.cpp]
C.2. Biblioteca C Estándar [diff.library]
C.2.1. Modificaciones de encabezados [diff.mods.to.headers]
C.2.2. Modificaciones de definiciones [diff.mods.to.definitions]
C.2.3. Modificaciones de declaraciones [diff.mods.to.declarations]
C.2.4. Modificaciones de comportamiento [diff.mods.to.behavior]
Apéndice D [depr] (normativo). Funciones de compatibilidad
D.1. Operador de incremento con operando bool [depr.incr.bool]
D.2. Palabra clave static [depr.static]
D.3. Declaraciones de acceso [depr.access.dcl]
D.4. Conversión implícita de cadenas constantes [depr.string]
D.5. Encabezados de la biblioteca C Estándar [depr.c.headers]
D.6. Miembros de iostream anteriores [depr.ios.members]
D.7. Flujos de char* [depr.str.strstreams]
D.7.1. Clase strstreambuf [depr.str.strstreams]
D.7.2. Clase istrstream [depr.istrstream]
D.7.3. Clase ostrstream [depr.ostrstream]
D.7.4. Clase strstream [depr.strstream]
Apéndice E [extendid] (normativo). Nombres de caracteres universales
Índice alfabético
