GeekBand学习笔记-第六周 关于STL的使用之一

写在前面：感谢GeekBand提供这样好的学习机会，让我在繁忙的工作之余可以学习巩固c++知识。以下是边学边记的一些扩展点。分享给大家。

今天我分享的是把原生数组和指针的思想，过渡到STL的思想中去。

基本思想：容器相当于原生数组，迭代器相当于指针，for循环能不写就不写，交给迭代过程去做。

活学活用STL：给定一个 vector:v1 = [0, 0, 30, 20, 0, 0, 0, 0, 10, 0],希望通过not_equal_to 算法找到到不为零的元素,并复制到另一个 vector: v2

---

先看看下面这个not_equal_to 是什么，是用来判断是否“不等于”的函数。需要2个参数，返回一个bool值。这个我们要放在迭代器里使用，所以与以往的if()分支的写法不同。

• 同理可推equal_to, greater, less, greater_equal, less_equal 的用法

//如需引用，用这里
#include 
//源文件，在这里
        // TEMPLATE STRUCT not_equal_to
template
    struct not_equal_to
    {   // functor for operator!=
    typedef _Ty first_argument_type;
    typedef _Ty second_argument_type;
    typedef bool result_type;

    _CONST_FUN bool operator()(const _Ty& _Left, const _Ty& _Right) const
        {   // apply operator!= to operands
        return (_Left != _Right);
        }
    };

不过，究竟怎么用，我们看看std::not_equal_to()的参考吧

// not_equal_to example
#include      // std::cout
#include    // std::not_equal_to
#include     // std::adjacent_find

int main () {
  int numbers[]={10,10,10,20,20};
  int* pt = std::adjacent_find (numbers, numbers+5, std::not_equal_to()) +1;
  std::cout << "The first different element is " << *pt << '\n';
  return 0;
}

看，用上面这个例子里的方法来做。用指针的思想来处理数组，只需要从头到尾遍历一次就好。顺便说一下，例子里也正好有个find的用法，等下我们也要用find来查找。

int* GetIt(int* start, int* end, const int unexpectedInt)
{
    if (start != NULL && end != NULL)
    {
        int* result = std::find_if(start, end, std::bind2nd(std::not_equal_to(), unexpectedInt));
        if (*result != unexpectedInt)
        {
            return result;
        }
    }
    return NULL;
}

这里，我们用find_if 这个查找最近一个符合条件的数据的指针，并且注意bind2nd这个结合not_equal_to()的用法。每一个数据都经由这个函数对比过，并返回结果。这个任务的剩余部分，也就如下面所示了。

int* GetNextOne(int * ptr)
{ //根据指针，返回数组里下一个元素的地址的操作
    if (ptr != iarray + 10 && ptr != NULL)
    {
        for (int i = 0; i < 10; i++)
        {
            if (ptr == iarray + i)
            {
                return ptr = iarray + i + 1;
            }
        }
    }
    else return 0;
}

void FiltArray(int* thePtr)
{//封装的整体查找过程，放入一个GetIt返回的指针即可
    while (thePtr < iarray + 10 && thePtr != NULL)
    {
        thePtr = GetIt(thePtr, iarray + 10, 0);
        if (thePtr != NULL)
        {
            v2.push_back(*thePtr);
            //std::cout << *nptr << '\n';
            thePtr = GetNextOne(thePtr);
        }
    }
}

int main()
{
    FiltArray(GetIt(iarray, iarray + 10, 0));
    std::cout << "V2 set as" << '\n';
    std::for_each(v2.begin(),v2.end(), PrintIt);
    return 0;
}

上面的实例只是完成了，但是并没有用到Vector的特性。

而且指针的操作，比较烦人。STL能简化并且提升这个操作。

然而， 指针的思想是好的；遍历一次的这个流程是好的。

所以我们可以用迭代器替代指针，改写GetIt的函数

int iarray[10] = { 0, 0, 30, 20, 0, 0, 0, 0, 10, 0 };
std::vector v1(iarray, iarray + 10);
std::vector v2;
//上面是构造vector 容器
std::vector::iterator GetIt(std::vector::iterator start, std::vector::iterator end, const int unexpectedInt)
{
    std::vector::iterator result = std::find_if(start, end, std::bind2nd(std::not_equal_to(), unexpectedInt));
    return result;
}

这里要说明一下，迭代器避免了“空指针”的概念，也就是说如果查找不到合适的返回值，那么会返回end。比如std::vector v1 的v1.end(). 这个end是一个特殊的元素，如下图所示。

v1的内部结构,这里的“\n”我们是借用了一个写法，只是代表一个特殊符号

所以，只要我们收到v1.end()，就说明查找结束。那么就有遍历查找过程

void FiltArray(std::vector::iterator thePtr)
{//封装的整体查找过程
    while (thePtr != v1.end())
    {
        thePtr = GetIt(thePtr, v1.end(), 0);
        if (thePtr != v1.end())
        {
            v2.push_back(*thePtr);        //添加到目标容器中
            ++thePtr;                     //找寻下一个元素的迭代器，替代了上面的GetNextOne.
                                          //极大地减少了操作
        }
    }
}

int main()
{  //类似的调用方法，更直观，更省心。
    FiltArray(v1.begin());
    std::cout << "V2 set as" << '\n';
    std::for_each(v2.begin(),v2.end(), PrintIt);
    return 0;
}

void PrintIt(const int i)
{//打印方法，让上面的for_each调用
    std::cout << i << "; ";
}

看，这就是STL的好处。