C++ Namespaces

Two libraries, one name

C++ programs pull in many headers. Your code might define count. A library might also definecount. If both names live in the global space, the compiler cannot tell them apart. A namespace is a labeled box around names so stats::count and ui::count can both exist.

You have been using a namespace since the first program: std. cout, string, and vector live there. using namespace std; opens the box so you can write the short names. The names were never global to begin with.

std::cout without using namespace

The qualifier is two colons: std::cout. That means “the cout that belongs tostd.” This program skips using namespace std; entirely. Every standard name is spelled out. The program still compiles and still prints.

#include <iostream>

int main() {
  int n = 5;
  std::cout << n << std::endl;
  return 0;
}

A namespace of your own

Write namespace, a name, and a brace block. Functions and types inside belong to that namespace. Call them with the same :: syntax you use for std. This mathx box holds one function so it cannot clash with some other square in a larger project.

#include <iostream>
using namespace std;

namespace mathx {
  int square(int n) {
    return n * n;
  }
}

int main() {
  cout << mathx::square(5) << endl;
  cout << mathx::square(12) << endl;
  return 0;
}

The function is not square in the global space. It is mathx::square. Other files can define a different square without colliding, as long as they sit in a different namespace or you keep yours qualified.

Two boxes, same short name

This program puts label in two namespaces. Both functions return a string. The calls pick which one with ::. Without namespaces, two global functions named label would not compile together.

#include <iostream>
#include <string>
using namespace std;

namespace audio {
  string label() {
    return "track";
  }
}

namespace video {
  string label() {
    return "frame";
  }
}

int main() {
  cout << audio::label() << endl;
  cout << video::label() << endl;
  return 0;
}

using, one name at a time

using namespace std; imports every name in std. That is convenient in a short.cpp file and is the house style for most StudyGrid examples. In a larger file it can hide collisions until a new include appears.

You can import one name instead: using std::cout;. Then cout is short, butendl still needs std::endl unless you using that too. This tutorial's small programs keep the blanket using-directive. Qualifying everything, as in the first example, is the safest default when you leave the tutorial.

Do not wrap main

int main() stays in the global namespace. Do not put main insidenamespace. The runtime looks for the global main as the start of the program.

Namespace names follow the same rules as other names: letters, digits, underscore, no spaces. Pick a short word that is unlikely to match a library: a project prefix, not std and not string.

Qualify when two meanings exist

If a name appears in one place, a short call is fine. If two namespaces offer the same name, write:: every time and skip a using-directive for those boxes. Next: destructors, which run when an object leaves scope and is destroyed.