Boost学习之指针容器--pointer_container

Boost学习之指针容器--pointer_container

Boost.pointer_container提供了和标准相似的容器,只是它存放的是指针,维护的是堆分配的对象.

有时,我们可能需要一个包含指针的容器.比如存放一些不可拷贝的对象或者想在容器里存放基类以实现多态.尽管我们可以直接定义存放指针的STL容器,不过这样并不方便,我们得处处小心,在清空或删除容器里的元素时我们要保证异常安全地回收指针所指向的对象,以防内存泄漏.

一个好的办法是使用共享智能指针的容器,如std::vector >,不过这样做的话智能指针所带来的开销显然太大了.

Boost.pointer_container提供了和标准相似的容器,只是它维护的是指针所指的对象.

要使用Boost.pointer_container只需包含下面的头文件即可

#include 

 

一个简单的例子

1. #include 
2. #include 
3.  
4. using namespace std;
5. using namespace boost;
6.  
7. struct base{  //基类
8.     virtual void print()=0;
9.         virtual ~base(){}
10. };
11.  
12. struct A:base{ //A,从base继承
13.     void print(){
14.         cout << "A" << endl;
15.     }
16. };
17.  
18. struct B:base{ //B,从base继承
19.     void print(){
20.         cout << "Here is B" << endl;
21.     }
22. };
23.  
24. struct C:base{ //C,从base继承
25.     C(string str)
26.         :m_str(str){}
27.     void print(){
28.         cout << "C:" << m_str << endl;
29.     }
30. private:
31.     string m_str;
32. };
33.  
34. int main()
35. {
36.     ptr_vector data;
37.     data.push_back(new A);
38.     data.push_back(new B);
39.     data.push_back(new C("hello"));
40.     data.push_back(new C("world"));
41.    
42.     for(ptr_vector::iterator itr=data.begin(); itr!=data.end(); ++itr)
43.     {
44.         itr->print();
45.     }
46.  
47.     return 0;
48. }

运行结果:

A Here is B C:hello C:world

应该注意到,这里没有内存泄漏,在ptr_vector析构时会删除容器内指针所指向的对象.

本例中,我们使用了ptr_vector,在Boost.pointer_container库中包含的指针容器有:

ptr_vector
ptr_list
ptr_deque
ptr_array
ptr_set
ptr_multi_set
ptr_map
ptr_multimap

除ptr_array以外,其它所有的容器都能与STL一一对应起来,除了以指针方式存入以外,使用方法没什么区别.至于ptr_array,它不过是的简单包装罢了.

毫无悬念地,这些指针容器是STL兼容的,比如上面的循环打印用这句代替:

for_each(data.begin(), data.end(), mem_fun_ref(&base::print));

 

其它问题

空值

如果向容器中插入NULL, 默认情况是抛出一个异常. 如果想让指针容器能保存NULL指针,那么声明容器时就必须使用nullable来包装数据类型,例如:

boost::ptr_vector< boost::nullable > animals_type;

克隆能力

默认情况下,容器或迭代器之间的赋值并不是简单的指针复制,而是使用拷贝构造函数产生一个新的拷贝.比如:

1. struct C:base{
2.     C(string str)
3.         :m_str(str){
4.         cout << "C:con " << this << ' ' << str <
5.     }
6.  
7.     C(){
8.         cout << "C:con " << this <
9.     }
10.  
11.     C(const C& oth){
12.         m_str = oth.m_str;
13.         cout << "C:copy " << this << ' ' << m_str <
14.     }
15.  
16.     ~C(){
17.         cout << "C:decon " << this <
18.     }
19.     void print(){
20.         cout << "C:" << m_str << endl;
21.     }
22. private:
23.     string m_str;
24. };
25.  
26. int main()
27. {
28.     ptr_vector data;
29.     data.push_back(new C("hello"));
30.     data.push_back(new C("world"));
31.    
32.     ptr_vector dataX = data;
33.  
34.     return 0;
35. }

显示两次构造,两次拷贝,四次析构. 说明ptr_vector dataX = data;使用了拷贝构造函数生成了自己的对象实例.

我们可以通过定义T* new_clone(const T&)来改变这种行为:

在上例的main()函数之前定义:

1. C* new_clone(const C& orig)
2. {
3.     cout << "C:clone" << endl;
4.     return new C("cloned");
5. }

这次运行结果显示它调用了两次new_clone而不是拷贝了.

Boost.pointer_container提供了和标准相似的容器,只是它存放的是指针,维护的是堆分配的对象.

新的成员函数

release:

声明:

auto_type release(iterator where)

作用:
    把指针从容器中删除,并返回这个指针. auto_type是数据的智能指针,类似于std::auto_ptr.

transfer

声明:

template< class PtrSeqAdapter > void transfer( iterator before, PtrSeqAdapter::iterator first, PtrSeqAdapter::iterator last, PtrSeqAdapter& from ) // strong template< class PtrSeqAdapter > void transfer( iterator before, PtrSeqAdapter::iterator object, PtrSeqAdapter& from ) // strong

作用:
    从另一容器from中转移指定的元素到本容器中.

replace

声明:

auto_type replace( iterator where, Ty_* x )

作用
    用x替换where处的元素,返回被替换掉的元素.

类STL算法

因为存入指针容器的是指针,并且由容器负责所指对象的生命周期. 面迭代器表现的却是对象的引用,这种不一致造成了它不适合使用STL里那些会改变容器内容的算法(比如sort),所以指针容器自己提供了一些有用的算法:

排序

1. void sort( iterator first, iterator last )
2. void sort()
3. template< class Compare >
4.         void sort( iterator first, iterator last, Compare comp )
5. template< class Compare >
6.         void sort( Compare comp )

唯一

1. void unique( iterator first, iterator last )
2. void unique()
3. template< class Compare >
4.         void unique( iterator first, iterator last, Compare comp )
5. template< class Compare >
6.         void unique( Compare comp )

条件删除

1. template< class Pred >
2.         void erase_if( iterator first, iterator last, Pred pred )
3. template< class Pred >
4.         void erase_if( Pred pred )

归并

1. void merge( iterator first, iterator last,
2.     ptr_sequence_adapter& from )
3. template< class BinPred >
4.         void merge( iterator first, iterator last,
5.                     ptr_sequence_adapter& from, BinPred pred )
6. void merge( ptr_sequence_adapter& r )
7. template< class BinPred >
8.         void merge( ptr_sequence_adapter& r, BinPred pred )