Namespaces in C++

A namespace is a container that groups related code — variables, functions, and classes — under a single name. It prevents name conflicts when two pieces of code use the same name for different things. Think of it like two people named "Alex" working in different departments of a company. You say "Alex from Marketing" or "Alex from Engineering" to avoid confusion. Namespaces do the same thing in C++.

Large programs and libraries use namespaces heavily so their code does not accidentally clash with names used elsewhere.

Why Namespaces Are Needed

Without namespaces, every function and variable shares the same global pool of names. Two libraries that both define a function called print() would collide and cause a compile error. Namespaces keep each library's names separate.

Diagram: Name Collision Without Namespaces

Library A:   void print() { ... }
Library B:   void print() { ... }
Your code:   print();   ← ERROR: which print()?

With Namespaces:
LibA::print();  ← Library A's print
LibB::print();  ← Library B's print

Defining a Namespace

namespace NamespaceName {
    // variables, functions, classes go here
}

Example:

#include <iostream>
using namespace std;

namespace Geometry {
    double PI = 3.14159;

    double circleArea(double r) {
        return PI * r * r;
    }
}

int main() {
    cout << Geometry::circleArea(5) << endl;
    return 0;
}

Output:

78.5397

You access names inside a namespace using the scope resolution operator ::.

The std Namespace

Everything in the C++ Standard Library lives in the std namespace. That is why you write std::cout and std::endl — it means "cout from the std namespace".

#include <iostream>

int main() {
    std::cout << "Hello from std namespace!" << std::endl;
    return 0;
}

The using Declaration

Writing std:: before every standard library name gets tedious. The using keyword solves this.

Bring in a single name:

#include <iostream>
using std::cout;
using std::endl;

int main() {
    cout << "Only cout is brought in." << endl;
    return 0;
}

Bring in the entire namespace:

#include <iostream>
using namespace std;

int main() {
    cout << "Everything in std is available." << endl;
    return 0;
}

Using the entire namespace with using namespace std; is convenient for small programs and learning. In large projects, it is better to use specific names or always write the std:: prefix to avoid accidental conflicts.

Multiple Namespaces in One Program

#include <iostream>
using namespace std;

namespace Kitchen {
    void prepare() {
        cout << "Kitchen: chopping vegetables." << endl;
    }
}

namespace Office {
    void prepare() {
        cout << "Office: setting up the projector." << endl;
    }
}

int main() {
    Kitchen::prepare();
    Office::prepare();
    return 0;
}

Output:

Kitchen: chopping vegetables.
Office: setting up the projector.

Both namespaces define a function named prepare() and they coexist without any conflict.

Nested Namespaces

A namespace can live inside another namespace. This creates a hierarchy similar to folders inside folders.

#include <iostream>
using namespace std;

namespace Company {
    namespace Engineering {
        void buildFeature() {
            cout << "Engineering builds the feature." << endl;
        }
    }
    namespace Marketing {
        void runCampaign() {
            cout << "Marketing runs the campaign." << endl;
        }
    }
}

int main() {
    Company::Engineering::buildFeature();
    Company::Marketing::runCampaign();
    return 0;
}

Output:

Engineering builds the feature.
Marketing runs the campaign.

C++17 Shorthand for Nested Namespaces:

namespace Company::Engineering {
    void buildFeature() { ... }
}

Namespace Aliases

Long namespace names can be shortened using an alias. This is like a nickname.

#include <iostream>
using namespace std;

namespace VeryLongCompanyNameEngineering {
    void deploy() {
        cout << "Deploying software." << endl;
    }
}

namespace Eng = VeryLongCompanyNameEngineering;

int main() {
    Eng::deploy();
    return 0;
}

Output:

Deploying software.

Anonymous (Unnamed) Namespaces

A namespace without a name makes its contents visible only within the same file. This replaces the use of static at the global level in C-style code.

namespace {
    int secret = 42;   // only accessible in this file

    void helper() {
        // internal helper function
    }
}

Code in other files cannot access secret or helper(). This is useful for keeping implementation details private to a single source file.

Extending a Namespace

A namespace can be defined in multiple places across your code. All definitions with the same name merge into one namespace.

#include <iostream>
using namespace std;

namespace Tools {
    void hammer() { cout << "Hammering." << endl; }
}

// Later in the same file or another file:
namespace Tools {
    void saw() { cout << "Sawing." << endl; }
}

int main() {
    Tools::hammer();
    Tools::saw();
    return 0;
}

Output:

Hammering.
Sawing.

Namespaces vs Global Scope

Key Takeaways

• Namespaces group related code and prevent name collisions.
• Access members of a namespace using the :: scope resolution operator.
• The entire C++ Standard Library lives in the std namespace.
• using namespace std; is convenient but avoid it in large or library code.
• Namespaces can be nested, aliased, and extended across multiple files.
• Anonymous namespaces restrict visibility to the current file.