C语言swap函数如何正确使用？

核心问题：为什么不能直接交换？

你必须理解C语言的函数调用机制是“传值调用”（Pass-by-Value），这意味着当你调用一个函数时，函数会创建一份参数的副本,而不是使用原始变量本身。

错误示范：

#include <stdio.h>
// 错误的swap函数
void swap_wrong(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    // 这里的交换只发生在a和b的副本上
    // 函数结束后，副本被销毁，原始变量不受影响
}
int main() {
    int x = 10;
    int y = 20;
    printf("交换前: x = %d, y = %d\n", x, y);
    swap_wrong(x, y); // 尝试交换
    printf("交换后: x = %d, y = %d\n", x, y); // 结果没有改变
    return 0;
}

输出：

交换前: x = 10, y = 20
交换后: x = 10, y = 20

可以看到，x和y的值根本没有改变，因为swap_wrong函数内部操作的是x和y的副本，而不是x和y本身。

使用指针（最经典、最安全的方法）

这是最常用、最标准、也是最安全的方法，通过传递变量的地址,函数可以间接地访问和修改原始变量。

原理：

1. 在函数参数中，我们使用指针类型（如 int*）来接收变量的地址。
2. 在函数内部，我们通过解引用操作符 来访问或修改指针指向的内存地址中的值。
3. 交换的是指针所指向的值,也就是原始变量的值。

代码示例：

#include <stdio.h>
// 正确的swap函数，使用指针
void swap_with_pointers(int *pa, int *pb) {
    int temp = *pa; // 解引用pa，获取a的值，存入temp
    *pa = *pb;     // 将b的值赋给a
    *pb = temp;     // 将temp的值（原来的a的值）赋给b
}
int main() {
    int x = 10;
    int y = 20;
    printf("交换前: x = %d, y = %d\n", x, y);
    // 传递x和y的地址（使用 & 运算符）
    swap_with_pointers(&x, &y);
    printf("交换后: x = %d, y = %d\n", x, y);
    return 0;
}

输出：

交换前: x = 10, y = 20
交换后: x = 20, y = 10

这次交换成功了！swap_with_pointers函数通过地址成功修改了main函数中的x和y。

使用全局变量（不推荐，但需了解）

你可以将要交换的变量声明为全局变量，这样任何函数都可以直接访问它们,但这是一种非常糟糕的编程实践。

原理： 全局变量存储在程序的静态存储区，生命周期贯穿整个程序，任何函数都可以直接访问它们,无需作为参数传递。

代码示例：

#include <stdio.h>
// 不推荐！使用全局变量
int x_global, y_global;
void swap_with_globals() {
    int temp = x_global;
    x_global = y_global;
    y_global = temp;
}
int main() {
    x_global = 10;
    y_global = 20;
    printf("交换前: x = %d, y = %d\n", x_global, y_global);
    swap_with_globals(); // 不需要传参数
    printf("交换后: x = %d, y = %d\n", x_global, y_global);
    return 0;
}

为什么不推荐？

1. 破坏封装性：函数不再依赖于它的参数，其行为变得不可预测,你无法仅通过函数签名就知道它操作了哪些数据。
2. 副作用：任何地方都可能修改全局变量，导致程序逻辑混乱,难以调试。
3. 线程安全问题：在多线程环境中，全局变量的访问和修改非常危险,极易引发竞态条件。
4. 降低代码可重用性：这个函数只能用于特定的全局变量,无法复用。

使用结构体（C++风格，C语言中不常用）

在C++中，你可以通过引用轻松实现swap，在纯C语言中，有一种类似的方法，就是将多个变量打包到一个结构体中，然后交换整个结构体，由于结构体在传递时也可以是传值，但如果结构体很小，编译器可能会进行优化（RVO - 返回值优化）,或者你可以通过指针传递结构体。

这种方法在C语言中非常不常见，通常只用在需要返回多个值的场景,而不是单纯的交换。

#include <stdio.h>
struct Pair {
    int a;
    int b;
};
// 交换整个结构体（传值，效率可能不高）
void swap_structs(struct Pair p1, struct Pair p2) {
    // ...
}
// 更好的方式是传递结构体指针
void swap_structs_with_pointers(struct Pair *p1, struct Pair *p2) {
    int temp = p1->a;
    p1->a = p2->a;
    p2->a = temp;
    temp = p1->b;
    p1->b = p2->b;
    p2->b = temp;
}
int main() {
    struct Pair my_pair1 = {10, 20};
    struct Pair my_pair2 = {30, 40};
    printf("交换前: pair1.a=%d, pair1.b=%d\n", my_pair1.a, my_pair1.b);
    printf("交换前: pair2.a=%d, pair2.b=%d\n", my_pair2.a, my_pair2.b);
    swap_structs_with_pointers(&my_pair1, &my_pair2);
    printf("交换后: pair1.a=%d, pair1.b=%d\n", my_pair1.a, my_pair1.b);
    printf("交换后: pair2.a=%d, pair2.b=%d\n", my_pair2.a, my_pair2.b);
    return 0;
}

这种方法虽然可行，但对于简单的两个整数交换来说，是“杀鸡用牛刀”,不如直接用指针清晰高效。

总结与最佳实践

在C语言中，如果你想实现一个通用的、正确的swap函数，唯一推荐的方法就是使用指针。

*一个更通用的指针版swap函数（使用`void`）：**

如果你想写一个可以交换任何类型数据的swap函数，可以使用void*指针，并利用内存拷贝函数memcpy。

#include <stdio.h>
#include <string.h> // for memcpy
// 通用的swap函数
void swap_generic(void *a, void *b, size_t size) {
    // 创建一个临时缓冲区
    char temp[size];
    // 将a指向的内容拷贝到temp
    memcpy(temp, a, size);
    // 将b指向的内容拷贝到a
    memcpy(a, b, size);
    // 将temp的内容拷贝到b
    memcpy(b, temp, size);
}
int main() {
    int x = 10, y = 20;
    double d1 = 3.14, d2 = 6.28;
    printf("交换前 (int): x = %d, y = %d\n", x, y);
    swap_generic(&x, &y, sizeof(int));
    printf("交换后 (int): x = %d, y = %d\n", x, y);
    printf("\n交换前 (double): d1 = %.2f, d2 = %.2f\n", d1, d2);
    swap_generic(&d1, &d2, sizeof(double));
    printf("交换后 (double): d1 = %.2f, d2 = %.2f\n", d1, d2);
    return 0;
}

这个版本非常强大，但为了交换两个int而写这么复杂的代码，通常没有必要，对于大多数情况，为特定类型（如int, double）写专门的swap函数就足够了,并且更清晰。

最终建议： 对于初学者和日常开发，请牢牢掌握使用指针的swap方法,这是C语言中处理这类问题的基石。