迴圈引用

#include <iostream>
#include <memory.h>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
using namespace std;

template<class T>
struct ListNode
{
    ListNode(const T& data)
        :_prev(NULL)
        ,_next(NULL)
        ,_data(data)
    {
        cout
 
<<"ListNode()"<<endl;
    }

    ~ListNode()
    {
        cout<<"~Node()"<<this<<endl;
    }

    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
    //weak_ptr<ListNode> _prev;
    //weak_ptr<ListNode> _next;
    T _data;
};

void Test()
{
    //迴圈引用問題
 

    shared_ptr<ListNode> p1(new ListNode());
    shared_ptr<ListNode> p2(new ListNode());

    cout<<"p1->Count:"<<p1.use_count()<<endl;
    cout<<"p2->Count:"<<p2.use_count()<<endl;

    p1->_next = p2;//p1節點的_next指向p2節點
    p2->_prev = p1;//p2節點的_prev指向p1節點
 

    cout<<"p1->Count:"<<p1.use_count()<<endl;
    cout<<"p2->Count:"<<p2.use_count()<<endl;
}

使用shared_ptr時，由於節點之間的相互引用使得多個節點指向同一塊空間，引用計數count不為1。在釋放空間時，p1等待p2釋放，而p2又在等待p1的釋放，從而引起迴圈引用問題，造成記憶體洩漏。

仿函式：也叫函式物件。就是使一個類的使用看上去像一個函式。其實現原理就是就是在類中過載（），這個類就有了類似函式的行為，同時也成為一個仿函式類了

下面兩個仿函式的使用例子

定製刪除器

#include <iostream>
using namespace std;

template<class T>
struct Delete
{
    void operator ()(T* p)
    {
        delete(p);
        cout<<"Delete"<<endl;
    }
};

template<class T>
struct Free
{
    void operator ()(T* p)
    {
        free(p);
        cout<<"Free"<<endl;
    }
};

template<class T>
struct Fclose
{
    void operator ()(T* p)
    {
        fclose(p);
        cout<<"Fclose"<<endl;
    }
};

template<class T, class Del = Del<T>>
class SharedPtr
{
public:
    SharedPtr(T* p =NULL)
        :_p(p)
        ,_pcount(NULL)
    {
        if(_p)
            _pcount = new int(1);
    }

    SharedPtr(const SharedPtr<T, Del>& sp)
        :_p(sp._p)
        ,_pcount(sp._pcount)
    {
        (*sp._pcount)++;
    }

    SharedPtr<T, Del>& operator =(const SharedPtr<T, Del>& sp)
    {
        if(this != &sp)
        {
            Release();

            _p = sp._p;
            _pcount = sp._pcount;
            (*sp._pcount)++;
        }
        return *this;
    }

    ~SharedPtr()
    {
        Release();
    }

    T& operator *()
    {
        return *_p;
    }

    T* operator ->()
    {
        return _p;
    }
private:
    void Release()
    {
        if(_p && (--(*_pcount)) == 0)
        {
            Del()(_p);

            delete _pcount;
            _pcount = NULL;
        }
    }

    T* _p;
    int* _pcount;
};

int main()
{
    SharedPtr<int, Free<int>> sp1((int*)malloc(sizeof(int)));
    SharedPtr<int, Delete<int>> sp2(new int(1));
    SharedPtr<FILE, Fclose<FILE>> sp3(fopen("test.txt", "wb"));
}

多重氣泡排序

#include <iostream>
using namespace std;

template<class T>
struct Great//升序
{
    bool operator ()(T& left, T& right)
    {
        return left > right;
    }
};

template<class T>
struct Less//降序
{
    bool operator ()(T& left, T& right)
    {
        return left > right;
    }
};

template<class T, class Compare>
void BubbleSort(T arr[], int len)
{
    int i = 0;
    int j = 0;
    int flag = 0;

    for(i = 0; i < len-1; i++)
    {
        flag = 0;
        for(j = 0; j < len-1-i; j++)
        {
            if(Compare()(arr[j], arr[j+1]))
            {
                flag = 1;
                swap(arr[j], arr[j+1]);
            }
        }
        if(flag == 0)
            break;
    }
}

int main()
{
    int arr1[] = {3, 7, 5, 2, 1, 9, 6, 4, 8};
    int len1 = sizeof(arr1)/sizeof(arr1[0]);
    BubbleSort<int, Great<int>>(arr1, len1);

    int arr2[] = {3, 7, 5, 2, 1, 9, 6, 4, 8};
    int len2 = sizeof(arr2)/sizeof(arr2[0]);
    BubbleSort<int, Less<int>>(arr2, len2);

    return 0;
}