C++泛型算法

泛型算法=模板+迭代器

问题：

首先我们利用随机数，然后对这些随机数从小到大排序。
vector 还是使用我们自定义的vector，参加《vector第四步修炼之道》博文。
测试函数：

#include<iostream>
#include<time.h>
//#include "vectorAllocate.h"
//#include "vectorAllocateIterator.h"
#include "vectorjGenericity.h"

using namespace std;


int main()
{
    /***********vectorjGenericity的使用*************/
    myAllocator<int> alloc;
    vector<int, myAllocator<int>> vec1(10, alloc);
    srand(time(NULL));
    for (int i = 0; i < 20; i++)
    {
        vec1.push_back(rand()%100);
    }
    showContainer<vector<int, myAllocator<int>>>(vec1);
    return 0;
}

然后写从小到大排序函数，算法使用冒泡排序

//默认从小到大，把[first,last]区间的所有元素从小到大排序
template<typename Iterator>
void mySort(Iterator it1, Iterator it2)
{
    Iterator::value_type tmp;
    int size = it2 - it1;
    for (int i = 0; i < size; ++i)
    {
        for (int j = 0;j < size - i - 1;++j)
        {
            if (it1[j]>it1[j + 1])
            {
                tmp = it1[j];
                it1[j] = it1[j + 1];
                it1[j + 1] = tmp;
            }
        }
    }
};

调用函数

mySort(vec1.begin(),vec1.end());

如果此时我需要从大到小呢？是不是需要重新定义一个函数？好麻烦~

优化1

如果我分别定义从大到小的函数和从小到大的函数，然后在排序函数中使用函数指针呢？

//函数定义
template <typename T>
 bool mygreater(T a, T b)
{
    return a > b;
}
template <typename T>
bool myless(T a, T b)
{
    return a < b;
};

mySort函数实现

 //默认从小到大，把[first,last]区间的所有元素从小到大排序
template<typename Iterator,typename Compare>
void mySort(Iterator it1, Iterator it2, Compare func)
 {
     Iterator::value_type tmp;
     int size = it2 - it1;
     for (int i = 0; i < size; ++i)
     {
         for (int j = 0;j < size - i - 1;++j)
         {
             if (func(it1[j],it1[j + 1]))  
             {
                 tmp = it1[j];
                 it1[j] = it1[j + 1];
                 it1[j + 1] = tmp;
             }
         }
     }
 }

测试函数

    mySort(vec1.begin(), vec1.end(), mygreater<int>);
    mySort(vec1.begin(), vec1.end(), myless<int>);

优化2

如果定义成函数模板，那可以转化成模板类吗？当然可以。

(func(it1[j],it1[j + 1]))   ==》func.operator(it1[j],it1[j + 1])

模板类定义如下：

//模板类定义
template <typename T>
class mygreater 
{
public:
    bool operator()(T a, T b)
    {
        return a > b;
    }
};
template <typename T>
class myless
{
public:
    bool operator()(T a, T b)
    {
        return a < b;
    }
};

mySort函数实现

template<typename Iterator,typename Compare>
void mySort(Iterator it1, Iterator it2, Compare func)
 {
     Iterator::value_type tmp;
     int size = it2 - it1;
     for (int i = 0; i < size; ++i)
     {
         for (int j = 0;j < size - i - 1;++j)
         {
             if (func.operator()(it1[j], it1[j+1]))   
             {
              tmp = it1[j];
              it1[j] = it1[j + 1];
              it1[j + 1] = tmp;
             }
         }
     }
 }

测试函数：

    mySort(vec1.begin(), vec1.end(), mygreater<int>());
    mySort(vec1.begin(), vec1.end(), myless<int>());

STL 库中如何使用还需要看源码来分析，有时间了就琢磨下。