What is
Namespaces in C++ Programming Language:
Using namespace we can have
class,global variables,functions under one name. We can change global scope to
Sub-scope.
Namespace in c++
·
Namespace is a logical compartment used to avoid naming collisions.
·
The naming conflict or Collision always Occurs may
occur -
·
When same program is using more than one library with some
variables or functions having same name.
·
The name collision may occur for global variables, global
functions, classes etc.
·
Default namespace is global namespace and can access global data
and functions by proceeding (::) operator.
·
We can create our own namespace. And anything declared within
namespace has scope limited to namespace.
Creating a namespace:
·
Creation of namespace is similar to creation of class.
·
Namespace declarations appear only at global scope.
·
Namespace declarations can be nested within another namespace.
·
Namespace declarations don’t have access specifiers. (Public or
private)
·
No need to give semicolon after the closing brace of definition of
namespace.
·
We can split the definition of namespace over several units.
Syntax:
namespace namespace_name
{
//member declarations
}
Live Example :
//In firstHeader.h
namespace ns1
{
class one
{
//----Declarations---
};
class two
{
//----Declarations---
};
}
//In secondHeader.h
namespace ns1 // can continue the defination of ns1 over multiple header files
{
class three
{
//----Declarations---
};
}
What is Unnamed Namespace
?
·
Unnamed namespaces are the replacement for the static declaration of
variables.
·
They are directly usable in the same programand are used for declaring unique identifiers.
·
In unnamed namespaces, name of the namespace in not mentioned in
the declaration of namespace.
·
The name of the namespace is uniquely generated by the compiler.
·
The unnamed namespaces you have created will only be accessible
within the file you created it in.
#include<iostream>
using namespace std;
namespace
{
int i;
}
int main()
{
i=10;
cout<< "Value : "<<i;
return 0;
}
Output:
Value : 10
How to Use Namespaces in C++
Programming Language :
Following are the ways to refer to
namespace members:
Way 1 : Using Scope Resolution :
In this method, we use the namespace
name, scope resolution operator (::) and member of that namespace.
Way 2 : Using Directive:
We can use ‘using’ directive to specify the namespace.
#include<iostream>
using namespace std;
namespace first
{
int i;
}
namespace second
{
int i;
}
int main()
{
first::i=1; //scope resolution
second::i=2;
using first::i; //using directive
cout<<i;
}
Way 3 : Using declaration:
It is a declaration within the
current scope. This means it can override names from a using directive.
#include<iostream>
using namespace std;
namespace first
{
int i;
}
using namespace first;// using declaration
int main()
{
i=2;
cout<<"Value : "<<i<<endl;
}
Output:
Value : 2
Different Verities of Using
Namespace :
1.We can Have Class Definition inside Namespace
#include <iostream>
using namespace std;
namespace MyNameSpace {
int num1;
int num2;
class Student
{
int marks;
public:
Student() {
marks = num1;
}
};
}
int main()
{
MyNameSpace::num1 = 70;
MyNameSpace::num2 = 90;
MyNameSpace::Student ob1();
}
·
num1,num2 are two variables under same namespace name
“MyNamespace”.
·
We can Initialize them in main function by using Scope Resolution
Operator.
·
We can Declare Class inside Namespace and thus we can have
multiple classes with same name but they must be in different namespace.
2.We can Have Same Class Definition inside different Namespace
#include <iostream>
using namespace std;
namespace MyNameSpace1 {
int num1;
int num2;
class Student
{
int marks;
public:
Student() {
marks = num1;
}
};
}
namespace MyNameSpace2 {
int num1;
int num2;
class Student
{
int marks;
public:
Student() {
marks = num1;
}
};
}
int main()
{
MyNameSpace1::num1 = 80;
MyNameSpace1::num2 = 50;
MyNameSpace1::Student ob1();
}
Consider a situation when we
have two persons with the same name, Zara, in the same class. Whenever we need
to differentiate them definitely we would have to use some addition information
along with their name, like either the area if they live in different area or
their monther or father name etc.
Same situation can arise in
your C++ applications. For example, you might be writing some code that has a
function called xyz() and there is another library available which is also
having same function xyz(). Now the compiler has no way of knowing which
version of xyz() function you are referring to within your code.
A namespace is designed to overcome this
difficulty and is used as an additional information to differentiate similar
functions, classes, variables etc. with the same name available in different
libraries. Using namespace, you can define the context in which names are
defined. In essence, a namespace defines a scope.
Defining a
Namespace:
A
namespace definition begins with the keyword namespace followed by the namespace name as
follows:
namespace namespace_name {
// code declarations
}
To call the namespace-enabled
version of either function or variable, prepend the namespace name as follows:
name::code; // code could be variable or function.
Let us see how namespace scope
the entities including variable and functions:
#include <iostream>
using namespace std;
// first name space
namespace first_space{
void func(){
cout << "Inside first_space" << endl;
}
}
// second name space
namespace second_space{
void func(){
cout << "Inside second_space" << endl;
}
}
int main ()
{
// Calls function from first name space.
first_space::func();
// Calls function from second name space.
second_space::func();
return 0;
}
If we compile and run above
code, this would produce following result:
Inside first_space
Inside second_space
The using
directive:
You
can also avoid prepending of namespaces with the using namespace directive. This directive tells the
compiler that the subsequent code is making use of names in the specified
namespace. The namespace is thus implied for the following code:
#include <iostream>
using namespace std;
// first name space
namespace first_space{
void func(){
cout << "Inside first_space" << endl;
}
}
// second name space
namespace second_space{
void func(){
cout << "Inside second_space" << endl;
}
}
using namespace first_space;
int main ()
{
// This calls function from first name space.
func();
return 0;
}
If we compile and run above
code, this would produce following result:
Inside first_space
The using directive can also
be used to refer to a particular item within a namespace. For example, if the
only part of the std namespace that you intend to use is cout, you can refer to
it as follows:
using std::cout;
Subsequent
code can refer to cout without prepending the namespace, but other items in the stdnamespace will still need to
be explicit as follows:
#include <iostream>
using std::cout;
int main ()
{
cout << "std::endl is used with std!" << std::endl;
return 0;
}
If we compile and run above
code, this would produce following result:
std::endl is used with std!
Names
introduced in a using directive obey normal scope rules. The
name is visible from the point of the using directive to the end of the scope in
which the directive is found. Entities with the same name defined in an outer
scope are hidden.
Discontiguous
Namespaces:
A namespace can be defined in
several parts and so a namespace is made up of the sum of its separately
defined parts. The separate parts of a namespace can be spread over multiple
files.
So, if one part of the
namespace requires a name defined in another file, that name must still be declared.
Writing a following namespace definition either defines a new namespace or adds
new elements to an existing one:
namespace namespace_name {
// code declarations
}
Nested
Namespaces:
Namespaces can be nested
where you can define one namespace inside another name space as follows:
namespace namespace_name1 {
// code declarations
namespace namespace_name2 {
// code declarations
}
}
You can access members of
nested namespace by using resultion operators as follows:
// to access members of namespace_name2
using namespace namespace_name1::namespace_name2;
// to access members of namespace:name1
using namespace namespace_name1;
In the above statements if
you are using namespace_name1 then it will make elements of namespace_name2 available
in the scope as follows:
#include <iostream>
using namespace std;
// first name space
namespace first_space{
void func(){
cout << "Inside first_space" << endl;
}
// second name space
namespace second_space{
void func(){
cout << "Inside second_space" << endl;
}
}
}
using namespace first_space::second_space;
int main ()
{
// This calls function from first name space.
func();
return 0;
}
If we compile and run above
code, this would produce following result:
Inside second_space
No comments:
Post a Comment