代理模式

 当待排数据元素为体积庞大的对象时，如何提高排序的效率？ 

 问题分析 

        - 排序过程中不可避免的需要进行交换操作 

       －交换操作的本质为数据元素间的相互复制

       －当数据元素体积较大时，交换操作耗时巨大

 解决方案：代理模式 

         1. 为待排数据元素设置代理对象 

         2. 对代理对象所组成的序列进行排序 

         3 需要访问有序数据元素时，通过访问代理序列完成

#include <iostream>
#include "Sort.h"
#include <ctime>

using namespace std;
using namespace DTlib;

struct Test : public Object
{
    int id;
    int data1[1000];
    double data2[1000];

    bool operator < (const Test& obj)
    {
        return (id < obj.id);
    }
    bool operator <= (const Test& obj)
    {
        return (id <= obj.id);
    }
    bool operator > (const Test& obj)
    {
        return (id > obj.id);
    }
    bool operator >= (const Test& obj)
    {
        return (id >= obj.id);
    }
};

class TestProxy : public Object
{
protected:
    Test* m_pTest;
public:

    int id()
    {
        return m_pTest->id;
    }

    int* data1()
    {
        return m_pTest->data1;
    }

    double* data2()
    {
        return m_pTest->data2;
    }

    Test& test() const
    {
        return *m_pTest;
    }

    bool operator < (const TestProxy& obj)
    {
        return test() < obj.test();
    }
    bool operator <= (const TestProxy& obj)
    {
        return test() <= obj.test();
    }
    bool operator > (const TestProxy& obj)
    {
        return test() > obj.test();
    }
    bool operator >= (const TestProxy& obj)
    {
        return test() >= obj.test();
    }
    Test& operator = (Test& test)
    {
        m_pTest = &test;

        return test;
    }
};

Test t[1000];
TestProxy pt[1000];

int main()
{
    clock_t begin = 0;
    clock_t end = 0;
    for(int i=0; i<1000; i++)
    {
        t[i].id = i;
        pt[i] = t[i];
    }

    begin = clock();

    Sort::Bubble(pt, 1000, 0);

    end = clock();

    cout << "Time = " << (end - begin) << endl;

    return 0;
}