C++中的命名空间——集合4（不同名称空间中的数据过载和交换）

命名空间是C++中一个非常有用的特性，它允许我们在全局作用域内定义同名实体而不会出现重名的问题。本文将介绍如何在不同的命名空间中进行数据过载和交换，从而扩展我们的程序设计能力。

数据过载

数据过载（Overloading）是指在同一个作用域内定义多个同名的函数或运算符，并且这些函数或运算符具有不同的参数列表。C++中允许我们在同一个命名空间中进行数据过载，也允许在不同的命名空间中进行数据过载。

同名实体的不同命名空间中的数据过载

当我们在全局作用域和命名空间中定义相同名称的函数或变量时，它们并不会冲突，而是存在于不同的命名空间中。我们可以使用作用域操作符::来指定哪个命名空间中的实体应该被使用。例如：

#include<iostream>

namespace ns1 {
    int x = 10;
}

namespace ns2 {
    int x = 20;
}

int main() {
    std::cout << ns1::x << std::endl;  // 输出10
    std::cout << ns2::x << std::endl;  // 输出20
    std::cout << x << std::endl;  // 报错，无法确定使用哪个命名空间中的x
    std::cout << ::x << std::endl;  // 输出0，全局作用域中没有定义过x，所以会使用默认值0
    return 0;
}

在上面的例子中，我们在两个不同的命名空间ns1和ns2中定义了同名的变量x，我们使用作用域操作符来访问它们分别存储在不同的命名空间中的值。

同名实体的同一命名空间中的数据过载

如果我们在同一个命名空间中定义了两个同名的函数或变量，那么它们将出现冲突，我们需要使用数据过载来解决冲突。

例如：

#include<iostream>

namespace ns {
    int x = 10;
    void foo() {
        std::cout << "ns::foo()" << std::endl;
    }
    void foo(int x) {
        std::cout << "ns::foo(int)" << std::endl;
    }
}

int main() {
    std::cout << ns::x << std::endl;  // 输出10
    ns::foo();  // 输出ns::foo()
    ns::foo(1);  // 输出ns::foo(int)
    return 0;
}

在上面的例子中，我们在命名空间ns中定义了一个变量x和两个同名的函数foo，但这两个函数参数列表不同，因此我们可以通过传递不同参数的方式来调用它们。

数据交换

数据交换（Swapping）是指交换两个数据的值。在C++中，我们可以使用STL中的std::swap函数来交换两个变量的值，它通过传递变量的地址来实现变量值的交换。但是，如果我们想对自己的类或自定义类型实现数据交换，我们需要自己定义swap函数。

使用自定义类型实现数据交换

我们可以使用自己的类或自定义类型实现数据交换，我们需要定义一个名为swap的函数，它应该是一个非成员函数。在swap函数中，我们应该通过传递引用的方式来交换两个对象的值。例如：

#include<iostream>

class Person {
public:
    Person(std::string name, int age) : name(name), age(age) {}
    std::string getName() const { return name; }
    int getAge() const { return age; }
private:
    std::string name;
    int age;
};

void swap(Person& p1, Person& p2) {
    std::swap(p1, p2);
}

int main() {
    Person p1("Tom", 18);
    Person p2("Jerry", 20);
    std::cout << "Before swapping:" << std::endl;
    std::cout << "p1: name=" << p1.getName() << ", age=" << p1.getAge() << std::endl;
    std::cout << "p2: name=" << p2.getName() << ", age=" << p2.getAge() << std::endl;

    swap(p1, p2);

    std::cout << "After swapping:" << std::endl;
    std::cout << "p1: name=" << p1.getName() << ", age=" << p1.getAge() << std::endl;
    std::cout << "p2: name=" << p2.getName() << ", age=" << p2.getAge() << std::endl;
    return 0;
}

在上面的例子中，我们使用自定义类型Person实现数据交换。我们定义了一个名为swap的非成员函数，并通过传递引用的方式来交换两个Person对象的值。

使用自定义类实现数据交换

我们还可以使用自定义类来实现数据交换。在自定义类中我们需要定义一个swap方法，这个方法应该交换当前对象的值和传递的对象的值。例如：

#include<iostream>

class Integer {
public:
    Integer(int value = 0) : value(value) {}
    int getValue() const { return value; }
    void swap(Integer& other) {
        std::swap(value, other.value);
    }
private:
    int value;
};

int main() {
    Integer i1(10);
    Integer i2(20);
    std::cout << "Before swapping:" << std::endl;
    std::cout << "i1.value=" << i1.getValue() << std::endl;
    std::cout << "i2.value=" << i2.getValue() << std::endl;

    i1.swap(i2);

    std::cout << "After swapping:" << std::endl;
    std::cout << "i1.value=" << i1.getValue() << std::endl;
    std::cout << "i2.value=" << i2.getValue() << std::endl;
    return 0;
}

在上面的例子中，我们使用自定义类Integer实现数据交换。我们定义了一个名为swap的成员函数，这个方法应该交换当前对象的值和传递的对象的值。

总结

本文介绍了命名空间中的数据过载和数据交换的使用。我们可以在同一命名空间中定义同名实体，可以在不同的命名空间中定义同名实体。同时，我们还可以使用自定义类型和自定义类来实现数据交换。命名空间是一个非常有用的特性，可以帮助我们更好地组织我们的代码，使代码更加模块化和可维护。