STL------通用工具

1.1 Pairs(对组)

 

  class pair可以将两个值视为一个单元。stl内多出使用了这个class，尤其容器类别map和multimap，就是使用pairs来管理其键值/实值(key/value)的成对元素。任何函数需返回两值，也需要pair。

Structure pair定义于<utility>：

namespace std{

  template<class T1,class T2>

  struct pair{

    //type names for the values

    typedef T1 first_type;

    typedef T2 second_type;

   

    //member

    T1 first;

    T2 second;

   

    /*default constructor

    *-T1() and T2() force initialization for built-in types

    */

   pair()

     :first(T1()),second(T2()){

   }

 

  //constructor for two values

  pair(const T1& a,const T2&b)

  :fist(a),second(b){

  }

  

  //copy constructor with implicit conversions

  template<class U,class V>

  pair(const pair<U,V>& p)

  : first(p.first),second(p.second){

  }

 
  };

}

 

//comparisons

template <class T1,class T2>

bool operator==(const pair <T1,T2>&, const pair<T1,T2>&);

....//similar :!=,<,>,>=,<=

 

//convenience function to create a pair

template<class T1,class T2>

pair<T1,T2> make_pair(const T1&,const T2&);

 

pair之间的比较

  为了比较两个pair对象，如果两个pair对象的所有元素都相等，才视为相等(equal)

  namespace std{

    template<class T1,class T2>

    bool operator==(const pair<T1,T2>& x,const pair<T1,T2>& y){

      return x.first==y.first && x.second==y.second;

    }

  }

 

1.1.1 便捷函数make_pair()

  template function make_pair()使你无需写型别，就可以生成一个pair对象：

 

namespace std{

  //create value pair only by providing the values

  template<class T1,class T2>

  pair<T1,T2> make_pair(const T1&x,const T2&y){

    return pair<T1,T2>(x,y);

  }

}

 

 

 

1.2 Class auto_ptr

 

  本节描述auto_ptr型别。C++ STL提供的auto_ptr是一种智能型指针(smart_point),帮助程序员防止"被异常抛出时发生资源泄露"。auto_ptr只是针对某个问题而设计，对于其它问题,auto_ptr无能为力。

 

1.2.1 auto_ptr设计动机

 

  函数的操作经常依以下模式进行：

1.获取一些资源；

2.执行一些动作；

3.释放所获取的资源;

 

如果一开始获取的资源被绑定于局部对象(local objects)身上，当函数退出时，它们的析构函数(destructor)被调用,从而自动释放这些资源。然而事情并不总是如此顺利，如果资源是显示手法(explicitly)获得，而且没有被绑定在任何对象身上，那就必须以显示手法释放。这种情形常常发生在指针身上。

 

一个典型的例子就是运用new和delete来产生和销毁对象：

void f()

{

  classA* ptr =new classA;//create an object explicitly;

  ...                               //peform some operations

  delete ptr;                    //clean up(destrory the object explicitly)

}

 

这个函数是麻烦的根源，我们经常会忘记delete动作，防止这种资源遗失的常见办法是捕捉所有异常。例如：

 

void f()

{

   classA* ptr=new classA;

   try{

     ....                //peform some operations

   }

   catch(...){ //for any exception

     delete ptr;    //clean up

     throw;          //rethrow the exception

   }

   delete prt;          //clean up on normal end

}

 

 

如果使用智能指针，情况大不一样。

 

  auto_ptr是这样的指针：它是"它所指的对象"的拥有者(owner)。所以，当身为对象拥有者的auto_ptr被摧毁时，该对象也将被摧毁。auto_ptr要求一个对象智能有一个拥有者，严禁一物二主。

 

下面是上面改写后的版本；

//header firle for auto_ptr

#include<memory>

 

void f()

{

   //create and initialize an auto_ptr

   std::auto_ptr<Class A> ptr(new ClassA);

 

   ....        //peform some operations

}

 

不再需要delete ，也不需要catch。auto_ptr的借口与一般指针非常相似：

operator* 用来提取所指对象，operator->用来指向对象中的成员。然而,所有指针(包括++)都没有定义(这可能是件好事,因为指针算术本是一大麻烦来源)。

 

 

注意：auto_ptr<>不允许使用一般指针惯用的assign初始化方式，必须直接使用数值完成初始化:

 

std::auto_ptr<ClassA> ptr(new ClassA); //OK

std::auto_ptr<ClassA>ptr2 =new ClassA;   //ERROR

 

1.2.2 auto_ptr拥有权(Ownership)的转移

 

  auto_ptr所界定的乃是一种严格的拥有权观念。也就是说，由于一个auto_ptr会删除所指定对象，所以这个对象绝对不能同时被其它对象"拥有"。绝对不应该出现多个autor_ptrs同时拥有一个对象的情况。

 

  这个条件导致了一个问题：auto_ptr的copy构造函数和assignment操作符应该如何运作呢？

  令auto_ptr的copy构造函数和assignment操作符将对象拥有权交出去。下例:copy构造函数的运用:

 

  //initialize an auto_ptr with a new object

  std::auto_ptr<ClassA> ptr1(new ClassA);

 

 //copy the auto_ptr

 //--transfer ownership from ptr1 to ptr2

 std::auto_ptr<ClassA> ptr2(ptr1);

 

....待续