10 Modules [module]

10.5 Private module fragment [module.private.frag]

private-module-fragment:
	module-keyword : private ; declaration-seq $_{o p t}$

A private-module-fragment shall appear only in a primary module interface unit ([module.unit]).

A module unit with a private-module-fragment shall be the only module unit of its module; no diagnostic is required.

[ Note

A private-module-fragment ends the portion of the module interface unit that can affect the behavior of other translation units.

A private-module-fragment allows a module to be represented as a single translation unit without making all of the contents of the module reachable to importers.

The presence of a private-module-fragment affects:

(2.1)
the point by which the definition of an exported inline function is required ([dcl.inline]),
(2.2)
the point by which the definition of an exported function with a placeholder return type is required ([dcl.spec.auto]),
(2.3)
whether a declaration is required not to be an exposure ([basic.link]),
(2.4)
where definitions for inline functions and templates must appear ([basic.def.odr], [dcl.inline], [temp.pre]),
(2.5)
the instantiation contexts of templates instantiated before it ([module.context]), and
(2.6)
the reachability of declarations within it ([module.reach]).

— end note

]

[ Example

export module A;
export inline void fn_e();      // error: exported inline function fn_e not defined
                                // before private module fragment
inline void fn_m();             // OK, module-linkage inline function
static void fn_s();
export struct X;
export void g(X *x) {
  fn_s();                       // OK, call to static function in same translation unit
  fn_m();                       // OK, call to module-linkage inline function
}
export X *factory();            // OK

module :private;
struct X {};                    // definition not reachable from importers of A
X *factory() {
  return new X ();
}
void fn_e() {}
void fn_m() {}
void fn_s() {}

— end example

]