C++ Namespaces vs Classes

Our previous lesson explained the core purpose of namespaces. They are a way to organise and group related code together, such as a collection of functions that relate to maths.

In this way, they have similar a organisational purpose to classes. The main conceptual differences is that classes can also create objects.

It doesn't make sense to create an object with a type of "Math". So, for this type of organisation, we can create a namespace instead.

Splitting C++ Namespaces into Header and Source Files

With classes, we saw the convention of provide the declaration of our class in a header file, and then provided the definition of its functions within a separate cpp file.

We can apply this exact same pattern when using namespaces:

1// Math.h
2#pragma once
3
4namespace Math {
5  float Pi { 3.14f };
6  int Add(int x, int y);
7  float Circumference(float Diameter);
8  class Square {
9	float SideLength;
10	float Area();
11  };
12}
13

1// Math.cpp
2#include "Math.h"
3
4int Math::Add(int x, int y) {
5  return x + y;
6}
7
8float Math::Circumference(float Diameter) {
9  return Diameter * Pi;
10}
11
12float Math::Square::Area() {
13  return SideLength * SideLength;
14}
15

Anonymous Namespaces

Classes have a useful property where we can have a "private" section. Here, we can store helper functions and variables that we want to keep hidden from the outside world.

Namespaces do not have access specifiers - everything in a namespace can be considered public.

However, we can solve the same problem using an anonymous namespace.

Predicatably, an anonymous namespace is a namespace without a name:

1namespace {
2  int SomeNumber { 4 };
3}
4

Variables and functions defined within an anonymous namespace are only available to the same source file where the namespace exists.

Therefore, we can think of an anonymous namespace as the "private" section of a file.

Following on from our previous Math example, lets make Pi "private".

To do that, we can remove it from our header file entirely:

1#pragma once
2
3namespace Math {
4  float Pi { 3.14f };
5  int Add(int x, int y);
6  float Circumference(float Diameter);
7  class Square {
8	float SideLength;
9	float Area();
10  };
11}
12

This is already an improvement over classes - it means our namespace header files are smaller. This makes them easier to read and faster to compile when other files #include it.

Next, we add it to an anonymous namespace in our source file:

1#include "Math.h"
2
3// Private
4namespace {
5  float Pi { 3.14f };
6}
7
8// Public
9int Math::Add(int x, int y) {
10  return x + y;
11}
12
13float Math::Circumference(float Diameter) {
14  return Diameter * Pi;
15}
16
17float Math::Square::Area() {
18  return SideLength * SideLength;
19}
20

With that done, everything in our file (including our namespace functions) still have access to it, we simplified our Math namespace, and we avoided creating a global variable.

Up next, we'll look at a simple new data type that is a powerful way of storing data that can be one of a specific set of possibilities.