20.4. Namespaces

20.4. Namespaces
	Chapter 20. Scope and Storage Class

[ fromfile: namespaces.xml id: namespaces ]

In C and C++ there is one global scope that contains
- The names of all global functions and variables
- Class and type names that are commonly available to all programs
Classes are one way of grouping names (members) under a common heading (the classname), but sometimes it is desirable to have a higher-level grouping of names.

The namespace mechanism provides a way to partition the global scope into individually named sub-scopes.
This helps avoid naming conflicts that can arise when developing a program that uses modules with name conflicts.
The syntax for defining a namespace is
```
        namespace namespaceName { decl1, decl2, ...}
```
Any legal identifier can be used for the optional namespaceName.
Example 20.11 and Example 20.12 define two separate namespaces in different files, each containing functions with the same name.

#include <iostream>
namespace A {
    using namespace std;
    void f() {
        cout << "f from A\n";
    }

    void g() {
        cout << "g from A\n";
    }
}

Example 20.12. src/namespace/b.h

#include <iostream>

namespace B {
    using namespace std;
    void f() {
        cout << "f from B\n";
    }

    void g() {
        cout << "g from B\n";
    }
}

Example 20.13 includes both header files, and uses scope resolution to call functions declared in either file.

Example 20.13. src/namespace/namespace1.cc

#include "a.h"
#include "b.h"

int main() {
    A::f();
    B::g();
}
Output:

f from A
g from B

The using keyword enables individual members of a namespace to be referenced without scope resolution.
The syntax can take two forms.

The using directive:
```
using namespace namespaceName
```
imports the entire namespace into the current scope.
The using declaration:
```
using namespaceName::identifier
```
imports a particular identifier from that namespace into the current scope.

Example 20.14. src/namespace/namespace2.cc

#include "a.h"
#include "b.h"

int main() {
    using A::f;         
    f();
    using namespace B;  
    g();                
    f();                
}
Output:

f from A
g from B
f from A

	Declaration - brings A::f() into scope.
	Brings all of B into scope.
	Okay.
	Ambiguous!

Example 20.15. src/namespace/namespace3.cc

#include "a.h"
#include "b.h"

int main() {
    using namespace A; 
    f();
    using namespace B; 
    g();
    f();              
}
Output:

OOP> gpp namespace3.cc
namespace3.cc: In function `int main()':
namespace3.cc:10: call of overloaded `g ()' is
ambiguous
b.h:6: candidates are: void B::g()
a.h:6:                 void A::g()
namespace3.cc:11: call of overloaded `f ()' is
ambiguous
b.h:4: candidates are: void B::f()
a.h:4:                 void A::f()
OOP>

	brings all of A into scope
	brings all of B into scope


20.3.2. Exercises: Storage Class		20.5. Review Questions