关于交换两个值的一些讨论

void swap_1(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

以上是交换两个int值的直觉方法

另外，其实还有

void swap_2(int& a, int& b)
{
    a = a + b;
    b = a - b;
    a = a - b;
}

以上情况不需要考虑int值相加溢出的问题，溢出了还可以减回来

另外还有一种方法

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

swap_2和swap_3是不需要临时变量的交换法，看起来很cool，实际上并没有什么性能上的优势，用途大概是面试用？

另外，swap_3其实是有问题的，正确的写法应该是

void swap_2(int& a, int& b)
{
if (a != b)
{
a = a + b;
b = a - b;
a = a - b;
}
}

void swap_3(int& a, int& b)
{
if (a != b)
{
a = a^b;
b = a^b;
a = a^b;
}
}

原因在于，判断a==b的情况避免swap(a,a)的时候会出现问题，面试的时候不要搞错了

以上都是对于int类型的交换，那么对于其他类型的交换呢

在float或double类型的交换中，swap_2方式的交换是错误的，原因在于float和double实质上是不精确的表示，会出现m + n - m != n的情况（注意运算顺序）

毫无疑问，使用临时变量的方法一般情况下都是正确的

template<typename T>
void swap(T& lhs, T& rhs)
{
    T temp(lhs);
    lhs = rhs;
    rhs = temp;
}

template<typename T>
void swap(T* lhs, T* rhs)
{
    T* temp(lhs);
    lhs = rhs;
    rhs = temp;
}

不正确的情况在于，c++的类可以进行运算符重载， 为自己编写拷贝构造函数

于是我们无法知道类的行为是否符合我们的预期

并且一次构造（临时的类），两次拷贝的代价是否符合我们的需要

此时我们需要一个东西，那就是类的自定义函数，例如：stl的swap在对vector调用时，实际上会调用vector<T>::swap()，以得到最佳的性能，至于swap模板如何判断类是否含有自定义的swap成员函数，可以通过定义类的特化版swap来实现