Global non static variable in unnamed namespace

Question

I can't find a good explanation about global non static variables in unnamed namespace. I avoid global variables as much as I can. In this particular case I'm interested about behaviour just from pure theoretic side.

Suppose the following code:

In a.h

namespace ai {
  class Widget {
    void DoSomething(int param);
  };
}

In a.cc

namespace {
  int x;
  void Helper() {
  }
}

namespace ai {
  void Widget::DoSomething(int param) {
    x = param;
    Helper();
  }
}

1. If I would create two instances of the same class Widget, will both instances share the same variable x?

2. Is above behaviour the same if class instances are on the same thread vs different threads?

3. What if the variable x would be custom type instead of built-in type?

4. When variable x will be contructed and when destructed?

5. Is any relation between sizeof(Widget) and such variables?

6. What aspects are defined in C++ standard and what not?

Any other considerations, e.g. "need to know" about that topic? Maybe anyone could provide good book reference (e.g. "Effective C++..") to read more?

Answer 1

1. Yes, there is just one variable x.
2. Yes, there is just one variable x.
3. Yes, there is just one variable x.
4. On startup & on shutdown.
5. I'm not following the question.
6. I believe 1-4 above are in the Standard.

It is exactly the same as if you had defined it as static : Global inside the file, but hidden outside of it.

static int x; 
namespace { 
  void Helper() { 
  } 
}

Unnamed namespaces were added specifically to eliminate that particulay usage of static (which has too many different meanings/usages)

Answer 2

1. yes. The namespace has given 'x' a fancy name, but its still a static object at global scope.

2. maybe. threads are not part of the iso c++ virtual machine described in the standards document. how c++ interacts with threads is an implementation defined issue. Most compilers have some sort of declspec directive to make variables thread local otherwise all threads share the same instance.

3. No difference.

4. x is an int. its value is undefined / uninitialzied. if it was a class it would be constructed before main() and destructed after.

5 & 6. don't understand the question.

I have one go-to resource for c++ questions: the c++ faq lite

Answer 3

sorry, i replied OT.

Answer 4

If I would create two instances of the same class Widget, will both instances share the same variable x?

Yep. It's a global variable. There can always ever be one - per process, that is.

Is above behaviour the same if class instances are on the same thread vs different threads?

Global variables are global per process (not per thread).

What if the variable x would be custom type instead of built-in type?

Doesn't matter. (Thankfully, C++ sports little differences between built-ins and UDTs.)

When variable x will be contructed and when destructed?

Constructed before main() is called, destructed afterwards. The order of construction of globals across multiple translation units is undefined. Within the same TU it's the order of definition. (Or definition? I forgot.) The order of destruction is well defined and is, as always, the revers construction order.

Is any relation between sizeof(Widget) and such variables?

Why would there be a relation between a class X and a variable Y of a different type?

What aspects are defined in C++ standard and what not?

Basically, a global variable in an unnamed namespace is a normal global variable. Only that it resides in a namespace with a "funny" name that you cannot spell out and which is unique to its translation unit.