Espacio de nombres en C++ | Serie 1 (Introducción)

Considere el siguiente programa en C++: 

// A program to demonstrate need of namespace
int main()
{
    int value;
    value = 0;
    double value; // Error here
    value = 0.0;
}

Producción :

Compiler Error:
'value' has a previous declaration as 'int value'

En cada ámbito, un nombre solo puede representar una entidad. Por lo tanto, no puede haber dos variables con el mismo nombre en el mismo ámbito. Usando espacios de nombres, podemos crear dos variables o funciones miembro que tengan el mismo nombre. 

// Here we can see that more than one variables
// are being used without reporting any error.
// That is because they are declared in the
// different namespaces and scopes.
#include <iostream>
using namespace std;
 
// Variable created inside namespace
namespace first
{
    int val = 500;
}
 
// Global variable
int val = 100;
 
int main()
{
    // Local variable
    int val = 200;
 
    // These variables can be accessed from
    // outside the namespace using the scope
    // operator ::
    cout << first::val << '\n';
 
    return 0;
}

Producción:

500

 Definición y creación: los espacios de nombres nos permiten agrupar entidades con nombre que de otro modo tendrían un alcance global en alcances más estrechos, dándoles un alcance de espacio de nombres . Esto permite organizar los elementos de los programas en diferentes ámbitos lógicos denominados por nombres. Los espacios de nombres proporcionan el espacio donde podemos definir o declarar identificadores, es decir, nombres de variables, métodos, clases, etc.

• El espacio de nombres es una función agregada en C++ y no está presente en C.
• Un espacio de nombres es una región declarativa que proporciona un alcance a los identificadores (nombres de funciones, variables u otros tipos de datos definidos por el usuario) dentro de él.
• Se permiten varios bloques de espacio de nombres con el mismo nombre. Todas las declaraciones dentro de esos bloques se declaran en el ámbito nombrado.

Una definición de espacio de nombres comienza con la palabra clave espacio de nombres seguida del nombre del espacio de nombres de la siguiente manera:

namespace namespace_name 
{
   int x, y; // code declarations where 
             // x and y are declared in 
             // namespace_name's scope
}

• Las declaraciones de espacio de nombres aparecen solo en el ámbito global.
• Las declaraciones de espacio de nombres se pueden anidar dentro de otro espacio de nombres.
• Las declaraciones de espacio de nombres no tienen especificadores de acceso (público o privado).
• No es necesario dar un punto y coma después de la llave de cierre de la definición de espacio de nombres.
• Podemos dividir la definición de espacio de nombres en varias unidades.

Definición de un espacio de nombres:

Una definición de espacio de nombres comienza con la palabra clave espacio de nombres seguida del nombre del espacio de nombres de la siguiente manera: espacio de nombres nombre_espacio de
nombres{
     // declaraciones de código, es decir, variable (int a;)
     método (void add();)
     clases ( class estudiante{};)
}

Cabe señalar que no hay punto y coma (;) después de la llave de cierre.
Para llamar a la versión habilitada para espacios de nombres de una función o una variable, anteponga el nombre del espacio de nombres de la siguiente manera:

nombre_espacio_de_nombres: :código; // el código puede ser una variable, una función o una clase.

// 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 the following result:
// Inside first_space
// Inside second_space

Inside first_space
Inside second_space

La directiva de uso:

Puede evitar la anteposición de espacios de nombres con la directiva de uso de espacios de nombres. Esta directiva le dice al compilador que el código subsiguiente está haciendo uso de nombres en el espacio de nombres especificado. Por lo tanto, el espacio de nombres está implícito para el siguiente código:

#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 the following result:
// Inside first_space

Inside first_space

La directiva de uso también se puede usar para hacer referencia a un elemento en particular dentro de un espacio de nombres. Por ejemplo, si la única parte del espacio de nombres estándar que desea utilizar es cout, puede hacer referencia a él de la siguiente manera:
using std::cout;
El código subsiguiente puede hacer referencia a cout sin anteponer el espacio de nombres, pero otros elementos en el espacio de nombres estándar aún deberán ser explícitos de la siguiente manera:
#include <iostream>
usando std::cout;
 

#include <iostream>
using namespace std;
 
int main ()
{
    cout << "std::endl is used with std!" << std::endl;
      return 0;
}

std::endl is used with std!

Los nombres introducidos en una directiva de uso obedecen las reglas de alcance normales, es decir, son visibles desde el punto en que ocurre la directiva de uso hasta el final del alcance en el que se encuentra la directiva. Las entidades con el mismo nombre definidas en un ámbito externo están ocultas.

// Creating namespaces
#include <iostream>
using namespace std;
namespace ns1
{
    int value()    { return 5; }
}
namespace ns2
{
    const double x = 100;
    double value() {  return 2*x; }
}
 
int main()
{
    // Access value function within ns1
    cout << ns1::value() << '\n';
 
    // Access value function within ns2
    cout << ns2::value() << '\n';
 
    // Access variable x directly
    cout << ns2::x << '\n';      
 
    return 0;
}

Producción:

5
200
100

 Clases y espacio de nombres: la siguiente es una forma sencilla de crear clases en un espacio de nombres: 

// A C++ program to demonstrate use of class
// in a namespace
#include<iostream>
using namespace std;
 
namespace ns
{
    // A Class in a namespace
    class geek
    {
    public:
        void display()
        {
            cout<<"ns::geek::display()"<<endl;;
        }
    };
}
 
int main()
{
    // Creating Object of geek Class
    ns::geek obj;
 
    obj.display();
 
    return 0;
}

ns::geek::display()

Una clase también puede declararse dentro del espacio de nombres y definirse fuera del espacio de nombres usando la siguiente sintaxis: 

// A C++ program to demonstrate use of class
// in a namespace
#include <iostream>
using namespace std;
 
namespace ns
{
    // Only declaring class here
    class geek;
}
 
// Defining class outside
class ns::geek
{
public:
    void display()
    {
        cout << "ns::geek::display()\n";
    }
};
 
int main()
{
    //Creating Object of geek Class
    ns::geek obj;
    obj.display();
    return 0;
}

Producción:

ns::geek::display()

También podemos definir métodos fuera del espacio de nombres . El siguiente es un código de ejemplo: 

// A C++ code to demonstrate that we can define
// methods outside namespace.
#include <iostream>
using namespace std;
 
// Creating a namespace
namespace ns
{
    void display();
    class geek
    {
    public:
       void display();
    };
}
 
// Defining methods of namespace
void ns::geek::display()
{
    cout << "ns::geek::display()\n";
}
void ns::display()
{
    cout << "ns::display()\n";
}
 
// Driver code
int main()
{
    ns::geek obj;
    ns::display();
    obj.display();
    return 0;
}

Producción:

ns::display()
ns::geek::display()

Espacios de nombres anidados:

Los espacios de nombres se pueden anidar, es decir, puede definir un espacio de nombres dentro de otro espacio de nombres de la siguiente manera:

namespace namespace_name1 {
  // declaraciones de código
  namespace namespace_name2 {
     // declaraciones de código
  }
}

Puede acceder a los miembros de un espacio de nombres anidado mediante el operador de resolución (::) de la siguiente manera:
// para acceder a los miembros del espacio de nombres_nombre2
usando el espacio de nombres nombre_espacio_de nombres1::nombre_espacio_de_nombres2;
// para acceder a los miembros del espacio de nombres: nombre1
usando el espacio de nombres nombre_espacio de nombres1;
En las declaraciones anteriores, si está utilizando namespace_name1, hará que los elementos de namespace_name2 estén disponibles en el alcance de la siguiente manera:
 

#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 second name space.
   func();
    
   return 0;
}
 
// If we compile and run above code, this would produce the following result:
// Inside second_space

Inside second_space

El espacio de nombres proporciona la ventaja de evitar la colisión de nombres: –

Por ejemplo, podría estar escribiendo un código que tiene una función llamada xyz() y hay otra biblioteca disponible en su código que también tiene la misma función xyz(). Ahora el compilador no tiene forma de saber a qué versión de la función xyz() te refieres dentro de tu código.
Un espacio de nombres está diseñado para superar esta dificultad y se utiliza como información adicional para diferenciar funciones, clases, variables, etc. similares con el mismo nombre disponible en diferentes bibliotecas. 
El mejor ejemplo de ámbito de espacio de nombres es la biblioteca estándar de C++ (std), donde se declaran todas las clases, métodos y plantillas. Por lo tanto, mientras escribimos un programa en C++, generalmente incluimos la directiva 
usando el espacio de nombres std;
 

espacio de nombres en C++ | Conjunto 2 (espacio de nombres ampliado y espacio de nombres sin nombre) Espacio de nombres en C++ | Conjunto 3 (Acceso, creación de encabezado, anidamiento y alias) ¿Se pueden anidar los espacios de nombres en C++? Referencia : http://www.cplusplus.com/doc/tutorial/namespaces/ Este artículo es una contribución de Abhinav Tiwari . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.