Namespaces in C++ | What does Namespaces in C++ Mean?

Namespaces in C++

Take into consideration a circumstance when we now have two folks with the same title, Zara, in the same class. At no matter level we have to separate them, we would wish to make the most of some additional information alongside their title, as both the territory, in the event that they stay in numerous areas or their mother’s or father’s title, and so forth. 

The identical circumstance can emerge in your C++ purposes. For example, you could be pondering of some code that has a capability known as xyz(), and there’s one other library accessible which is likewise having the identical capability xyz(). Presently the compiler has no likelihood to know which variant of xyz() work you’re alluding to inside your code. 

A namespace is meant to beat this bother. It’s utilized as additional information to separate comparative capacities, courses, components, and the same title accessible in numerous libraries. Utilizing namespace, you may characterize the setting the place names are characterised. A namespace characterizes a level.


Namespaces allow us to bunch named components that in any case would have a worldwide diploma into smaller extensions, giving them namespace scope. This allows placing collectively the parts of tasks into numerous constant extensions alluded to by names.

  • Namespace is a element included C++ and never current in C. 
  • A namespace is a revelatory district that offers a level to the identifiers (names of the varieties, work, components and so forth) inside it. 
  • Numerous namespace blocks with the same title are permitted. All displays inside these squares are proclaimed within the named scope.
  • Namespaces in C++ are utilized to coordinate such a lot of courses with the aim that it tends to be not troublesome to cope with the applying. 
  • For attending to the category of a namespace, we have to make the most of namespacename::classname. We are able to make the most of catchphrases with the aim that we don’t have to make the most of whole names continuously. 
  • In C++, worldwide namespace is the basis namespace. The worldwide::std will constantly allude to the namespace “sexually transmitted illness” of C++ Framework.

A namespace definition begins with the catchphrase namespace adopted by the namespace title as follows:

namespace namespace_name 

Utilizing directives:

The utilizing directive permits each one of many names in a namespace for use with out the namespace-name as an express qualifier. Make the most of a utilizing directive in an execution doc (for instance *.cpp) on the off likelihood that you’re using a couple of distinctive identifiers in a namespace; assuming you’re merely using a few identifiers, take into account a using-declaration to only convey these identifiers into the scope and never each one of many identifiers within the namespace. On the off likelihood close by issue has the same title as a namespace variable, the namespace variable is roofed up. It’s an error to have a namespace variable with the same title as a worldwide variable.

The International Namespace:

On the off likelihood that an identifier isn’t pronounced in an unequivocal namespace, it’s important for the implied worldwide namespace. By and huge, try to not make revelations at a worldwide diploma each time the state of affairs permits, other than the part level main Operate, which is required within the worldwide namespace. To expressly qualify a worldwide identifier, make the most of the diploma aim administrator with no title, as in::SomeFunction(x);. This may separate the identifier from something with the same title in another namespace, and it’ll likewise help with making your code less complicated for others to understand.

Declaring namespaces and namespace members:

Ordinarily, you pronounce a namespace in a header file. On the off likelihood that your capability executions are in a distinct file, qualify the capability names, as on this mannequin.

#pragma as soon as
namespace ContosoDataServer

    void Foo();
    int Bar();

Operate implementations in contosodata.cpp ought to use the absolutely certified title, even should you place a utilizing directive on the high of the file:

#embody "contosodata.h"
utilizing namespace ContosoDataServer;

void ContosoDataServer::Foo() // use fully-qualified title right here

   // no qualification wanted for Bar()

int ContosoDataServer::Bar()return zero;

A namespace might be introduced in numerous squares in a solitary doc and numerous data. The compiler consolidates the elements throughout preprocessing, and the next namespace comprises each one of many people pronounced the elements altogether. An illustration of that is the sexually transmitted illness namespace introduced in each one of many header data in the usual library. 

People from a named namespace might be characterised exterior the namespace through which they’re proclaimed by the categorical functionality of the title being characterised. Nonetheless, the definition ought to present up after the mark of presentation in a namespace that encases the affirmation’s namespace. For example:

// defining_namespace_members.cpp
// C2039 anticipated
namespace V 

void V::f()          // okay
void V::g()          // C2039, g() is just not but a member of V

namespace V 

This error can happen when the namespace members are declared throughout a number of header information, and you haven’t included these headers within the appropriate order.

The std Namespace:

All C++ commonplace library sorts and capabilities are declared within the std namespace or namespaces nested inside std.


  • Namespace declarations present up simply at worldwide levels. 
  • Namespace declaration might be settled inside one other namespace. 
  • Namespace declarations don’t method specifiers. (Public or personal) 
  • No compelling motive to offer semicolon after the top help of the which means of namespace. 
  • We are able to half the which means of a namespace with quite a lot of items.
// Creating namespaces
#embody <iostream>
utilizing namespace std;
namespace ns1

namespace ns2 

    const double x = 100;
    double worth() 

int most important()





Nested Namespaces:

Namespaces might be settled the place you may characterize one namespace inside one other title house as follows –

namespace namespace_name1 

You may get to people from settled namespace by means of decision operators as follows –

// to entry members of namespace_name2
utilizing namespace namespace_name1::namespace_name2;

// to entry members of namespace:name1
utilizing namespace namespace_name1;

Within the above articulations assuming you’re utilizing namespace_name1, it should make parts of namespace_name2 accessible within the scope as follows –

#embody <iostream>
utilizing namespace std;

// first title house
namespace first_space 

utilizing namespace first_space::second_space;
int most important () 
   // This calls perform from second title house.
   return zero;

If we compile and run above code, this could produce the next outcome –

Inside second_space

Inline Namespaces:

Fairly than a standard settled namespace, people from an inline namespace are handled as people from the mother or father namespace. This trademark empowers subordinate rivalry queries on over-burden capacities to chip away at capacities with over-burdens in a mother or father and a settled inline namespace. It moreover empowers you to proclaim a specialization in a mother or father namespace for a structure that’s pronounced within the inline namespace. The accompanying mannequin exhibits how outer code ties to the inline namespace naturally:

#embody <string>

namespace Check

    namespace old_ns
        std::string Func()  return std::string("Whats up from previous"); 

    inline namespace new_ns
        std::string Func()  return std::string("Whats up from new"); 

#embody "header.h"
#embody <string>
#embody <iostream>

int most important()

    utilizing namespace Check;
    utilizing namespace std;

    string s = Func();
    std::cout << s << std::endl; // "Whats up from new"
    return zero;

The next instance exhibits how one can declare a specialization in a mother or father of a template that’s declared in an inline namespace:

namespace Guardian

Namespace aliases:

You possibly can make the most of inline namespaces as a forming element to supervise modifications to the general public interface. For example, you can also make a solitary mother or father namespace and epitomize each type of the interface in its namespace settled contained in the mother or father. The namespace that holds the most recent or favoured adaptation is certified as inline and is accordingly uncovered as a right away particular person from the mother or father namespace. Buyer code that conjures the Guardian::Class will consequently tie to the brand new code. Prospects that prefer to make the most of the extra seasoned variant can, in any case, get to it by using the utterly certified technique to the settled namespace that has that code. 

The accompanying mannequin exhibits two variants of an interface, every in a settled namespace. The v_20 namespace has some adjustment from the v_10 interface and is ready aside as inline. Buyer code that makes use of the brand new library and calls Contoso::Funcs::Add will summon the v_20 variant. Code that endeavors to name Contoso::Funcs::Divide will presently get an assemble time blunder. On the off likelihood that they really want that work, they will in any case get to the v_10 kind by unequivocally calling Contoso::v_10::Funcs::Divide.

namespace Contoso

Nameless or unnamed namespaces:

You possibly can create an express namespace however not give it a reputation:


    int MyFunc()

That is known as an nameless or unknown namespace. It’s invaluable to make variable affirmations imperceptible to code in numerous data (for instance, give them inside linkage) with out making a named namespace. All code in the same file can see the identifiers in an nameless namespace. But, the identifiers, alongside the namespace itself, usually are not noticeable exterior that doc—or all of the extra unequivocally exterior the interpretation unit.

Scope decision operator (::):

We are able to explicitly specify any title declared in a namespace utilizing the namespace’s title and the scope decision “::” operator with the identifier.

namespace New_space

// Initializing static class variable
int New_space::X::i=23;      
class New_space::Y

    int a;
    int getdata()
        cout << a;
    // Constructor declaration

// Constructor definition explicitly


Discontiguous Namespace in C++:

As we most likely know, a namespace in C++ might be characterised in a couple of sections; therefore it consists of the quantity of its independently characterised elements. Thus, if one piece of the namespace requires a reputation characterised in one other doc, that title ought to, in any case, be introduced in its extension. Composing the accompanying namespace in an accompanying manner both characterizes one other namespace or provides new parts to a present one:


The usual library comprises the fundamental usefulness you employ in constructing your purposes like holders, calculations, and so forth. On the off likelihood that names utilized by these had been out within the open, as an illustration, in the event that they characterised a line class around the globe, you’d all the time be unable to make the most of the same title once more with out clashes. So that they made a namespace, sexually transmitted illness to comprise this variation.


Calls to capabilities might be ambiguous if they’re outlined in a couple of place.
To disambiguate, we use the prefix NameOfNamespace:: earlier than the perform. That is much less dangerous when utilizing a number of libraries.

This brings us to the top of the weblog on Namespaces in C++. We hope that you just had been capable of acquire complete data about Namespaces in C++. In the event you want to be taught extra such ideas in programming, do try Nice Studying Academy’s Free On-line Programs and upskill at the moment.



Leave a Comment