Root: 1 revision(s)

2007-06-08T15:04:45Z

1 revision(s)

← Older revision	Revision as of 15:04, 8 June 2007
(No difference)

Root at 09:47, 3 April 2007

2007-04-03T09:47:27Z

New page

=Namespaces=

Namespaces allow to group entities like classes, objects and functions under a name. This way the global scope can be divided in "sub-scopes", each one with its own name.

The format of namespaces is:

<tt> namespace identifier { entities } </tt>

Where <tt>identifier</tt> is any valid identifier and <tt>entities</tt> is the set of classes, objects and functions that are included within the namespace. For example:

{| class="snippet"
| class="code" |
namespace myNamespace
{
int a, b;
}

|}

In this case, the variables <tt>a</tt> and <tt>b</tt> are normal variables declared within a namespace called <tt>myNamespace</tt>. In order to access these variables from outside the <tt>myNamespace</tt> namespace we have to use the scope operator <tt><nowiki>::</nowiki></tt>. For example, to access the previous variables from outside <tt>myNamespace</tt> we can write:

{| class="snippet"
| class="code" |
myNamespace::a
myNamespace::b

|}

The functionality of namespaces is especially useful in the case that there is a possibility that a global object or function uses the same identifier as another one, causing redefinition errors. For example:

{| class="codebox"
| class="code" |
// namespaces
<nowiki>#include <iostream></nowiki>
using namespace std;

namespace first
{
int var = 5;
}

namespace second
{
double var = 3.1416;
}

int main () {
cout << first::var << endl;
cout << second::var << endl;
return 0;
}

| class="result" |
5
3.1416
|}

In this case, there are two global variables with the same name: <tt>var</tt>. One is defined within the namespace <tt>first</tt> and the other one in <tt>second</tt>. No redefinition errors happen thanks to namespaces.

===using===

The keyword <tt>using</tt> is used to introduce a name from a namespace into the current declarative region. For example:

{| class="codebox"
| class="code" |
// using

<nowiki>#include <iostream></nowiki>
using namespace std;

namespace first
{
int x = 5;
int y = 10;
}

namespace second
{
double x = 3.1416;
double y = 2.7183;
}

int main () {
using first::x;
using second::y;
cout << x << endl;
cout << y << endl;
cout << first::y << endl;
cout << second::x << endl;
return 0;
}

| class="result" |
5
2.7183
10
3.1416
|}

Notice how in this code, <tt>x</tt> (without any name qualifier) refers to <tt>first::x</tt> whereas <tt>y</tt> refers to <tt>second::y</tt>, exactly as our <tt>using</tt> declarations have specified. We still have access to <tt>first::y</tt> and <tt>second::x</tt> using their fully qualified names.

The keyword using can also be used as a directive to introduce an entire namespace:

{| class="codebox"
| class="code" |
// using

<nowiki>#include <iostream></nowiki>
using namespace std;

namespace first
{
int x = 5;
int y = 10;
}

namespace second
{
double x = 3.1416;
double y = 2.7183;
}

int main () {
using namespace first;
cout << x << endl;
cout << y << endl;
cout << second::x << endl;
cout << second::y << endl;
return 0;
}

| class="result" |
5
10
3.1416
2.7183
|}

In this case, since we have declared that we were <tt>using namespace first</tt>, all direct uses of <tt>x</tt> and <tt>y</tt> without name qualifiers were referring to their declarations in <tt>namespace first</tt>.

<tt>using</tt> and <tt>using namespace</tt> have validity only in the same block in which they are stated or in the entire code if they are used directly in the global scope. For example, if we had the intention to first use the objects of one namespace and then those of another one, we could do something like:

{| class="codebox"
| class="code" |
// using namespace example

<nowiki>#include <iostream></nowiki>
using namespace std;

namespace first
{
int x = 5;
}

namespace second
{
double x = 3.1416;
}

int main () {
{
using namespace first;
cout << x << endl;
}
{
using namespace second;
cout << x << endl;
}
return 0;
}

| class="result" |
5
3.1416
|}

===Namespace alias===

We can declare alternate names for existing namespaces according to the following format:

<tt> namespace new_name = current_name; </tt>

===Namespace std===

All the files in the C++ standard library declare all of its entities within the <tt>std</tt> namespace. That is why we have generally included the <tt>using namespace std;</tt> statement in all programs that used any entity defined in <tt>iostream</tt>.

Template:Cpptutorial Namespaces - Revision history

Root: 1 revision(s)

Root at 09:47, 3 April 2007