Accessing Names in Namespaces

Imagine a large program written by several teams. One team writes a function called main in their own part of the code, and another team's library also contains a name that looks identical. If every name were placed in one shared pool, the program would have no way to tell these apart. Namespaces solve this problem by giving names a place to live. This article is about the two everyday ways a program reaches a name that lives somewhere other than where the code currently sits.

A helpful way to picture a namespace is as a labeled drawer. Each drawer holds names, and the label on the drawer keeps names with the same spelling from getting mixed up when they belong to different drawers. A name stored in one drawer is not automatically visible from another drawer. To use it, you have to say which drawer it is in, or you have to set things up so that the drawer's contents can be looked at without repeating the label each time.

The real main() is not wrapped in a named group the way My_code::main is. It lives in the global namespace, which is the outermost level of the program. It is not inside a named namespace, a class, or a function. Because it sits at the outermost level, it is reached without any namespace prefix. A name that is not inside any named group is effectively a global name, so the absence of a prefix tells you something about where a name is defined.

Look at the diagram and notice that the name main appears twice. One entry is in the global namespace and the other is inside My_code. These are two different entries that happen to share a spelling. Keeping this picture in mind makes the next step easier to follow, because the question becomes which of the two entries a given prefix selects.

The most direct way to access a name that belongs to another namespace is to qualify it with the namespace's name. Qualification means writing the namespace name, then the scope operator, then the name you want. The full path tells the program exactly which drawer to open. The source uses two examples: std::cout, where cout is looked up inside the namespace called std, and My_code::main, where main is looked up inside the namespace called My_code. In both cases the prefix removes any doubt about which name is meant, even when a different name with the same spelling exists elsewhere.

Notice that the rule is the same for both lines. The program does not guess which cout or main you meant. The prefix before the scope operator names the drawer, and the name after it names the item inside that drawer.

Qualifying every name works, but it can become tedious when a program uses many names from the same namespace. To gain access to names in the standard-library namespace, the source introduces a using-directive, written as using namespace std;. Its role is to make names from that namespace available to the code without requiring the full qualified path each time. A using-directive is therefore a way of opening a drawer for the code that follows, rather than a way of moving the names out of the drawer.