C++ Namespaces and Using Declarations

When working with bigger projects, a problem can arise when many different identifiers exist in the same project. For example, two variables, functions or classes that have the same name.

The way this problem is solved is by the introduction of namespaces.

Creating a Namespace

We can wrap sections of our code inside a namespace as shown below.

1namespace Math {
2  // your code here
3}
4

We can popualte namespaces with any of the constructs we've seen before. This can include variables, functions and even complete classes:

1namespace Math {
2  int Add(int x, int y) {
3    return x + y;
4  }
5
6  float Pi { 3.14 };
7
8  float Circumference (float Diameter) {
9    // Because this function is in the same namespace as
10    // the pi variable, we can access Pi as normal here
11    return Diameter * Pi;
12  }
13
14  class Square {
15    float SideLength { 5.0 };
16    float Area() { return SideLength * SideLength };
17  }
18}
19

Accessing Things inside C++ Namespaces

In the earlier example, we saw that members of a namespace can access other members of their namespace as normal:

1namespace Math {
2  float Pi { 3.14 };
3  float Circumference(float Diameter) {
4    // We can access Pi here as we're in the same namespace
5    return Diameter * Pi;
6  }
7}
8

To access namespace members from outside the namespace, we need the Scope Resolution Operator, ::

For example, the following statement accesses the Add function and the Pi variable, which are both inside the Math namespace:

1Math::Add(10, Math::Pi);
2

1namespace Utilities {
2  void Square() {};
3};
4

C++ Nested Namespaces

Namespaces can be nested inside other namespaces in C++

1namespace Math {
2  int Add(int x, int y) {
3    return x + y;
4  }
5  namespace Geometry {
6    float Pi { 3.14f };
7  }
8}
9

To access these nested identifiers, we can can use the :: operator multiple times:

1Math::Add(10, Math::Geometry::Pi)
2

C++ using Declarations

Starting from the very first lesson, we've had a line of code in our files that we've left unexplained thus far:

1using namespace std;
2

Predictably, this line is related to namespaces.

The effect of this using declaration was an instruction that asks the compiler: "if an identifier in this scope is not found, try searching for it in the std namespace".

This using statement has been necessary every time we used cout and endl. These identifiers were actually in the std namespace.

Without the using declaration, we would needed to use the scope resolution operator. Instead of this:

1using namespace std;
2cout << "Hello world!" << endl;
3

We'd have needed to do this:

1std::cout << "Hello world!" << std::endl;
2

We can use using declarations with any namespace - not just std:

1namespace Maths {
2  float Pi { 3.14f };
3}
4
5using namespace Maths;
6using namespace std;
7
8cout << Pi << endl;
9

1namespace Utilities {
2  void Square() {};
3};
4
5// ?
6
7Square();
8

Should I use using namespace Statements?

Probably not. Namespaces exist to help us organise code - a using namespace declaration effectively subverts that organisation.

We will continue to use them in our lessons. This is only for two reasons:

• We want to keep our lines as short as possible - horizontal space is limited when we're presenting code on a mobile-friendly website
• Naming collisions are less of a problem when dealing with simple, tutorial examples.

But, in real projects, we should be cautious about adopting using declarations.

Remember too how #include directives work - if we have a using declaration that is scoped to an entire file, that would also effect any file that includes it.

This can cause things to get out of hand quite quickly so, if using declarations are going to be adopted, be particularly cautious when using them on files that are likely to be included in other files.

The Unreal coding standard asks for using declarations to never be used in the global scope:

And the Google C++ standard asks that using declarations never be used, anywhere:

If we want to use using statements, there are two ways we can get their benefits, whilst minimising their drawbacks. The first is to use them only in the scope they're necessary. The second is to restrict them to only using the specific identifiers we need.

Scoped using Declarations

Using declarations follow the normal block scoping rules. A using declaration outside of any block has "global" scope, and will apply to the entire file.

This can be problematic, especially if that file goes on to be added to a load of other files, via the #include directive.

As an alternative to global using declarations, we can place them inside blocks - usually function bodies or other namespaces. This wil limit their effect to just the scope of that block.

1void Hello() {
2  using namespace std;
3  cout << "Hello ";
4}
5
6void World() {
7  // Error!  The using declaration only applies to the block where it is used
8  cout << "World"
9}
10
11int main() {
12  Hello();
13  World();
14}
15

Restrict using Declarations to Specific Identifiers

Rather than having a using statement that covers the entire std namespace, we can restrict it just to specific identifiers.

For example, to use it with just std::cout and std::endl, we could write this:

1#include <iostream>
2
3using std::cout, std::endl;
4
5int main() {
6  cout << "Hello world!" << endl;
7}
8