static vs non-static variables in namespace

I have a namespace foo which contains an integer bar, declared so...

foo.h:

namespace foo {
    int bar;
}

Now if I include foo.h in only one file, this works just fine. But a problem arises when I include foo.h from two or more files: I get a linker error. I figured out that if I declare bar as static, I can include foo.h in more than one file. This seems strange to me, because I wasn't aware that one could declare a static variable inside of a namespace. (what does that even mean?)

Why does this work? And more importantly, why doesn't it work without static? What does static mean when used in a namespace?

Solution 1:

There are multiple meanings for static in different contexts. In this particular context it means that the variable has internal linkage, and thus each translation unit that includes that header will have it's own copy of the variable.

Note that while this will silent the linker error, it will do so maintaining a separate foo::bar variable for each one of the object files generated (changes will not be visible across different object files).

If you want a single variable, you should declare it as extern in the header and provide a single definition in one translation unit.

Solution 2:

When you declare a variable as static, it means that its scope is limited to the given translation unit only. Without static the scope is global.

When you declare a variable as static inside a .h file (within or without namespace; doesn't matter), and include that header file in various .cpp files, the static variable becomes locally scoped to each of the .cpp files.
So now, every .cpp file that includes that header will have its own copy of that variable.

Without the static keyword the compiler will generate only one copy of that variable, so as soon as you include the header file in multiple .cpp files the linker will complain about multiple definitions.

Solution 3:

The problem is caused by having more than one definition of the variable. The definitions in different translation units conflict with each other, just like multiple non-inline function definitions wouldn't work.

When you make the variable static you're giving the variable internal linkage, so each translation unit has its own independent copy.

What you probably actually want is to put only the declaration in a header (using extern) and then put the definition in an implementation file.