swap函数的用法

swap函数在C++中用于交换两个变量的值，提供了高效且类型安全的方式来交换两个对象的内容，而不需要显式地创建临时变量。

C++标准库中提供了泛型版本的swap函数，位于<utility>头文件中，可以用于基本数据类型和标准库容器等多种类型。

基本用法

对于基本数据类型，你可以直接使用std::swap：

#include <utility>
int main() {
    int a = 5, b = 10;
    std::swap(a, b); // 现在 a = 10, b = 5
}

对象交换

对于自定义类型（类的对象），如果类定义了移动赋值运算符和移动构造函数，swap函数可以更高效地工作。如果没有自定义实现，std::swap会尝试使用类提供的拷贝构造函数和赋值运算符来交换对象的内容。

class MyClass {
public:
    int value;
    // ... 其他成员函数
};
MyClass obj1{1}, obj2{2};
std::swap(obj1, obj2); // 交换obj1和obj2的value

容器交换

对于标准库容器，如std::vector、std::list等，swap函数可以非常高效地交换两个容器的所有元素，因为它通常只需要交换容器的内部指针或引用计数，而不是实际复制元素。

#include <vector>
#include <iostream>
int main() {
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    std::cout << "Before swap:\nvec1 = ";
    for (int i : vec1) std::cout << i << ' ';
    std::cout << "\nvec2 = ";
    for (int i : vec2) std::cout << i << ' ';
    std::cout << '\n';    
    vec1.swap(vec2); // 交换两个vector的内容    
    std::cout << "After swap:\nvec1 = ";
    for (int i : vec1) std::cout << i << ' ';
    std::cout << "\nvec2 = ";
    for (int i : vec2) std::cout << i << ' ';
    std::cout << '\n';
}

自定义swap函数

对于复杂类型，特别是那些包含资源管理的类，建议在类的实现中提供一个swap成员函数或非成员友元函数来定制交换逻辑，以确保资源正确处理且交换操作高效执行。

class ComplexClass {
    // ... 成员变量和方法
public:
    friend void swap(ComplexClass& first, ComplexClass& second) noexcept {
        // 实现具体的交换逻辑
    }
};

模板实现

C++标准库中的std::swap是一个模板函数，可以处理多种类型：

template <typename T>
void swap(T& a, T& b) {
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}

使用了std::move来优化交换过程，尤其是在对象具有移动语义时。不过，通常直接使用std::swap而不重新定义自己的版本是推荐的做法，除非你需要特定的优化或行为。

Python 的 enumerate() 和列表推导式交换

虽然直接元组解包是最简洁的交换方法，但也可以利用enumerate()和列表推导式在原地交换列表中满足特定条件的元素：

lst = [1, 2, 3, 4]
swap_indices = [(i, j) for i, val_i in enumerate(lst) for j, val_j in enumerate(lst) if i < j and val_i > val_j]
for i, j in swap_indices:
    lst[i], lst[j] = lst[j], lst[i]
print(lst)  # 这里示例逻辑是 Bubble Sort 的一部分，用于升序排列

JavaScript 的解构赋值与 map()

在JavaScript中，除了基础的解构赋值外，还可以利用map()方法间接达到交换对象属性的效果：

let obj1 = {name: 'Alice', age: 30};
let obj2 = {name: 'Bob', age: 25};
[obj1, obj2] = [obj2, obj1]; // 直接交换整个对象

对于数组内的复杂对象交换，可以通过映射（map）并根据某些条件调整：

let people = [{name: 'Alice', age: 30}, {name: 'Bob', age: 25}];
people = people.map(person => person.name === 'Alice' ? {...person, age: 35} : person);
// 上述代码虽不直接交换，但展示了基于条件更新对象的思路

C++ 的 std::exchange

std::exchange函数在C++中提供了交换并返回旧值的能力，常用于资源管理或线程安全的场景：

#include <iostream>
#include <utility>
int main() {
    int a = 5, b = 10;
    int oldA = std::exchange(a, b); // a 现在是10, oldA是5
    std::cout << "a = " << a << ", oldA = " << oldA << std::endl;
}

Rust 的 std::mem::replace

类似于std::exchange，Rust标准库提供了std::mem::replace函数，用于替换并获取被替换的值：

use std::mem;
let mut some_value = Some(2);
let replaced_value = mem::replace(&mut some_value, None); // some_value现在是None, replaced_value是Some(2)