2014-11-21 stl中迭代器

迭代器

Stl中心思想：将算法和数据容器分开，彼此设计独立。最后再撮合在一起，容器和算法的泛型化（class template和function template分别对应）

#include<vector>

#include<list>

#include<deque>

#include<algorithm>

#include<iostream>

using namespacestd;

 

      int main()

{

      const int arraySize=7;

      int ia[arraySize]={0,1,2,3,4,5,6};

 

      vector<int> ivect(ia,ia+arraySize);

      list<int>ilist(ia,ia+arraySize);

      deque<int>ideque(ia,ia+arraySize);

 

      vector<int>::iteratoritl=find(ivect.begin(),ivect.end(),4);

      if(itl==ivect.end())

           cout<<"4 notfound"<<endl;

      else

           cout<<"4found."<<*itl<<endl;

 

      list<int>::iteratorit2=find(ilist.begin(),ilist.end(),6);

      if(it2==ilist.end())

           cout<<"6 notfound."<<endl;

      else

           cout<<"6found.!"<<*it2<<endl;

      deque<int>::iteratorit3=find(ideque.begin(),ideque.end(),8);

      if(it3==ideque.end())

           cout<<"8 notfound."<<endl;

      else

           cout<<"8found."<<*it3<<endl;

      cin.get();

      return 0;

}

算法find（）接收两个迭代器和一个搜寻目标。

迭代器是一种smart pointer。指针最重要的工作是内容提领和成员访问。迭代器的最重要工作就是对operator*和operator->进行重载。

Auto_ptr:

C++的auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。

使用std::auto_ptr，要#include<memory>。

源代码：

template <class T>

class auto_ptr

{

private:

      T *ap;

public:

      explicitauto_ptr(T *ptr=0)throw():ap(ptr){}

      ~auto_ptr()throw(){delete ap}

//用来接收所有权

T *release()throw()

      {

           T *tmp(ap);

           ap=0;

           returntmp;

      }

//用来接收所有权

      voidreset(T *ptr=0)throw()

      {

           if(ap!=ptr)

           {

                 deleteap;

                 ap=ptr;

           }

      }

      auto_ptr(auto_ptr &rhs) throw():ap(rhs.release()){}

      template<class Y>

      auto_ptr(auto_ptr<Y> &rhs)throw():ap(rhs.release()){}

      auto_ptr &operator=(auto_ptr&rhs )throw()

      {

           reset(rhs.release());

           return*this;

      }

      T &operator*()constthrow()

      {

           return*ap;

      }

      T *operator->()constthrow()

      {

           returnap;

      }

      T *get()constthrow()

      {

           returnap;

      }

     

交换控制权

     

      template<class Y>

      structauto_ptr_ref

      {

           Y *yp;

           auto_ptr_ref(Y *rhs):yp(rhs){}

      };                 

      auto_ptr(auto_ptr_ref<T>rhs)throw():ap(rhs.yp){}

      auto_ptr &operator=(auto_ptr_ref<T>rhs)throw()

      {

           reset(rhs.yp);

           return*this;

      }

      template<class Y>

      operatorauto_ptr_ref<Y>()throw()

      {

           returnauto_ptr_ref<Y>(release());

      }

      template<class Y>

      operatorauto_ptr<Y>()throw()

      {

           returnauto_ptr<Y>(release());

      }

};

};

auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：

int*p=new int(0);

auto_ptr<int>ap(p);

从此我们不必关心应该何时释放p，也不用担心发生异常会有内存泄漏。

1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象，所以我们就要注意了，一个萝卜一个坑，两个auto_ptr不能同时拥有同一个对象。像这样：

1

2

3

int*p=newint(0);

auto_ptr<int>ap1(p);

auto_ptr<int>ap2(p);

因为ap1与ap2都认为指针p是归它管的，在析构时都试图删除p,　两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr.

2) 考虑下面这种用法：

1

2

int*pa=newint[10];

auto_ptr<int>ap(pa);

因为auto_ptr的析构函数中删除指针用的是delete,而不是delete[],所以我们不应该用auto_ptr来管理一个数组指针。

3) 构造函数的explicit关键词有效阻止从一个“裸”指针隐式转换成auto_ptr类型。

4) 因为C++保证删除一个空指针是安全的，　所以我们没有必要把析构函数写成：

1

2

3

4

~auto_ptr()throw()

{

if(ap)deleteap;

}

与一般拷贝构造函数，赋值函数不同，　auto_ptr的拷贝构造函数，赋值函数的参数为引用而不是常引用(const reference).当然，一个auto_ptr也不能同时拥有两个以上的“裸”指针，所以，拷贝或赋值的目标对象将先释放其原来所拥有的对象。

1) 因为一个auto_ptr被拷贝或被赋值后，　其已经失去对原对象的所有权，这个时候，对这个auto_ptr的提领(dereference)操作是不安全的。如下:

1

2

3

4

int*p=newint(0);

auto_ptr<int>ap1(p);

auto_ptr<int>ap2=ap1;

cout<<*ap1;//错误，此时ap1只剩一个null指针在手了

这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递，因为在函数调用过程中在函数的作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造)，这样，传入的实参auto_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto_ptr删除。如下：

1

2

3

4

voidf(auto_ptr<int>ap){cout<<*ap;}

auto_ptr<int>ap1(newint(0));

f(ap1);

cout<<*ap1;//错误，经过f(ap1)函数调用，ap1已经不再拥有任何对象了。

 

因为这种情况太隐蔽，太容易出错了，　所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的指针或引用作为函数参数或许可以，但是仔细想想，我们并不知道在函数中对传入的auto_ptr做了什么，　如果当中某些操作使其失去了对对象的所有权，　那么这还是可能会导致致命的执行期错误。　也许，用const reference的形式来传递auto_ptr会是一个不错的选择。

3) 因为auto_ptr不具有值语义(valuesemantic), 所以auto_ptr不能被用在stl标准容器中。

所谓值语义，是指符合以下条件的类型(假设有类A)：

1

2

3

4

5

6

Aa1;

Aa2(a1);

Aa3;

a3=a1;

//那么

a2==a1,a3==a1

很明显，auto_ptr不符合上述条件，而我们知道stl标准容器要用到大量的拷贝赋值操作，并且假设其操作的类型必须符合以上条件。

3 提领操作(dereference)

提领操作有两个操作，　一个是返回其所拥有的对象的引用，　另一个则是实现了通过auto_ptr调用其所拥有的对象的成员。如：

1

2

3

4

5

6

7

structA

{

voidf();

}

auto_ptr<A>apa(newA);

(*apa).f();

apa->f();

当然，　我们首先要确保这个智能指针确实拥有某个对象，否则，这个操作的行为即对空指针的提领是未定义的。

4 辅助函数

1) get用来显式的返回auto_ptr所拥有的对象指针。我们可以发现，标准库提供的auto_ptr既不提供从“裸”指针到auto_ptr的隐式转换(构造函数为explicit),也不提供从auto_ptr到“裸”指针的隐式转换，从使用上来讲可能不那么的灵活，　考虑到其所带来的安全性还是值得的。

2) release,用来转移所有权

3) reset，用来接收所有权，如果接收所有权的auto_ptr如果已经拥有某对象，必须先释放该对象。

5 特殊转换

这里提供一个辅助类auto_ptr_ref来做特殊的转换，按照标准的解释，　这个类及下面4个函数的作用是：使我们得以拷贝和赋值non-const auto_ptrs，　却不能拷贝和赋值const auto_ptrs. 我无法非常准确的理解这两句话的意义，但根据我们观察与试验，应该可以这样去理解：没有这些代码，我们本来就可以拷贝和赋值non-const的auto_ptr和禁止拷贝和赋值const的auto_ptr的功能，　只是无法拷贝和赋值临时的auto_ptr(右值)，　而这些辅助代码提供某些转换，使我们可以拷贝和赋值临时的auto_ptr，但并没有使const的auto_ptr也能被拷贝和赋值。如下：

1

auto_ptr<int>ap1=auto_ptr<int>(newint(0));

auto_ptr<int>(newint(0))是一个临时对象，同时是一个右值，一般的拷贝构造函数当然能拷贝右值，因为其参数类别必须为一个const reference,　但是我们知道，auto_ptr的拷贝函数其参数类型为reference，所以，为了使这行代码能通过，我们引入auto_ptr_ref来实现从右值向左值的转换。其过程为：

1) ap1要通过拷贝 auto_ptr<int>(new int(0))来构造自己

2)auto_ptr<int>(new int(0))作为右值与现有的两个拷贝构造函数参数类型都无法匹配，也无法转换成该种参数类型

3) 发现辅助的拷贝构造函数auto_ptr(auto_ptr_ref<T>rhs) throw()

4) 试图将auto_ptr<int>(new int(0))转换成auto_ptr_ref<T>

5) 发现类型转换函数operatorauto_ptr_ref<Y>() throw()，转换成功。

6)调用auto_ptr(auto_ptr_ref<T>rhs)throw()完成auto_ptr_ref向auto_ptr的构造。

从而通过一个间接类成功的实现了拷贝构造右值（临时对象）

同时，这个辅助方法不会使const auto_ptr被拷贝，　原因是在第5步，　此类型转换函数为non-const的，我们知道，const对象是无法调用non-const成员的，　所以转换失败。当然，　这里有一个问题要注意，　假设你把这些辅助转换的代码注释掉，该行代码还是可能成功编译，这是为什么呢？debug一下，　我们可以发现只调用了一次构造函数，而拷贝构造函数并没有被调用，原因在于编译器将代码优化掉了。这种类型优化叫做returned value optimization，它可以有效防止一些无意义的临时对象的构造。当然，前提是你的编译器要支持returnedvalue optimization。