[轉]談談C++中的swap函數

1，最通用的模板交換函數模式：創建臨時對象，調用對象的賦值操作符。

 

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

 

 

需要構建臨時對象，一個拷貝構造，兩次賦值操作。

2，針對int型優化：

 

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

 

 

無需構造臨時對象，異或

因為指針是int，所以基於這個思路可以優化1：

 

 

template <typename T> void Swap(T & obj1,T & obj2)
{
    unsigned char * pObj1 = reinterpret_cast<unsigned char *>(&obj1);
    unsigned char * pObj2 = reinterpret_cast<unsigned char *>(&obj2);
    for (unsigned long x = 0; x < sizeof(T); ++x)
    {
        pObj1[x] ^= pObj2[x];
        pObj2[x] ^= pObj1[x];
        pObj1[x] ^= pObj2[x];
    }
}

 

 

3，針對內建類型的優化：  int, flaot, double 等，甚至重載運算符的用戶自定義類型：向量，矩陣，圖像等。。。

type  a; -- e.g 10
type  b; -- e.g 5

a = a+b ; -- a=15,b=5
b = a-b ; -- a=15,b=10
a= a -b ; -- a= 5,b=10

// 無需構造臨時變量。使用基本運算操作符。

 

Ok, let's see.
a = a + b;
b = a - b;
a = a - b;
Let's introduce new names
c = a + b;
d = c - b;
e = c - d;
And we want to prove that d == a and e == b.
d = (a + b) - b = a, proved.
e = (a + b) - ((a + b) - b) = (a + b) - a = b, proved.
For all real numbers.

 

 

4，swap的一些特化：

std::string, std::vector各自實現了swap函數，

string中

 

template<class _Elem,
    class _Traits,
    class _Alloc> inline
    void __CLRCALL_OR_CDECL swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
        basic_string<_Elem, _Traits, _Alloc>& _Right)
    {   // swap _Left and _Right strings
    _Left.swap(_Right);
    }
    void __CLR_OR_THIS_CALL swap(_Myt& _Right)
        {   // exchange contents with _Right
        if (this == &_Right)
            ;   // same object, do nothing
        else if (_Mybase::_Alval == _Right._Alval)
            {   // same allocator, swap control information
 #if _HAS_ITERATOR_DEBUGGING
            this->_Swap_all(_Right);
 #endif /* _HAS_ITERATOR_DEBUGGING */
            _Bxty _Tbx = _Bx;
            _Bx = _Right._Bx, _Right._Bx = _Tbx;
            size_type _Tlen = _Mysize;
            _Mysize = _Right._Mysize, _Right._Mysize = _Tlen;
            size_type _Tres = _Myres;
            _Myres = _Right._Myres, _Right._Myres = _Tres;
            }
        else
            {   // different allocator, do multiple assigns
            _Myt _Tmp = *this;
            *this = _Right;
            _Right = _Tmp;
            }
        }

 

 

第二個swap(Right)進行判斷，如果使用了相同的分配器，則直接交換控制信息，否則調用string::operator=進行拷貝賦值。。。所以建議優先使用swap函數，而不是賦值操作符。

 

vector中

 

template<class _Ty,
    class _Alloc> inline
    void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right)
    {   // swap _Left and _Right vectors
    _Left.swap(_Right);
    }
    void swap(_Myt& _Right)
        {   // exchange contents with _Right
        if (this == &_Right)
            ;   // same object, do nothing
        else if (this->_Alval == _Right._Alval)
            {   // same allocator, swap control information
 #if _HAS_ITERATOR_DEBUGGING
            this->_Swap_all(_Right);
 #endif /* _HAS_ITERATOR_DEBUGGING */
            this->_Swap_aux(_Right);
            _STD swap(_Myfirst, _Right._Myfirst);
            _STD swap(_Mylast, _Right._Mylast);
            _STD swap(_Myend, _Right._Myend);
            }
        else
            {   // different allocator, do multiple assigns
            this->_Swap_aux(_Right);
            _Myt _Ts = *this;
            *this = _Right;
            _Right = _Ts;
            }
        }

 

vector的swap原理跟string完全一致，只有當當使用了不同分配器才進行字節拷貝。其余情況直接交換控制信息。

 

測試用例：

 

5，Copy and  Swap idiom

目的：C++異常有三個級別：基本，強，沒有異常。通過創建臨時對象然后交換，能夠實現重載賦值操作符的強異常安全的執行。

Loki中智能指針 臨時變量跟this交換，臨時變量自動銷毀~

 

SmartPtr& operator=(SmartPtr<T1, OP1, CP1, KP1, SP1, CNP1 >& rhs)
{
    SmartPtr temp(rhs);
    temp.Swap(*this);
    return *this;
}

 

 

boost::share_ptr，share_ptr定義了自己的swap函數。

 

shared_ptr & operator=( shared_ptr const & r ) // never throws
{
    this_type(r).swap(*this);
    return *this;
}
void swap(shared_ptr<T> & other) // never throws
{
    std::swap(px, other.px);
    pn.swap(other.pn);
}

 

 

記得本科上C++課，老師特別喜歡拿String來舉例子，面試題也特別喜歡String。。。下面說說String::opreator=函數的優化：

最一般的寫法，特點：使用const string& 傳參防止臨時對象。

 

String& String::operator =(const String & rhs)
{
    if (itsString)
        delete [] itsString;
    itsLen = rhs.GetLen();
    itsString = new char[itsLen+1];
    for (unsigned short i = 0;i<itsLen;i++)
        itsString[i] = rhs[i];
    itsString[itsLen] = '/0';
    return *this;
}

 

 

優化1，防止自我間接賦值，a = b; c = b; a = c; 如果沒有第一個if判斷，當把c賦給a的時候，刪除了a.itsString，后面的拷貝就會出錯。注意是if(this==&rhs), 而不是if(*this==rhs) .

 

String& String::operator =(const String & rhs)
{
    if (this == &rhs)
        return *this;
    if (itsString)
        delete [] itsString;
    itsLen=rhs.GetLen();
    itsString = new char[itsLen+1];
    for (unsigned short i = 0;i<itsLen;i++)
        itsString[i] = rhs[i];
    itsString[itsLen] = '/0';
    return *this;
}

 

 

優化2，不進行拷貝賦值，只是交換控制信息，而且是強異常安全：

 

String & String::operator = (String const &rhs)
{
    if (this != &rhs)
        String(rhs).swap (*this); // Copy-constructor and non-throwing swap
    // Old resources are released with the destruction of the temporary above
    return *this;
}

 

 

優化3，以最原始的傳值方式傳參，避免臨時對象創建：

 

String & operator = (String s) // the pass-by-value parameter serves as a temporary
{
   s.swap (*this); // Non-throwing swap
   return *this;
}// Old resources released when destructor of s is called.

 

 

最后這張方式主要是對C++新特性rvalue的優化，具體參見：http://en.wikibooks.org/wiki/More_C++_Idioms/Copy-and-swap 

 

附上網絡版的String：

 

#include <iostream>
#include <cstring>
using namespace std;
class String
{
        public:
                String();
                String(const char *const);
                String(const String &);
                ~String();
                char & operator[] (unsigned short offset);
                char operator[] (unsigned short offset)const;
                String operator+(const String&);
                void operator+=(const String&);
                String & operator= (const String &);
                unsigned short GetLen()const {return itsLen;}
                const char * GetString()const {return itsString;}
        private:
                String (unsigned short);
                char * itsString;
                unsigned short itsLen;
};
String::String()
{
        itsString = new char[1]; //為什么設置成1，這樣會導致內存1bytes無法釋放嗎？我覺得和itsString = new char沒區別，那他為什么要設置成1，這樣有什么用？21天學會C++那本書，我也有 ，書上也確實是設置成1.
        itsString[0] = '/0';
        itsLen=0;
}
String::String(unsigned short len)
{
        itsString = new char[len+1];
        for (unsigned short i =0;i<=len;i++)
                itsString[i] = '/0';
        itsLen=len;
}
String::String(const char * const cString)
{
        itsLen = strlen(cString);
        itsString = new char[itsLen+1];
        for (unsigned short i=0;i<itsLen;i++)
                itsString[i] = cString[i];
        itsString[itsLen] = '/0';
}
String::String(const String & rhs)
{
        itsLen = rhs.GetLen();
        itsString = new char[itsLen+1];
        for (unsigned short i = 0;i<itsLen;i++)
                itsString[i] = rhs[i];
        itsString[itsLen] = '/0';
}
String::~String()
{
        delete [] itsString;
        itsLen = 0;
}
String& String::operator =(const String & rhs)
{
        if (this == &rhs)
                return *this;
        delete [] itsString;
        itsLen=rhs.GetLen();
        itsString = new char[itsLen+1];
        for (unsigned short i = 0;i<itsLen;i++)
                itsString[i] = rhs[i];
        itsString[itsLen] = '/0';
        return *this;
}
char & String::operator [](unsigned short offset) //這個程序這樣寫，起到了什么用處？？和main中的那一個對應？
{
        if (offset > itsLen)
                return itsString[itsLen-1]; //這個返回itslen-1到底是什么意思？為什么要減去1 ？？
        else
                return itsString[offset];
}
char String::operator [](unsigned short offset)const
{
        if (offset > itsLen)
                itsString[itsLen-1];
        else
                return itsString[offset];
}
String String::operator +(const String& rhs)
{
        unsigned short totalLen = itsLen + rhs.GetLen();
        String temp(totalLen);
        unsigned short i;
        for (i=0;i<itsLen;i++)
                temp[i] = itsString[i];
        for (unsigned short j = 0;j<rhs.GetLen();j++,i++)
                temp[i] = rhs[j];
        temp[totalLen] = '/0';
        return temp;
}
void String::operator +=(const String& rhs)
{
        unsigned short rhsLen = rhs.GetLen();
        unsigned short totalLen = itsLen + rhsLen;
        String temp(totalLen);
        unsigned short i;
        for (i = 0;i<itsLen;i++)
                temp[i] = itsString[i];
        for (unsigned short j = 0;j<rhs.GetLen();j++,i++)
                temp[i] = rhs[i-itsLen];
        temp[totalLen] = '/0';
}
int main()
{

        String s1("initial test"); //調用了什么函數？
        cout<<"S1:/t"<<s1.GetString()<<endl;
        char *temp ="Hello World";
        s1 = temp;//調用了什么函數？
        cout<<"S1:/t"<<s1.GetString()<<endl;
        char tempTwo[20];
        strcpy(tempTwo,"; nice to be here!");
        s1 += tempTwo;
        cout<<"tempTwo:/t"<<tempTwo<<endl;
        cout<<"S1:/t"<<s1.GetString()<<endl;
        cout<<"S1[4]:/t"<<s1[4]<<endl;
        cout<<"S1[999]:/t"<<s1[999]<<endl;//調用了什么函數？
        String s2(" Anoter string");//調用了什么函數？
        String s3;
        s3 = s1+s2;
        cout<<"S3:/t" <<s3.GetString()<<endl;
        String s4;
        s4 = "Why does this work?";//調用了什么函數？
        cout<<"S4:/t"<<s4.GetString()<<endl;
        return 0;
}

 

 

 

參考引用：

1，http://www.vbforums.com/showthread.php?t=245517

2，http://www.cplusplus.com/reference/algorithm/swap/

3，http://codeguru.earthweb.com/forum/showthread.php?t=485643

4，http://stackoverflow.com/questions/1998744/benefits-of-a-swap-function

5，http://answers.google.com/answers/threadview/id/251027.html

 

C++ idioms

http://en.wikibooks.org/wiki/Category:More_C%2B%2B_Idioms

 

Copy and Swap idiom

http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom