Hispanopedia Wiki
Articulo de referencia

Módulos (C++)

Los módulos en C++ son una característica añadida en C++20 que implementa la programación modular como una alternativa moderna a los encabezados precompilados . [ 1 ] Un módulo ...

Hispanopedia WikiContenido en espanolLectura gratuita

Los módulos en C++ son una característica añadida en C++20 que implementa la programación modular como una alternativa moderna a los encabezados precompilados . [ 1 ] Un módulo en C++ comprende una única unidad de traducción . [ 2 ] Al igual que los archivos de encabezado y los archivos de implementación, un módulo puede contener declaraciones y definiciones, pero se diferencia de los encabezados precompilados en que no requieren la directiva del preprocesador #include, sino que se acceden mediante la palabra import. Un módulo debe declararse utilizando la palabra modulepara indicar que la unidad de traducción es un módulo. [ 1 ] Un módulo, una vez compilado, se almacena como un archivo de interfaz de módulo construido (BMI) que actúa de forma muy similar a un archivo .pch (encabezado precompilado). [ 3 ] Los símbolos y importlas s de los módulos se resuelven en la etapa de compilación, no en la etapa de enlace.

Los módulos suelen tener la extensión .cppm (principalmente común en las cadenas de herramientas Clang y GCC ), aunque algunas extensiones alternativas incluyen .ixx y .mxx (más comunes en las cadenas de herramientas Microsoft / MSVC ), [ 4 ] o incluso la extensión tradicional de C++ .cpp .

Aunque el lenguaje C estándar no tiene módulos, los dialectos de C permiten módulos, como Clang C. [ 5 ] Sin embargo, la sintaxis y la semántica de los módulos de Clang C difieren significativamente de los módulos de C++.

Historia

Antes de la concepción de los módulos, C++ se basaba en el sistema de archivos de cabecera y de código fuente. Existían cabeceras precompiladas que eran similares a los módulos como instantáneas de unidades de traducción más fáciles de analizar por el compilador y, por lo tanto, proporcionaban una compilación más rápida, [ 6 ] pero no tenían las mismas leyes de encapsulación que los módulos. Los módulos se propusieron por primera vez en 2012 para su inclusión en C++14 , [ 7 ] pero sufrieron extensas revisiones y un rediseño completo hasta que la forma moderna se integró en C++20 . [ 8 ]

Usos principales

Los módulos ofrecen las ventajas de los encabezados precompilados con una compilación más rápida que #includelos encabezados tradicionales, así como un procesamiento más rápido durante la fase de enlace. [ 9 ] [ 10 ] Esto se debe a que los módulos no son gestionados por el preprocesador de C durante el paso de preprocesamiento, sino directamente por el compilador durante la compilación. [ 11 ] Los módulos también reducen el código repetitivo al permitir que el código se implemente en un solo archivo, en lugar de estar separado entre un archivo de encabezado y la implementación fuente . La separación del "archivo de interfaz" y el "archivo de implementación" sigue siendo posible con los módulos, aunque estos proporcionan una encapsulación más limpia del código. [ 2 ] Sin embargo, separar la interfaz del código y la implementación fuente es necesario para beneficiarse de las compilaciones incrementales . Los módulos eliminan la necesidad de las directivas #include o #pragma once , ya que no modifican directamente el código fuente. A diferencia de los encabezados, los módulos no tienen que procesarse ni recompilarse varias veces. [ 9 ] Sin embargo, al igual que con los encabezados, cualquier cambio en un módulo requiere la recompilación no solo del módulo en sí, sino también de todas sus dependencias, y las dependencias de esas dependencias, etcétera. Al igual que los encabezados, los módulos no permiten dependencias circulares y no se compilarán. [ 12 ]

Tenga en cuenta que, actualmente, los archivos de interfaz de módulo compilado (BMI) difieren entre compiladores, no son portátiles y dependen en gran medida de la versión exacta del compilador, la arquitectura de destino y las opciones de compilación (por lo que se consideran más artefactos de compilación temporales que binarios distribuibles). [ 13 ] Por ejemplo, de los BMI de los principales compiladores de C++:

  • GCC utiliza .gcm (módulo compilado por GCC) [ 14 ]
  • Clang utiliza .pcm (módulo precompilado) [ 3 ]
  • MSVC utiliza .ifc (contenedor de archivos de interfaz) [ 15 ]

Un módulo se importa usando la palabra clave importseguida de un nombre de módulo, [ a ] ​​mientras que un módulo se declara con export moduleseguido del nombre. Una importinstrucción indica al compilador que cargue el archivo de interfaz de módulo construido (BMI) del módulo para resolver los símbolos utilizados. Todos los símbolos dentro de un módulo destinados a ser expuestos públicamente están marcados export, y la importación del módulo expone todos los símbolos exportados a la unidad de traducción. Si un módulo nunca se importa, nunca se cargará. [ 16 ] Los módulos pueden exportar símbolos con nombre, pero no macros que se consumen antes de la compilación. [ 17 ] Por lo tanto, los módulos evitan la fuga no deseada de macros entre unidades de traducción.

A diferencia de las inclusiones de encabezado, el orden de las declaraciones de importación no importa. [ 9 ] Un módulo puede permitir importaciones transitivas marcando una importación con , que reexporta el módulo importado a una unidad de traducción que importa el primer módulo. [ 1 ] Los módulos no imponen ninguna noción de espacios de nombres , aunque por convención, los módulos deben coincidir con los espacios de nombres y las rutas de los archivos fuente (por ejemplo, una clase con espacio de nombres como declarada en el módulo que reside en el archivo wikipedia/project/util/ConfigLoader.cppm , similar a la convención de Java). [ 1 ] Las declaraciones solo se aplicarán en las unidades de traducción si están marcadas explícitamente , lo que hace mucho menos probable que el uso de una declaración para traer símbolos al espacio de nombres global cause conflictos de nombres entre las unidades de traducción del módulo. Esto resuelve la contaminación de declaraciones en los encabezados, que debido a la inclusión textual del encabezado por una directiva, siempre resultará en declaraciones que agregan símbolos al ámbito, incluso si no es intencional.exportimportwikipedia::project::util::ConfigLoaderwikipedia.project.util.ConfigLoaderusingexportusingusing#includeusing

La palabra clave exportse introdujo por primera vez en C++03 cuando se añadieron las " plantillas exportadas " a C++. [ 18 ] Posteriormente se eliminaron en C++11 , debido a que muy pocos compiladores realmente admitían la característica. [ 19 ] El único compilador conocido que admitía plantillas exportadas era Comeau C/C++ .

Módulos de biblioteca estándar

C++20 especifica la introducción de unidades de cabecera de la biblioteca estándar de C++ [ 20 ] , y C++23 añade soporte completo para módulos en la biblioteca estándar [ 21 ] (sin embargo, los módulos están disponibles informalmente en la mayoría de las implementaciones de C++20 [ 22 ] ). Actualmente, a través de módulos, la biblioteca estándar debe importarse en su totalidad (usando ). [ 23 ] Los estándares de C++ ofrecen dos módulos de biblioteca estándar:importstd;

Los nombres de los módulos stdy std.*están reservados por el estándar C++, por lo que declarar un módulo cuyo nombre coincida con cualquiera de estos patrones generará una advertencia del compilador. [ 24 ] Sin embargo, la mayoría de los compiladores ofrecen una opción para omitir o suprimir dicha advertencia (por ejemplo, -Wno-reserved-module-identifieren Clang y GCC). [ 3 ]

Soporte de herramientas

Actualmente, solo GCC , Clang y MSVC ofrecen soporte para módulos y . [ 25 ] El servidor de lenguaje Clangd admite módulos.importstd;

La compatibilidad con los sistemas de compilación varía. CMake , MSBuild , XMake, Meson y Build2 ofrecen compatibilidad total con módulos. Los sistemas de compilación generados, como Make y Ninja, también son compatibles con módulos. Sin embargo, Gradle para C++ y Bazel aún no son compatibles con módulos. Actualmente, Qt moc no reconoce módulos en su preprocesador. [ 26 ]

Ejemplo

Un ejemplo sencillo de uso de módulos es el siguiente:

MiClase.cppm

exportar módulo wikipedia . proyecto . Persona ;importar std ;usando std :: string ;exportar espacio de nombres wikipedia :: proyecto {clase Persona { privado : cadena nombre ; entero edad ; público : Persona ( cadena nombre , entero edad ) : nombre { std :: move ( nombre ) }, edad { edad } {}string getName () const { return name ; }void setName ( string name ) { this -> name = std :: move ( val ); }int getAge () const noexcept { return age ; }void setAge ( int age ) noexcept { this -> age = age ; }; };}

Main.cpp

importar std ;importar wikipedia.proyecto.Persona ;​​​​usando wikipedia :: proyecto :: Persona ;int main ( int argc , char * argv []) { Person me ( "John Doe" , 10 ); me.setAge ( 15 ) ; std :: println ( " ¡Hola, {0}! {0} tiene {1} años.", me.getName(), me.getAge ( ) ) ; // imprime " ¡ Hola , John Doe! John Doe tiene 15 años." }

Unidades de cabecera

Los encabezados también pueden ser importimportados, incluso si no están declarados como módulos. Los encabezados importados se llaman "unidades de encabezado" y están diseñados para permitir que las bases de código existentes migren de encabezados a módulos de manera más gradual. [ 27 ] [ 28 ] La sintaxis es similar a la inclusión de un encabezado, con la diferencia de que #includese reemplaza con import. Como importlas declaraciones no son directivas del preprocesador sino más bien declaraciones del lenguaje leído por el compilador, [ 11 ] deben terminar con un punto y coma. Las unidades de encabezado exportan automáticamente todos los símbolos y se diferencian de los módulos propiamente dichos en que permiten la emisión de macros, lo que significa que todas las unidades de traducción que importan la unidad de encabezado obtendrán sus macros contenidas. Esto ofrece una ruptura mínima entre la migración a módulos. [ 9 ] La semántica de búsqueda del archivo dependiendo de si se usan comillas o corchetes angulares también se aplica aquí. Por ejemplo, se puede escribir para importar el encabezado o para importar el archivo como una unidad de encabezado. [ 1 ] La mayoría de los sistemas de compilación, como CMake , solo tienen soporte experimental para esto. [ 29 ] [ 30 ]import<string>;<string>import"MyHeader.h";"MyHeader.h"

Al igual que en las sentencias de Goimport , las importaciones de unidades de cabecera van seguidas de una representación literal de cadena sin procesar de la ruta. Sin embargo, no se puede escribir una cadena literal en tiempo de compilación e importarla esperando que se interprete como una ruta.

Anatomía

Particiones y jerarquía de módulos

Los módulos pueden tener particiones, que separan la implementación del módulo en varios archivos. [ 1 ] Las particiones de módulo se declaran usando la sintaxis A:B, lo que significa que el módulo Atiene la partición B. Las particiones de módulo no se pueden importar individualmente fuera del módulo que posee la partición misma, lo que significa que cualquier unidad de traducción que requiera código ubicado en una partición de módulo debe importar todo el módulo que posee la partición. [ 1 ]

La partición del módulo Bse vincula al módulo propietario Acon la instrucción en el archivo que contiene la declaración del módulo o cualquier otra partición del módulo (por ejemplo, ), que se resuelve implícitamente en , porque el módulo se llama . [ 3 ] Estas instrucciones de importación pueden ser exportadas por el módulo propietario, incluso si la partición en sí no se puede importar directamente, y por lo tanto, la importación de código de una partición se realiza simplemente importando todo el módulo. [ 1 ]import:B;AAA:C:BA:BA

Si un módulo se divide entre interfaz e implementación, su unidad de traducción comprende tanto la interfaz como la implementación. Del mismo modo, si un módulo tiene particiones, su unidad de traducción también abarca todos esos módulos.

Aparte de las particiones, los módulos no tienen un sistema jerárquico ni "submódulos", sino que normalmente utilizan una convención de nomenclatura jerárquica, similar a los paquetes de Java . [ b ] Solo pueden aparecer caracteres alfanuméricos, el guion bajo y el punto en el nombre de un módulo. [ 31 ] En C++, el nombre de un módulo no está vinculado al nombre de su archivo ni a la ubicación del módulo, a diferencia de Java, [ 32 ] y el paquete al que pertenece debe coincidir con la ruta en la que se encuentra. [ 33 ] Por ejemplo, los módulos Ay A.Ben teoría son módulos disjuntos y no necesariamente tienen que tener ninguna relación, sin embargo, el uso de un esquema de nomenclatura con puntos en el nombre del módulo se utiliza para sugerir que el módulo A.Bestá relacionado o asociado de alguna otra manera con el módulo A. [ 1 ]

El esquema de nombres de un módulo C++ está diseñado para permitir que se sugiera una jerarquía, y el estándar C++ recomienda reexportar "submódulos" que pertenecen a la misma API pública (es decir, el módulo alpha.beta.gammadebe ser reexportado por alpha.beta, etc.), aunque los puntos en los nombres de los módulos no imponen ninguna jerarquía. El estándar C++ recomienda nombres de módulos ASCII en minúsculas (sin guiones ni guiones bajos), aunque técnicamente no hay ninguna restricción en dichos nombres. [ 34 ] Además, debido a que los módulos no se pueden volver a aliasar ni renombrar (a menos que se vuelvan a exportar todos los símbolos en otro módulo), los nombres de los módulos pueden tener prefijos con nombres de organizaciones y proyectos tanto para mayor claridad como para evitar conflictos de nombres (es decir, google.abseilen lugar de abseil). [ 34 ] Además, a diferencia de Java, cuyos paquetes pueden incluir normalmente un dominio de nivel superior (TLD) adicional delante para evitar conflictos de espacio de nombres, los módulos C++ no necesitan tener esta convención (por ejemplo, tanto org.wikipedia.project.myfunctionality.MyModulecomo wikipedia.project.myfunctionality.MyModuleson convenciones igualmente válidas).

Si se exportan símbolos dentro de un espacio de nombres, el espacio de nombres en sí se exporta implícitamente, pero solo los símbolos que se exportan explícitamente dentro de él.

exportar módulo wikipedia.mymodule ;​​espacio de nombres wikipedia :: mimódulo { // no exportado int secretFunction ();// exportado con espacio de nombres export int publicFunction1 (); export long publicFunction2 (); }

Si un módulo exporta una función cuyo tipo de retorno o que tiene como tipo de parámetro un tipo no exportado, el módulo está mal informado a menos que sea un puntero.

exportar módulo wikipedia.mymodule ;​​espacio de nombres wikipedia :: mimódulo { // tipo no exportado clase Oculto { // ... };export Hidden * someFunction ( Hidden * h ); }

El código del cliente no puede llamar a métodos, acceder a datos ni destruir el objeto. Además, la información de tipo en tiempo de ejecución (RTTI) no puede inspeccionar el tipo, pero la reflexión sí, ya que se realiza en tiempo de compilación .

Enlace de módulos

La vinculación de módulos permite compartir símbolos entre diferentes unidades de traducción, pero solo si pertenecen al mismo módulo. Se puede acceder a dichos símbolos desde cualquier archivo que forme parte del módulo, pero no desde el código que importa ese módulo, a menos que se declare explícitamente export.

Alcance del módulo y fragmento del módulo global

En el ejemplo anterior, todo lo que está por encima de la línea en el archivo Person.cppm se denomina lo que está "fuera del ámbito del módulo", es decir, lo que está fuera del alcance del módulo. [ 1 ] Normalmente, todos los se colocan fuera del ámbito del módulo entre la instrucción y la declaración de , de la siguiente manera:exportmodulewikipedia.project.Person;#includemodule;export module

módulo ; // Opcional; marca el comienzo del fragmento del módulo global (obligatorio si se invoca una directiva include por encima de la declaración del módulo de exportación)// Los encabezados se incluyen fuera del ámbito del módulo, antes de que se declare el módulo #include <print> #include "MyHeader.h"export module wikipedia . project . MyModule ; // Obligatorio; marca el comienzo del preámbulo del módulo// Las importaciones de módulos con nombre y unidades de encabezado vienen después de la declaración del módulo // Las declaraciones de importación se colocan inmediatamente después de la declaración del módulo y no aparecen después de ninguna declaración de código o símbolo // En unidades de traducción que no son módulos, las directivas #include preceden a las declaraciones de importación import std ; import < string > ; import wikipedia . project . util . UtilitySymbols ; import "Foo.h" ; import < thirdlib / features / Feature . h > ;// Código aquí...módulo : privado ; // Opcional; marca el comienzo del fragmento del módulo privado

Todo el código que no pertenece a ningún módulo existe en el llamado "módulo sin nombre" (también conocido como fragmento de módulo global) y, por lo tanto, no puede ser importado por ningún módulo. [ 1 ]

El punto de entrada puede adjuntarse al módulo global a partir de C++26 marcándolo . Esto se utiliza para permitir pruebas unitarias de entidades no exportadas en un módulo. [ 35 ]main()extern"C++"

Muchas bibliotecas que solo contienen encabezados pueden portarse fácilmente a módulos a través de un encabezado, que adjunta automáticamente los símbolos al módulo global, lo que permite adjuntar símbolos que de otro modo se declararían con enlace interno :exportextern"C++"

exportar módulo wikipedia.ejemplos.mylib ;​​​​export extern "C++" { // Fuerza a que el contenido del encabezado tenga una conexión de módulo global cuando se exporta #include <wikipedia/examples/MyLib.hpp> }

Fragmento de módulo privado

Un módulo puede declarar un "fragmento de módulo privado" escribiendo , en el cual todas las declaraciones o definiciones posteriores a la línea son visibles solo desde dentro del archivo y no pueden ser accedidas por las unidades de traducción que importan ese módulo. [ 3 ] Cualquier unidad de módulo que contenga un fragmento de módulo privado debe ser la única unidad de módulo de su módulo. [ 1 ]module:private;

Compatibilidad con bibliotecas de terceros

Como los módulos son una adición reciente y los proveedores de compiladores fueron notablemente lentos en desarrollar soporte para módulos, la mayoría de las bibliotecas de terceros todavía se ofrecen solo como encabezados. Sin embargo, algunas bibliotecas populares han implementado soporte para módulos. Estas incluyen {fmt} (una biblioteca de formato e impresión, como fmt), nlohmann-json (una biblioteca JSON, como nlohmann.json), POCO C++ Libraries (una biblioteca C++ de propósito general, como Poco) y varias bibliotecas de Boost C++ Libraries (una biblioteca C++ de propósito general, como boost.*). [ 36 ] En mayo de 2026, Microsoft lanzó soporte para módulos para C++/WinRT , con un módulo por espacio de nombres (como winrt.*). [ 37 ]

Módulos C de Clang

Una característica similar, aunque no relacionada, son los módulos C de Clang. Clang ofrece soporte para módulos no estándar en C , sin embargo, la semántica difiere significativamente de la de los módulos C++. Los módulos C de Clang existen esencialmente por la misma razón que los módulos C++: [ 5 ]

  • Para garantizar que las unidades de traducción se compilen solo una vez.
  • Para garantizar que las unidades de traducción se incluyan solo una vez.
  • Para evitar la fuga de macros no deseadas
  • Para garantizar límites claros de una biblioteca (es decir, especificar qué archivos de cabecera pertenecen a qué biblioteca).
  • Para controlar explícitamente qué símbolos se exportan

Los módulos de C no introducen espacios de nombres en los símbolos. En su lugar, utilizan un archivo llamado module.modulemap para definir los módulos, de forma similar a como Xcode ofrece interoperabilidad entre Objective-C y Swift . Por ejemplo, el mapa de módulos de la biblioteca estándar de C podría tener un aspecto similar a este:

módulo std [ sistema ] [ extern_c ] { módulo assert { encabezado textual "assert.h" encabezado "bits/assert-decls.h" exportar * }módulo complejo { encabezado "complex.h" exportar * }módulo ctype { encabezado "ctype.h" exportar * }módulo errno { encabezado "errno.h" encabezado "sys/errno.h" exportar * }módulo fenv { encabezado "fenv.h" exportar * }// ...siguen más encabezados... }

Esto permite importar bibliotecas C de la siguiente manera:

import std.io ;​​int main ( int argc , char * argv []) { if ( argc > 1 ) { printf ( "Hola, %s! \n " , argv [ 1 ]); } else { printf ( "Hola, mundo! \n " ); } return 0 ; }

Los módulos Clang C también se pueden usar en C++, aunque esto es menos portable ya que no solo son una característica no estándar, sino que también entran en conflicto con el sistema de módulos existente en C++. Por ejemplo, el stdmódulo mostrado anteriormente se puede extender a C++ usando una requiresdeclaración:

módulo std { // Biblioteca estándar de C...módulo vector { requiere el encabezado cplusplus "vector" }módulo type_traits { requiere cplusplus11 encabezado "type_traits" }// más encabezados... }

Véase también

Notas

  1. ↑ Laimportpalabra clave en C++ difiere en significado que en otros lenguajes. Por ejemplo,importen Java es en realidad análogo ausingen C++ y no a C++import. En el primero, una importación simplemente crea un alias del tipo o descalifica un espacio de nombres, porque Java carga los archivos .class dinámicamente según sea necesario, haciendo que todos los tipos estén disponibles simplemente calificando completamente todos los espacios de nombres (en lugar de tener que declarar explícitamente los módulos accesibles). Sin embargo, en C++ los módulos no se cargan automáticamente, y por lo tanto deben "importarse" manualmente para que sean accesibles, ya queindica que la unidad de traducción debe acceder al código en el módulo importado. Por lo tanto, probablemente sea más apropiado compararen C++ conen lenguajes como Swift y Haskell , donde importar un módulo es estrictamente necesario para usar símbolos dentro de él.importimportimport
  2. ↑ Es más apropiado comparar paquetes en Java y módulos en C++, en lugar de módulos en Java y módulos en C++. Los módulos en C++ y Java difieren en su significado. En Java, un módulo (gestionado por el Sistema de Módulos de la Plataforma Java ) se utiliza para agrupar varios paquetes, mientras que en C++ un módulo es, estrictamente hablando, una unidad de traducción.

Referencias

  1. 1 2 3 4 5 6 7 8 9 10 11 12 cppreference.com (2025). "Módulos (desde C++20)" . cppreference.com . cppreference . Consultado el 20 de febrero de 2025 .
  2. 1 2 Szalay, R.; Porkoláb, Z. (2025). "Refactoring to Standard C++20 Modules" . Journal of Software: Evolution and Process . 37 (e2736). doi : 10.1002/smr.2736 . hdl : 10831/113355 . Recuperado el 28 de julio de 2025 .
  3. 1 2 3 4 5 Proyecto LLVM. "Módulos C++ estándar" . clang.llvm.org . Proyecto LLVM . Consultado el 3 de diciembre de 2025 .
  4. ↑ Microsoft Corporation (24 de abril de 2023). "Descripción general de los módulos en C++" . learn.microsoft.org . Microsoft Learn.
  5. 1 2 Proyecto LLVM. "Módulos" . clang.llvm.org . Proyecto LLVM . Consultado el 3 de diciembre de 2025 .
  6. ↑ Microsoft Corporation (2015). "Creación de archivos de encabezado precompilados" . MSDN . Microsoft Corporation. Archivado del original el 28 de marzo de 2018. Consultado el 28 de marzo de 2018 .
  7. ^ Daveed Vandevoorde (11 de enero de 2012). "N3347=12-0037: Módulos en C++ (Revisión 6)" (PDF) . open-std.org . ISO/CEI JTC1/SC22/WG21 . Consultado el 28 de julio de 2025 .
  8. ↑ Richard Smith (22 de febrero de 2019). "P1103R3: Fusionar módulos" (PDF) . open-std.org . ISO/IEC JTC1/SC22/WG21 . Consultado el 28 de julio de 2025 .
  9. 1 2 3 4 Microsoft Corporation (12 de febrero de 2022). "Comparar unidades de encabezado, módulos y encabezados precompilados" . learn.microsoft.org . Microsoft Learn.
  10. ↑ Paul Krill (2 de junio de 2022). "C++ 23 introducirá soporte para módulos" . infoworld.com . InfoWorld.
  11. 1 2 Michael Spencer (2024-03-21). "P3034R1: Las declaraciones de módulos no deberían ser macros" . open-std.org . ISO/IEC JTC1/SC22/WG21 . Recuperado el 2025-07-28 .
  12. ↑ ISO/IEC 14882:2020. Lenguajes de programación – C++ (3.ª ed.). Organización Internacional de Normalización. §9.3, «Unidades de interfaz de módulo y reglas de importación/exportación» y §16.3, «Dependencias de módulo».
  13. ↑ Daniel Ruoso (12 de octubre de 2022). "Especificación de la interoperabilidad de los archivos de interfaz de módulos compilados" (PDF) . open-std.org . WG21.
  14. ↑ Colección de compiladores GNU. "Interfaz de módulo compilado 3.23.3" . gcc.gnu.org . Proyecto GNU . Consultado el 18 de abril de 2026 .
  15. ↑ Microsoft Learn (22 de noviembre de 2022). "/ifcOutput" . learn.microsoft.com . Microsoft Learn.
  16. ↑ ISO/IEC 14882:2020. Lenguajes de programación – C++ (3.ª ed.). Organización Internacional de Normalización. §9.3, «Unidades de interfaz de módulo y reglas de importación/exportación» y §16.2, «Semántica de importación de módulos».
  17. ↑ Alisdair Meredith (2022-08-08). "DxxxxR0: Módulos y macros" . isocpp.org . ISO C++ . Consultado el 28 de julio de 2025 .
  18. ↑ cppreference.com. "Plantilla de clase" . cppreference.com . Consultado el 7 de octubre de 2025 .
  19. ↑ Herb Sutter (3 de marzo de 2003). "Por qué no podemos permitirnos exportar" (PDF) . open-std.org . WG 21.
  20. ↑ Richard Smith (18 de julio de 2019). "Unidades de cabecera de la biblioteca estándar para C++20" . open-std.org . WG21.
  21. ↑ Stephan T. Lavavej, Gabriel Dos Reis, Bjarne Stroustrup, Jonathan Wakely (11 de marzo de 2022). "Módulos de la biblioteca estándar std y std.compat" (PDF) . open-std.org . WG21.{{cite web}}: CS1 maint: varios nombres: lista de autores ( enlace )
  22. ↑ Stephan T. Lavavej (24 de febrero de 2021). "Unidades y módulos de cabecera de la biblioteca estándar: seguimiento del problema n.º 1694" . github.com . Microsoft Corporation.
  23. ↑ cppreference.com. "Biblioteca estándar - Importación de módulos" . cppreference.com . cppreference . Consultado el 3 de diciembre de 2025 .
  24. ↑ cppreference.com (2025). "Biblioteca estándar de C++" . cppreference.com . cppreference . Consultado el 20 de febrero de 2025 .
  25. ↑ cppreference.com. "Soporte del compilador para C++20" . cppreference.com . cppreference . Consultado el 3 de diciembre de 2025 .
  26. ↑ Elias Stuerer. "¿Ya somos módulos?: Soporte de herramientas" . arewemodulesyet.org . arewemodulesyet . Consultado el 3 de diciembre de 2025 .
  27. ↑ Microsoft Corporation (12 de abril de 2022). "Tutorial: Crear e importar unidades de encabezado en Microsoft Visual C++" . Microsoft Learn.
  28. ↑ Proyecto LLVM. "Módulos C++ estándar - Unidades de cabecera" . clang.llvm.org . Proyecto LLVM.
  29. ↑ CppNow (26-07-2023). Los desafíos de implementar unidades de encabezado de C++: módulos de C++ - Daniel Ruoso - CppNow 2023. youtube.com . YouTube . Consultado el 28-07-2025 .
  30. ↑ "CXX_MODULE_HEADER_UNIT_SETS" . cmake.org . Kitware . Consultado el 31 de octubre de 2025 .
  31. ↑ ISO/IEC 14882:2020. Lenguajes de programación – C++ (3.ª ed.). Organización Internacional de Normalización. §9.2, «Unidades de interfaz de módulo y reglas de importación/exportación».
  32. ↑ Oracle Corporation. "Creación de un paquete" . docs.oracle.com . Oracle Corporation . Consultado el 3 de diciembre de 2025 .
  33. ↑ Oracle Corporation. "Administración de archivos fuente y de clase" . docs.oracle.com . Oracle Corporation . Consultado el 3 de diciembre de 2025 .
  34. 1 2 Corentin Jabot (16 de junio de 2019). "Directrices para nombrar módulos" . isocpp.org . ISO C++ . Consultado el 3 de diciembre de 2025 .
  35. ↑ Michael Spencer (10 de febrero de 2025). "Permitir adjuntar main al módulo global" . open-std.org . WG21.
  36. ↑ Elias Steurer. "¿Ya somos módulos?" . arewemodulesyet.org . arewemodulesyet . Consultado el 3 de diciembre de 2025 .
  37. ↑ "Paquete C++/WinRT" . NuGet . Microsoft . Consultado el 15 de junio de 2025 .