Requisito previo:
- Espacio de nombres en C++ | Serie 1 (Introducción)
- 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)
En este artículo, discutiremos el concepto de intercambio de datos entre diferentes espacios de nombres, cómo acceder y sobrecargar operadores estándar para trabajar con clases definidas por el usuario dentro de espacios de nombres definidos por el usuario y su implementación.
En C++ , podemos crear clases dentro de diferentes espacios de nombres y el alcance de esas clases se limita al espacio de nombres en el que se crean. Por lo tanto, debemos acceder a esas clases usando el operador de resolución de alcance (::) .
A continuación se muestra la implementación para comprender la declaración de clases dentro de un espacio de nombres y la inicialización de objetos en el programa:
CPP
// C++ program to illustrate the basics
// of classes inside namespaces
#include <iostream>
#include <string>
// Declaration of namespace
namespace GeeksforGeeks {
// Output string
std::string out = "This is not from (GeeksforGeeks::string) class!";
// Class inside GeeksforGeeks namespace
class string {
private:
std::string s = "Hello! ";
public:
// Make string
string(const std::string& str)
{
s += str;
}
// Function to get string
std::string get_str()
{
return s;
}
};
};
// Driver Code
int main()
{
std::cout << GeeksforGeeks::out
<< std::endl;
// Create an object of string class
// of Test namespace
GeeksforGeeks::string str("From namespace Test!");
// Print the string
std::cout << str.get_str()
<< std::endl;
return 0;
}
This is not from (GeeksforGeeks::string) class! Hello! From namespace Test!
En el programa anterior, podemos ver claramente que el alcance de la clase ‘string’ dentro del espacio de nombres GeeksforGeeks estaba solo dentro del espacio de nombres y la clase fue inicializada por el constructor parametrizado que también cambió la string privada ‘s’ de la string de Clase dentro del espacio de nombres Prueba .
El siguiente programa es la ilustración de los conceptos de sobrecarga de operadores con diferentes objetos de clase de espacio de nombres como parámetros y acceso e intercambio de datos de un espacio de nombres a otro espacio de nombres :
CPP
// C++ program to show overloading and
// accessing from different namespaces
#include <iostream>
#include <string>
// Declare namespace test_space1
namespace test_space1 {
const std::string const_prefix = "(test_space1::string) ";
// String class
class string {
private:
std::string str = "";
// Private default constructor
string();
public:
// Public parameterized constructor
string(const std::string& s)
: str(const_prefix + s)
{
}
// Get string function
std::string get_str() const
{
return str;
}
};
};
// Declare namespace test_space2
namespace test_space2 {
const std::string const_prefix = "(test_space2::string) ";
class string {
private:
std::string str = "";
const std::string check_scope = "test_space2!";
string();
public:
// Public parameterized constructor
string(const std::string& s)
: str(const_prefix + s)
{
}
std::string get_str() const
{
return str;
}
std::string getScopestr() const
{
return check_scope;
}
};
};
// Declare namespace test_space3
namespace test_space3 {
// Object from another namespace
// (test_space2 in this case!)
const std::string const_prefix = "(test_space3::string) from both nmspaces test_space3 & ";
// Class inside namespace test_space3
class string {
std::string str = "";
string();
public:
string(const test_space2::string& s)
: str(const_prefix + s.getScopestr())
{
}
// Access function from test_space2
// and adding a private string of
// test_space2:: string to str of
// test_space3
std::string get_str() const
{
return str;
}
};
};
// Overloading << operator for test_space1
std::ostream& operator<<(std::ostream& os,
const test_space1::string& s1)
{
os << s1.get_str();
return os;
}
// Overloading << operator for test_space2
std::ostream& operator<<(std::ostream& os,
const test_space2::string& s2)
{
os << s2.get_str();
return os;
}
// Overloading << operator for test_space3
std::ostream& operator<<(std::ostream& os,
const test_space3::string& s3)
{
os << s3.get_str();
return os;
}
// Driver Code
int main()
{
// String str
const std::string str("This is a standard string");
// Print the string str
std::cout << str << std::endl;
const std::string sample1("This is a test_space1 namespace string");
// Declare a test_space1 namespace
// string class object
const test_space1::string s2(sample1);
std::cout << s2 << std::endl;
// Print test_space1 string
const std::string sample2("This is a test_space2 namespace string");
// std string
test_space2::string s3(sample2);
// Declare a test_space2 namespace
// string class object
std::cout << s3 << std::endl;
// Print test_space2 string
test_space3::string s4(s3);
// Print string s4
std::cout << s4 << std::endl;
return 0;
}
This is a standard string (test_space1::string) This is a test_space1 namespace string (test_space2::string) This is a test_space2 namespace string (test_space3::string) Accessing from both namespaces test_space3 and test_space2!
Explicación:
- En el programa anterior, hemos creado tres espacios de nombres: test_space1, test_space2 y test_space3 .
- Todos estos espacios de nombres tienen una string de clase común en ellos. Hemos creado sus respectivos objetos s2, s3 y s4 que toman diferentes parámetros durante la inicialización.
- El espacio de nombres test_space 3 se usa para acceder a los miembros de la clase desde dentro de la clase de string del espacio de nombres test_space2 y, por lo tanto, el constructor de test_space3::string es diferente de los otros dos constructores de clases.
- Entonces, podemos acceder a los datos de test_space2 y usarlos en test_space3 . Esto muestra la Accesibilidad y el Intercambio de Datos entre diferentes Namespaces y sus Clases.