交换任意数据类型

众所周知，不用中间变量交换数据的写法是这样：

void Swap(int& a,int& b){
    a ^= b;
    b ^= a;
    a ^= b;
}

有人可能会说，这只能用来交换整数，没什么用

真的是这样吗？

在内存中，数据是这样的：

这不就是一堆整形吗（）只需要直接绕过类型，操作对应的内存即可，于是有以下代码

void swap(void* a,void* b,size_t size){
    using byte = unsigned char;
    for(size_t i = 0;i < size;++i){
        *(byte*)a ^= *(byte*)b;
        *(byte*)b ^= *(byte*)a;
        *(byte*)a ^= *(byte*)b;
    }
}

嗯，很完美，但好像效率有点低，每次交换一个字节，能不能做到一次交换多个字节？

当然可以，这时候就可以用到c++的模板来简化写法：

//UnsignedIntegral 无符号整形约束

//实现基础逻辑，交换整形数据（最大可达八字节，即unsigned long long)
template<UnsignedIntegral UINT>
void
MemorySwap(UINT& a, UINT& b) {
    a ^= b;
    b ^= a;
    a ^= b;
}
//实现n个整数类型的数据交换
template<size_t N,UnsignedIntegral UINT>
void
MemorySwap(UINT* a, UINT* b) {
//可用OpenMP或模板For优化这个for循环
    for (int i = 0; i < N; i++) {
        MemorySwap(a[i], b[i]);
    }
}
//同上，支持动态填写size参数，缺点是不能用For模板进行优化循环
template<UnsignedIntegral UINT>
void
MemorySwap(UINT* a, UINT* b,size_t size) {
    for (int i = 0; i < size; i++){
        MemorySwap(a[i], b[i]);
    }
}
//Different 不同类型约束，此次确保T不为void
//接口
template<Different<void> T>
void
MemorySwap(T* a, T* b) {
    using byte = unsigned char;
    using uint64 = unsigned long long;
    //常量表达式，不消耗资源
    constexpr auto rate = sizeof(T) / (sizeof uint64);
    constexpr auto modulo = sizeof(T) % (sizeof uint64);
    
    //if constexpr 判断
    if constexpr(rate)
        //交换数据前rate * 8个字节
        MemorySwap<rate>(reinterpret_cast<uint64*>(a), reinterpret_cast<uint64*>(b));
    if constexpr(modulo)
        //交换剩下没交换的字节
        MemorySwap<modulo>(reinterpret_cast<byte*>(a), reinterpret_cast<byte*>(b));
}

struct AAA{
    int a,b,c;
}

int main(){
    AAA a = {1,2,3};
    AAA b = {3,4,5};
    MemorySwap(&a,&b);
}

（注：main函数内容未经测试，可能有误，MemorySwap函数经过测试，暂时无误）

这样即可做到交换任意数据类型（不过使用场景貌似很有限）