Understanding Namespaces and Using Directives

Many C++ programs print output using a name such as cout. That name does not stand on its own. It belongs to a namespace called std, so the complete name, written out in full, is std::cout. Every time a program uses a name this way, the namespace prefix has to be written, and in a long program that repetition makes code longer and harder to read. This article follows one way to shorten those references, the using-directive, and it traces exactly what the compiler does with a short name once that directive is in place.

The reason a program needs namespaces is that every named thing in a program has to be distinguishable from every other named thing. As programs grow and pull in code written by different people, the same plain word can end up meaning two different things. A namespace is the mechanism C++ provides for organizing names so that they do not collide with one another.

The standard library offers a large set of ready-made names that a C++ program can use, and those names are gathered into one namespace called std. Anything from the standard library that you want to use is looked up inside std. Because cout is one of those standard library names, it is placed in std, and the std namespace is the container that holds it.

The expression std::cout is the standard example of an explicitly qualified name. Its parts have fixed roles, and reading them in order makes the meaning clear. The part before the separator names the namespace, the separator is written as two colons, and the part after the separator is the name being accessed.

Explicit qualification uses the namespace name followed by the scope separator to access a name. Reading a qualified name is therefore a matter of splitting it at the separator: the left side tells you where the name lives, and the right side tells you which name it is.

A using-directive makes names from a named namespace accessible as if they were local to the scope where the directive is placed. The key phrase is as if they were local. A using-directive does not move the names out of their namespace, and it does not copy them anywhere. It makes the names usable without the namespace prefix, as though they had been declared in the current scope.

The directive names a namespace, and every name from that namespace becomes available to write in the short form within the scope where the directive appears. So the directive does not change what cout is or where it is stored. It changes only whether the namespace prefix must be written at each use.

Once the directive is in place, the compiler sees the bare name cout and needs to decide what it refers to. The directive has told it that names from std are available in the short form, so the bare cout is resolved to std::cout. The output stream reached is the same in both cases. The only difference is whether the namespace prefix had to be written at this use.

Notice that the resolution depends on the directive being in effect. Without it, the bare cout is not covered by any directive, and the full std::cout is what the code must say.

The source gives the central pattern: after the using-directive for std, the program can write cout instead of std::cout. The following fragments show the same output statement written two ways. The first uses the full prefix at the point of use. The second places the directive first and then uses the short name.

The definition says names become accessible in the scope where the directive is placed, so placement matters. A name made accessible by a directive is only usable within the scope that the directive was written in. Code outside that scope is not covered by the directive, so the namespace prefix or another arrangement is still needed there. When reading a program, the first question to ask about a using-directive is therefore where it appears.

Read the example as a scope question. Inside first, the bare cout is covered by the directive and can be written without the prefix. Inside second, the directive does not reach, so the code must use std::cout. The two functions sit in the same file, yet the same short name is valid in one and not covered in the other.

Writing the namespace prefix every time is not always necessary. The source is explicit that explicit qualification is not always necessary, and its own author often leaves out the std:: when discussing standard features, because the meaning is clear from context. Dropping the prefix is therefore a legitimate choice, not a mistake in itself.

The source also notes that names can be made visible without explicit qualification through a separate technique, covered in a later section. That technique is not introduced here. Until it is, the safe habit is to keep the full prefix visible while learning, so you can always see which namespace a name comes from.