C++ Modules – why were they removed from C++0x? Will they be back later on?

by

C++ Modules draft (Technical Specification after C++17)

A draft and several updated revisions for the C/C++ module specification have been published by WG21 on open-std.org. I will link only to the latest documents here:

  • Working Draft, Extensions to C++ for Modules N4610 (October 2016).
  • Fourth revision published as P0142R0 (March 2016).
  • Wording for Modules published as P0143R2 (March 2016).
  • The clang team has published a second revision of their changes: P0273R1 (October 2016).

The following blog posts contain a summary of the standards meetings and in particular a summary of the current status of the modules draft:

Update: As explained in the Kona trip report that I linked to above, there are currently two competing proposals, one from Microsoft and one from Clang. The proposed solution from Microsoft does not allow to export Macros, while the solution from the Clang team would support exporting Macros. So far only Microsoft has formally submitted a draft for a module specification.

Module specification as proposed by Microsoft

Here is a quick overview of the most important concepts that this proposal contains. As its a draft this might possibly still change. The new modules standard will among other things consist of the following:

A module keyword to declare a module, multiple files can declare this to build one module (but for each module only one compilation-unit can contain an export {} section):

module M;

An import keyword to import modules, instead of import it might also be decided to use using module instead, so a new import keyword could be avoided.

import std.io;
import module.submodule;

An export syntax, which defines the public declarations that are part of this module, non-interface declarations that should not be exported as part of the module will be defined outside the export block. Declarations can be any kind of declaration in C/C++, that is, not only functions but also variables, structs, templates, namespaces and classes:

export {
    int f(int);
    double g(double, int);

    int foo;

    namespace Calc {
         int add(int a, int b);
    }        
}

void not_exported_function(char* foo);

An important change of modules will be that macros and preprocessor definitions will be local to modules and will not be exported. Thus macros do not have any impact on imported modules:

#define FILE "my/file"
import std.io;   //will not be impacted by the above definition

Its important note that the both the current preprocessor system and modules will be able to co-exist and headers can still be used for example to include macros.

For more detailed information I suggest to read the draft.

Clang Modules

Clang has been working on a modules implementation which can be found at the clang modules page. However clang does currently not implement a concrete syntax for modules, that is, none of the above mentioned syntax has been implemented by Clang. To explain this the page contains the following statement:

At present, there is no C or C++ syntax for import declarations. Clang will track the modules proposal
in the C++ committee. See the section Includes as imports to see how modules get imported today.

The main part that is currently implemented by Clang is the “Module Map Language” which allows write module maps for existing code that still uses header files.

Macro Exports from Modules

As mentioned above it is still unclear if macro exports will be part of the final Modules TS. In P0273R1 the following syntax was proposed for the export of macros:

#export define MAX(A,B) ((A) > (B)) ? (A) : (B);

More Related Contents:

  1. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  2. Deprecation of the static keyword… no more?
  3. Computing length of a C string at compile time. Is this really a constexpr?
  4. What are declarations and declarators and how are their types interpreted by the standard?
  5. Can we apply content not explicitly cited from the normative references to the C++ standard?
  6. ISO C++ standard draft
  7. Does the C++ standard specify anything on the representation of floating point numbers?
  8. C++ Need help for a homework program that reads in a list of doubles from a file and add a string to each double
  9. C++ lambda with captures as a function pointer
  10. using extern template (C++11)
  11. Will std::string always be null-terminated in C++11?
  12. SFINAE working in return type but not as template parameter
  13. Error “undefined reference to ‘std::cout'”
  14. When to use the brace-enclosed initializer?
  15. Allow for Range-Based For with enum classes?
  16. How to reverse the order of arguments of a variadic template function?
  17. Template specialization and enable_if problems [duplicate]
  18. Initializer-list-constructing a vector of noncopyable (but movable) objects
  19. A class name introduced inside a class is not treated as a nested class name
  20. Why is locking a std::mutex twice ‘Undefined Behaviour’?
  21. In C++, is it still bad practice to return a vector from a function?
  22. Different ways of initializing an object in c++
  23. C++11: Number of Variadic Template Function Parameters?
  24. How to make a variadic is_same?
  25. What is the reason behind cbegin/cend?
  26. Understanding gsl::narrow implementation
  27. How to determine programmatically if an expression is rvalue or lvalue in C++?
  28. GCC std::thread not found in namespace std
  29. using extern template (C++11) to avoid instantiation
  30. narrowing conversion from unsigned to double

Leave a Comment