Namespaces (namespace) are intended for organizing code to avoid name conflicts (especially in large projects and libraries). Regular namespaces allow grouping of classes, functions, variables, etc.
Anonymous namespaces (namespace { ... }) are used to restrict visibility within a single file — everything declared in them is not visible outside the file. Previously, the static modifier was used for file-level functions and variables, but now anonymous namespaces are preferred.
// In mylib.cpp namespace { void helper() { // ... } int hidden_var = 42; }
Can we consider that declaring a function/variable with static at file level and in an anonymous namespace always leads to the same effect?
Answer:
No, there are differences. static limits visibility only in the current file. Objects within an anonymous namespace have the same local visibility, but get a unique name for each compilation file, which prevents name conflicts between translation units. At the same time, anonymous namespaces support nesting and can contain classes, while static cannot.
History
-When migrating old code, one module used static for a variable, while another used a similar variable with the same name but without static. A linker error occurred due to multiple definitions of the variable.
History
-In a large project, merging several libraries led to invisible conflicts between static functions from different files (same name, different implementations). As a result, one library began to behave unpredictably after the build.
History
-A developer placed the class declaration in an anonymous namespace only in the .cpp file, which made it impossible to access the class from other files, violating the module architecture.