Namespace

Programming Language & Its Applications — C++ Constructs with Objects and Classes, NEC licence examination syllabus (Nepal Engineering Council).

Namespace

A named scope for identifiers — the fix for the name collisions that plagued large C programs.

🌍 Where this lives: the very first line of almost every C++ program you will ever read is using namespace std;, and almost every experienced C++ programmer will tell you not to write it. That disagreement is worth understanding rather than memorising. Namespaces exist because C had no way to stop two libraries from both defining log() — and when that happened, the linker simply failed with a duplicate-symbol error and you could not use both libraries in one program. Java's package, Python's modules and Rust's mod all solve the same problem the same way. Search "why using namespace std is considered bad practice" once you finish this page; the answer involves std::count versus your own count, and it will make sense.

The problem namespaces solve

Two libraries, both perfectly reasonable: graphics.h: void draw(); int max_size; audio.h: void draw(); int max_size; In C, including both is a hard error — the names collide at the global scope and there is NO way to disambiguate. Your options were ugly prefixes: gfx_draw(); gfx_max_size; aud_draw(); aud_max_size; which is exactly what large C libraries do (SDL_Init, GTK_widget_show, PyObject_New). It works but it is manual, verbose, and nothing enforces it. C++ makes the prefix a language feature: namespace gfx { void draw(); int max_size; } namespace aud { void draw(); int max_size; } gfx::draw(); aud::draw(); /* both usable */

namespaces.cpp

#include <iostream>

namespace graphics {
    int  resolution = 1080;
    void draw() { std::cout << "drawing a triangle\n"; }
}

namespace audio {
    int  resolution = 44100;      /* same NAME, no clash */
    void draw() { std::cout << "drawing a waveform\n"; }
}

int main() {
    graphics::draw();   audio::draw();
    std::cout << "video " << graphics::resolution
              << "p, audio " << audio::resolution << " Hz\n";
    return 0;
}
Output:
drawing a triangle
drawing a waveform
video 1080p, audio 44100 Hz

The four ways to reach a name

1. FULLY QUALIFIED — always unambiguous, always safe std::cout << graphics::resolution; 2. using DECLARATION — brings in ONE name using std::cout; cout << "no std:: needed for cout only"; /* std::cin still needs the prefix */ 3. using DIRECTIVE — brings in EVERYTHING using namespace std; cout << "everything visible"; /* convenient, but imports ~2000 names */ 4. NAMESPACE ALIAS — shorten a long name namespace fs = std::filesystem; fs::path p = "/tmp/data.txt"; Scope matters: a `using` inside a function affects only that function. At file scope in a HEADER it pollutes every file that includes it — which is why "using namespace std;" in a header is genuinely bad, not merely unfashionable.

using_forms.cpp

#include <iostream>
#include <vector>

namespace company {
    namespace project {          /* nested */
        int version = 3;
        void info() { std::cout << "v" << version << "\n"; }
    }
}
/* C++17 shorthand for the same nesting: */
/* namespace company::project { ... } */

int main() {
    /* 1. fully qualified */
    company::project::info();

    /* 2. using declaration - one name only */
    using std::cout;
    cout << "cout works bare; ";
    std::cout << "std::cout still fine\n";

    /* 3. using directive - scoped to this block */
    {
        using namespace company::project;
        info();          /* no prefix needed HERE */
    }
    /* info();  <-- error out here: not declared */

    /* 4. alias */
    namespace cp = company::project;
    cout << "via alias: " << cp::version << "\n";
    return 0;
}
Output:
v3
cout works bare; std::cout still fine
v3
via alias: 3

Worked example — the collision that motivates the rule

collision.cpp

#include <iostream>
#include <algorithm>     /* declares std::count */

/* A perfectly reasonable global of my own */
int count = 0;

int main() {
    /* With "using namespace std;" at file scope, this
       line becomes AMBIGUOUS: ::count or std::count? */
    count = 5;             /* fine WITHOUT the using directive */
    std::cout << "count = " << count << "\n";

    /* The scoped, safe habit: */
    using std::cout;       /* just the names you need */
    cout << "explicit is better\n";
    return 0;
}
Output:
count = 5
explicit is better

/* Add "using namespace std;" above and some compilers
   report:
     error: reference to 'count' is ambiguous
     candidates: int count  /  std::count(...)          */

The size of what a using directive imports: <iostream> alone pulls in roughly 2,000 names from std. Include <algorithm>, <vector>, <string> and you are past 10,000. Names in std that collide with ordinary variable names people actually write: count, distance, size, data, begin, end, swap, min, max, find, sort, left, right, hash, byte, transform So the practical rule: · in a .cpp file, inside a function → using directive is acceptable and common · at file scope in a .cpp → tolerable in small programs · in a HEADER (.h/.hpp) → never. Every file that includes your header inherits the pollution and cannot opt out.

The deeper point is about who bears the cost. A using inside your function costs only you. A using in your header costs everyone who includes it, invisibly, and they cannot undo it. That asymmetry — local convenience versus imposed global cost — is a design principle worth carrying into every API you ever write.

Unnamed namespaces and the std reservation

ANONYMOUS namespace — the C++ replacement for static: namespace { int helper_counter = 0; /* visible only in void helper() { } THIS .cpp file */ } Equivalent to C's `static int helper_counter;` but works for types too, which static cannot do. RESERVED: you may NOT add your own names to namespace std. namespace std { void my_function(); } /* undefined behaviour */ The one narrow exception the standard allows is specialising a template like std::hash for YOUR type — and even that has rules. Why? The standard library authors need to be free to add names in future versions without breaking your code.

🌍 Go further: namespaces are only half of how C++ keeps names apart — the other half is name mangling. Because C++ allows two functions called draw in different namespaces (and overloading, next topic), the linker cannot work with plain names. So the compiler encodes the namespace, class and parameter types into the symbol: graphics::draw() becomes something like _ZN8graphics4drawEv. Run nm --demangle on any C++ binary and you can read it back. This is also exactly why you need extern "C" to call C++ code from C. Search "C++ name mangling extern C".

💡 Exam angle: define a namespace, access members with the scope resolution operator ::, and state the difference between a using declaration (one name) and a using directive (all names). Know that namespaces can nest and be aliased, that an unnamed namespace gives internal linkage, and that adding names to std is forbidden. A short program with two same-named functions in different namespaces is the standard question.

Syllabus points

Namespace declaration & use

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.