在C中实现通用交换宏[重复]

Question

可能重复：
is there an equivalent of std::swap() in c

大家好，

我试图在 C 中编写通用交换宏时遇到问题，我的宏如下所示：

#define swap(x,y) { x = x + y; y = x - y; x = x - y; }

它适用于整数和浮点数，但我不确定其中是否有任何问题。如果通用宏是指交换指针、字符等怎么办？谁能帮我写一个通用宏来交换每个输入？

谢谢

Answer 1

这仅适用于整数。

对于浮点数，它将失败（例如，尝试用一个非常大的浮点数和一个非常小的浮点数运行它）。

我建议如下：

#define swap(x,y) do \ 
   { unsigned char swap_temp[sizeof(x) == sizeof(y) ? (signed)sizeof(x) : -1]; \
     memcpy(swap_temp,&y,sizeof(x)); \
     memcpy(&y,&x,       sizeof(x)); \
     memcpy(&x,swap_temp,sizeof(x)); \
    } while(0)

当在编译时知道要复制的数量时，memcpy 得到了很好的优化。 此外，无需手动传递类型名称或使用编译器特定的扩展。

Answer 2

你可以这样做：

#define SWAP(x, y, T) do { T SWAP = x; x = y; y = SWAP; } while (0)

然后你会像这样调用它：

SWAP(a, b, int);

或：

SWAP(x, y, float);

如果您乐于使用 gcc 特定的扩展，那么您可以像这样改进：

#define SWAP(x, y) do { typeof(x) SWAP = x; x = y; y = SWAP; } while (0)

然后就是：

SWAP(a, b);

或：

SWAP(x, y);

这适用于大多数类型，包括指针。

这是一个测试程序：

#include <stdio.h>

#define SWAP(x, y) do { typeof(x) SWAP = x; x = y; y = SWAP; } while (0)

int main(void)
{
    int a = 1, b = 2;
    float x = 1.0f, y = 2.0f;
    int *pa = &a;
    int *pb = &b;

    printf("BEFORE:\n");
    printf("a = %d, b = %d\n", a, b);
    printf("x = %f, y = %f\n", x, y);
    printf("pa = %p, pb = %p\n", pa, pb);

    SWAP(a, b);     // swap ints
    SWAP(x, y);     // swap floats
    SWAP(pa, pb);   // swap pointers

    printf("AFTER:\n");
    printf("a = %d, b = %d\n", a, b);
    printf("x = %f, y = %f\n", x, y);
    printf("pa = %p, pb = %p\n", pa, pb);

    return 0;
}

Answer 3

GMan 开始了这一尝试，结合inline 函数和宏对其进行编码。此解决方案假设您拥有支持 C99 的现代 C 编译器，因为它使用 compound literal:

inline void swap_detail(void* p1, void* p2, void* tmp, size_t pSize)
{
   memcpy(tmp, p1, pSize);
   memcpy(p1, p2, pSize);
   memcpy(p2 , tmp, pSize);
}
#define SWAP(a, b) swap_detail(&(a), &(b), (char[(sizeof(a) == sizeof(b)) ? (ptrdiff_t)sizeof(a) : -1]){0}, sizeof(a))

这具有以下属性：

• 它只评估a 和b 一次。
• 它有一个编译时检查 尺寸正确。
• 隐藏的没有命名问题 变量。
• 临时变量的大小是 在编译时计算，所以 复合文字不是动态的 数组。

需要演员(ptrdiff_t)，这样-1 不会被静默提升为SIZE_MAX。

这个解决方案仍然有两个缺点：

1. 它不是类型安全的。它只检查 对于类型的大小，而不是 他们的语义。如果类型 不同，比如大小为 8 的 double 和 uint64_t，你有麻烦了。

2. 表达式必须允许& 运算符适用。因此 它不适用于使用 register 声明的变量 存储类。

Answer 4

简单地说：您不能在 C 中创建 通用 交换宏，至少，并非没有风险或头痛。 （见其他帖子。解释如下。）

宏很好，但实际代码会遇到的问题是数据类型问题（如您所说）。此外，宏在某种程度上是“愚蠢的”。例如：

使用您的示例宏 #define swap(x,y) { x = x + y; y = x - y; x = x - y; }，swap(++x, y) 变成 { ++x = ++x + y; y = ++x - y; ++x = ++x - y;}。

如果你运行int x = 0, y = 0; swap(++x, y);，你会得到x=2, y=3，而不是x=0, y=0。除此之外，如果您的宏中的任何临时变量出现在您的代码中，您可能会遇到一些烦人的错误。

您正在寻找的功能是在 C++ 中作为模板引入的。您可以在 C 中获得最接近的方法是为每种可以想象的数据类型或相当复杂的宏使用内联函数（请参阅以前的宏问题和以前的帖子）。

在 C++ 中使用模板的解决方案如下所示：

template<typename T>
inline void swap(T &x, T &y)
{
    T tmp = x;
    x = y; y = tmp;
}

在 C 中，你需要类似的东西：

inline void swap_int(int *x, int *y) { /* Code */ }
inline void swap_char(char *x, char *y) { /* Code */ }
// etc.

或（如多次提到的）一个相当复杂的宏，它可能是危险的。

Answer 5

根据标准，这不一定适用于int。想象一下x 和y 分别是INT_MAX 和INT_MAX-1 的情况。第一个加法语句将导致标准未定义的有符号溢出。

int 的交换宏更可靠的实现是 XOR 交换算法

• http://en.wikipedia.org/wiki/XOR_swap_algorithm

Answer 6

说真的，您必须在代码中进行多少次交换才能让在给定解决方案的此线程中出现的所有令人头疼的问题都值得？我的意思是，这不是一个 10 行复杂且容易出错的代码结构，它是一个众所周知的习语，只有一个临时变量和三个简单的赋值。把它写在你需要的地方，如果你想节省空间，即使在一行中：

function foo ()
{
    int a, b, tmp;
    ...
    tmp = a; a = b; b = tmp;
    ....
}

或者在 a 和 b 更复杂的地方使用“本地”宏。

#define SWAP(t,a,b) ( (t) = (a), (a) = (b), (b) = (t) )

function foo (pointer)
{
    int tmp;
    ...
    SWAP(tmp, pointer->structure.array[count+1], pointer->structure.array[count+2]);
    ...
}

#undef SWAP