# V1068. Do not define an unnamed namespace in a header file.

The analyzer detected an anonymous namespace declared in the header file. Such a header file creates copies of symbols with internal linkage in each translation unit that includes this header file. This leads to object files bloat, which may be unwanted behavior.

Consider a simple example of a header file with an anonymous namespace:

    // utils.hpp
    #pragma once
    #include <iostream>

    namespace
    {
      int global_variable;
      void set_global_variable(int v)
      {
        std::cout << global_variable << std::endl;
        global_variable = v;
      }
    }

When the 'utils.hpp' header file is included, each translation unit will receive its own instance of the 'global_variable' variable. The variable will not relate to other instances and will not be accessible from other translation units. Several redundant 'set_global_variable' functions will also be generated. Before the C++17 standard, such code could occur in header-only libraries in order not to violate the One Definition Rule when including header files in multiple translation units. Also, such code may appear due to careless refactoring, for example, when moving an anonymous namespace from a compiled file to a header file.

it is worth mentioning that this rule also applies to unnamed namespaces nested in other namespaces:

    namespace my_namespace
    {
      int variable1; // namespace-scope non-const variable
                     // 'variable1' has external linkage

      namespace // <=
      {
        int variable2; // unnamed namespace applies 'static'
                       // 'variable2' has internal linkage
      }
    }

If you need to create exactly one instance of a symbol for the header-only library, you can use the 'inline' specifier. Starting with C++17, it applies to variables as well:

    // utils.hpp
    #pragma once
    #include <iostream>

    inline int global_variable; // ok since C++17

    inline void set_global_variable(int v)
    {
      std::cout << global_variable << std::endl;
      global_variable = v;
    }

If an earlier version of the standard is used, but the library is not header-only, then you can declare the symbols as 'extern' in the header file and define them in one of the translation units:

    // utils.hpp
    #pragma once

    extern int global_variable;
    void set_global_variable(int v); // functions implicitly
                                     // have external linkage ('extern')

    // utils.cpp
    #include "utils.hpp"
    #include <iostream>

    int global_variable;

    void set_global_variable(int v)
    {
      std::cout << global_variable << std::endl;
      global_variable = v;
    }

In the case when an older version of the standard is used, but the library must be header-only, the warning can be suppressed with a comment:

    // utils.hpp
    #pragma once
    #include <iostream>

    namespace //-V1068
    {
      int global_variable;
      void set_global_variable(int v)
      {
        std::cout << global_variable << std::endl;
        global_variable = v;
      }
    }

This diagnostic is classified as:

CERT-DCL59-CPP

You can look at examples of errors detected by the V1068 diagnostic.