Borrador de módulos C ++ (Especificación técnica posterior a C ++ 17)
WG21 ha publicado un borrador y varias revisiones actualizadas de la especificación del módulo C / C ++ en open-std.org. Solo vincularé los documentos más recientes aquí:
- Borrador de trabajo, Extensiones a C ++ para los módulos N4610 (octubre de 2016).
- Cuarta revisión publicada como P0142R0 (marzo de 2016).
- Redacción de los módulos publicados como P0143R2 (marzo de 2016).
- El equipo de clang ha publicado una segunda revisión de sus cambios: P0273R1 (octubre de 2016).
Las siguientes publicaciones del blog contienen un resumen de las reuniones de estándares y, en particular, un resumen del estado actual del borrador de los módulos:
Actualización: como se explicó en el informe de viaje de Kona al que me vinculé anteriormente, actualmente hay dos propuestas en competencia, una de Microsoft y otra de Clang. La solución propuesta por Microsoft no permite exportar macros, mientras que la solución del equipo de Clang admitiría la exportación de macros. Hasta ahora, solo Microsoft ha presentado formalmente un borrador para una especificación de módulo.
Especificación del módulo propuesto por Microsoft
A continuación, se ofrece una descripción general rápida de los conceptos más importantes que contiene esta propuesta. Como es un borrador, esto posiblemente aún podría cambiar. El nuevo estándar de módulos consistirá, entre otras cosas, en lo siguiente:
Una modulepalabra clave para declarar un módulo, varios archivos pueden declarar esto para construir un módulo (pero para cada módulo solo una unidad de compilación puede contener una export {}sección):
module M;
También podría decidirse utilizar una importpalabra clave para importar módulos, en lugar de importella using module, por lo que podría evitarse una nueva palabra clave de importación.
import std.io;
import module.submodule;
Una exportsintaxis, que define las declaraciones públicas que forman parte de este módulo, las declaraciones que no son de interfaz que no deben exportarse como parte del módulo se definirán fuera del bloque de exportación. Las declaraciones pueden ser cualquier tipo de declaración en C / C ++, es decir, no solo funciones sino también variables, estructuras, plantillas, espacios de nombres y clases:
export {
int f(int);
double g(double, int);
int foo;
namespace Calc {
int add(int a, int b);
}
}
void not_exported_function(char* foo);
Un cambio importante de módulos será que las macros y las definiciones de preprocesador serán locales para los módulos y no se exportarán. Por tanto, las macros no tienen ningún impacto en los módulos importados:
#define FILE "my/file"
import std.io; //will not be impacted by the above definition
Es importante señalar que tanto el sistema de preprocesador actual como los módulos podrán coexistir y los encabezados aún se pueden usar, por ejemplo, para incluir macros.
Para obtener información más detallada, sugiero leer el borrador.
Módulos Clang
Clang ha estado trabajando en una implementación de módulos que se puede encontrar en la página de módulos de clang . Sin embargo, clang actualmente no implementa una sintaxis concreta para los módulos, es decir, Clang no ha implementado ninguna de las sintaxis mencionadas anteriormente. Para explicar esto, la página contiene la siguiente declaración:
En la actualidad, no existe una sintaxis C o C ++ para las declaraciones de importación. Clang hará un seguimiento de la propuesta de módulos en el comité de C ++. Consulte la sección Incluye como importaciones para ver cómo se importan los módulos hoy.
La parte principal que actualmente implementa Clang es el "Lenguaje de mapa de módulo" que permite escribir mapas de módulo para código existente que todavía usa archivos de encabezado.
Exportaciones de macros de módulos
Como se mencionó anteriormente, aún no está claro si las exportaciones macro serán parte de los módulos TS finales . En P0273R1 se propuso la siguiente sintaxis para la exportación de macros:
#export define MAX(A,B) ((A) > (B)) ? (A) : (B);
Clang es el primer compilador que comienza a trabajar en módulos incluso antes de que se complete la estandarización. Todavía no hay mucha documentación, pero se puede encontrar un código de ejemplo aquí:
http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Modules/
Algunos comentarios de Douglas Gregor (el desarrollador que los implementó):
http://clang-developers.42468.n3.nabble.com/C-modules-td3619936.html
En teoría, puede definir un montón de macros auxiliares como begin_module, end_module, import_module para protegerse de cualquier cambio probable en la sintaxis que vendrá en el futuro.
EDICIÓN 1:
Douglas Gregor ha publicado una presentación sobre su implementación:
http://llvm.org/devmtg/2012-11/Gregor-Modules.pdf?=submit
EDIT 2:
El soporte del módulo en clang se ha documentado aquí:
http://clang.llvm.org/docs/Modules.html
EDICIÓN 3: Los
módulos ahora también son compatibles con el compilador C ++ de Microsoft: http://blogs.msdn.com/b/vcblog/archive/2015/12/03/c-modules-in-vs-2015-update-1. aspx
fuente
fuente