C++中的命名空间|集合4(不同名称空间中的数据过载和交换)

先决条件：

• C++中的命名空间|设置1(简介)
• C++中的命名空间|集合2(扩展名称空间和未命名名称空间)
• C++中的命名空间|设置3(访问，创建标题，嵌套和别名)

在本文中，我们将讨论不同名称空间之间的数据共享的概念，如何访问和重载标准运算符以在用户定义的名称空间内为用户定义的类工作，以及它们的实现。
在C++中，我们可以在不同的名称空间中创建类，并且这些类的范围限于创建它们的名称空间。因此，我们必须使用范围解析运算符(：:)访问这些类。

以下是了解名称空间中类的声明和程序中对象的初始化的实现：

// C++ program to illustrate the basics
// of classes inside namespaces
#include 
#include 
  
// 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!

在上面的程序中，我们可以清楚地看到GeeksforGeeks命名空间中的类‘ 字符串 ‘的作用域仅在命名空间中，并且该类由参数化构造函数初始化，该构造函数还更改了命名空间Test中Class字符串的私有字符串‘ 。

以下程序说明了使用不同名称空间类对象作为参数的运算符重载以及从一个名称空间到另一名称空间的数据访问和交换的概念：

// C++ program to show overloading and
// accessing from different namespaces
#include 
#include 
  
// 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!

解释：

1. 在上面的程序中，我们创建了三个名称空间– test_space1，test_space2和test_space3 。
2. 所有这些名称空间中都有一个通用的类字符串。我们创建了它们各自的对象s2，s3和s4 ，它们在初始化期间采用不同的参数。
3. 名称空间test_space 3用于从名称空间test_space2的字符串类内部访问类成员，因此， test_space3 :: string的构造函数与其他两个类的构造函数不同。
4. 因此，我们能够从test_space2访问数据并将其用于test_space3 。这显示了不同命名空间及其类之间的数据可访问性和交换。

想要从精选的最佳视频中学习和练习问题，请查看有关从基础到高级C++的C++基础课程以及有关语言和STL的C++ STL课程。要完成从学习语言到DS Algo等的更多准备工作，请参阅“完整面试准备课程” 。