策略模式 C++ 实现

#include<iostream>
#include<algorithm>
#include<string>
/*
问题：和工厂模式的本质区别？
*/
using namespace std;
/*abstract sort class --- strategy class*/
class super_sort
{ public:
typedef int ElemType;
void swap(ElemType *a,ElemType*b)
{
ElemType tmp;
tmp=*a;
*a=*b;
*b=tmp;
}

virtual void sort(int *a,int l, int r)
{ }
};

/* concrete sort --- concret strategy */

/*quicksort*/
class quick_sort: public super_sort
{ private:
typedef int ElemType;

int partition(int *a,int l,int r)
{ElemType v=a[r];
int i=l-1;int j=r;
while(i<j)
{
while(a[++i]>v&&i<r) ;
while(j>l&&a[--j]<v) ;
if(i>=j)
break;
swap(&a[i],&a[j]);
}
swap(&a[i],&a[r]);

return i;
}

void quicksort(int *a,int l,int r)
{ int i;
if(l>=r) return;
i=partition(a,l,r);
quicksort(a,l,i-1);
quicksort(a,i+1, r);

}
public:
void sort(int *a, int l, int r)
{
quicksort(a,l,r);

}

};

/*insert sort*/

class insert_sort: public super_sort
{
private:
typedef int ElemType;
void insertsort(ElemType *a,int l,int r)
{
int i;
for(i=1;i<r;i++)
if(a[i]<a[0]) swap(&a[0],&a[i]);

for(i=l+2;i<r;i++)
{
int j=i;ElemType v=a[i];
while(v<a[j-1])
{a[j]=a[j-1];j--;}
a[j]=v;

}
}

public:
void sort(int *a,int l, int r)
{
insertsort(a,l,r);
}
};

/*direct sort*/

class direct_sort: public super_sort
{
private:
void selectsort(int *a,int l,int r)
{int i,j;
int flag=1;
for(i=l;i<r;i++)
{   int min=i;
for(j=i+1;j<10;j++)
{
if(a[j]<a[min])
min=j;

}
swap(&a[i],&a[min]);

}
}

public:
void sort(int *a, int l, int r)
{
selectsort(a,l,r);
}

};

/*context class*/

class context
{
private:
super_sort *my_sort;
public:
context(){};
void select_sort(int num,int *a, int l, int r)
{
switch(num)
{
case 1:
my_sort = new quick_sort();
break;
case 2:
my_sort = new insert_sort();
break;
case 3:
my_sort = new direct_sort();
break;

default:
cout << "Erro input, please check. " << endl;

}
my_sort->sort(a, l, r);
}

void sort_list()
{
cout <<"1 -------- quicksort ---------"<< endl;
cout <<"2 -------- insertsort ---------"<< endl;
cout <<"3 -------- directsort ---------"<< endl;
cout << "Input your choice: "<< endl;
}
};

/*
策略模式 和 简单工厂模式的 区别：
简单工厂模式让客户端识别两个类，而策略模式只让客户端识别一个类；
耦合更加低。

*/

/*client class*/
int main()
{   int num;
int a[10] = {1,20,12,0,4,54,22,11,78,8};
context my_selection;
my_selection.sort_list();
cin >> num;
my_selection.select_sort(num,a,0,9);
cout <<"-------- result ---------"<< endl;
for(int i = 0; i < 10; i++)
cout <<a[i]<< endl;

system("pause");
return 0;
}