boost___smart_ptr
2014-10-21 18:15
218 查看
包括scoped_ptr, scoped_array, shared_ptr, shared_array, weak_ptr, intrusive_ptr六个部分。
scoped_ptr很类似std::auto_ptr,但是其所有权更加严格,一旦获得不允许转让。
成员函数
explicit scoped_ptr(T* p=0)
构造函数,存储p的一份拷贝。注意,p 必须是用operator new分配的,或者是null.在构造的时候,不要求T必须是一个完整的类型。当指针p是调用某个分配函数的结果而不是直接调用new得到的时候很有用:因为这个类型不必是完整的,只需要类型T的一个前向声明就可以了。这个构造函数不会抛出异常。
~scoped_ptr()
删除指针所指向的对象。类型T在被销毁时必须是一个完整的类型。如果scoped_ptr在它被析构时并没有保存资源,它就什么都不做。这个析构函数不会抛出异常。
void reset(T* p=0);
重置一个 scoped_ptr 就是删除它已保存的指针,如果它有的话,并重新保存p. 通常,资源的生存期管理应该完全由scoped_ptr自己处理,但是在极少数时候,资源需要在scoped_ptr的析构之前释放,或者scoped_ptr要处理它原有资源之外的另外一个资源。这时,就可以用reset,但一定要尽量少用它。(过多地使用它通常表示有设计方面的问题) 这个函数不会抛出异常。
T& operator*() const;
该运算符返回一个智能指针中存储的指针所指向的对象的引用。由于不允许空的引用,所以解引用一个拥有空指针的scoped_ptr将导致未定义行为。如果不能肯定所含指针是否有效,就用函数get替代解引用。这个函数不会抛出异常。
T* operator->() const;
返回智能指针所保存的指针。如果保存的指针为空,则调用这个函数会导致未定义行为。如果不能肯定指针是否空的,最好使用函数get。这个函数不会抛出异常。
T* get() const;
返回保存的指针。应该小心地使用get,因为它可以直接操作裸指针。但是,get使得你可以测试保存的指针是否为空。这个函数不会抛出异常。get通常在调用那些需要裸指针的函数时使用。
operator unspecified_bool_type() const
返回scoped_ptr是否为非空。返回值的类型是未指明的,但这个类型可被用于Boolean的上下文(boolean context)中。在if语句中最好使用这个类型转换函数,而不要用get去测试scoped_ptr的有效性
void swap(scoped_ptr& b)
交换两个scoped_ptr的内容。这个函数不会抛出异常。
普通函数
template<typename T> void swap(scoped_ptr<T>& a,scoped_ptr<T>& b)
这个函数提供了交换两个scoped pointer的内容的更好的方法。之所以说它更好,是因为 swap(scoped1,scoped2) 可以更广泛地用于很多指针类型,包括裸指针和第三方的智能指针。scoped1.swap(scoped2) 则只能用于它的定义所在的智能指针,而不能用于裸指针。
用法
scoped_ptr的用法与普通的指针没什么区别;最大的差别在于你不必再记得在指针上调用delete,还有复制是不允许的。典型的指针操作(operator* 和 operator->)都被重载了,并提供了和裸指针一样的语法。用scoped_ptr和用裸指针一样快,也没有大小上的增加,因此它们可以广泛使用。使用boost::scoped_ptr时,包含头文件"boost/scoped_ptr.hpp". 在声明一个scoped_ptr时,用被指物的类型来指定类模板的参数。例如,以下是一个包含std::string指针的scoped_ptr:
boost::scoped_ptr<std::string> p(new std::string("Hello"));
当scoped_ptr被销毁时,它对它所拥有的指针调用delete 。
scoped_array: 包装了new[]而不是new,为动态数组提供了代理。与scoped_ptr设计思想一致,不能赋值,拷贝,只能在被声明的作用域内使用。接口也大体相同,特点:
1. 构造函数接受的指针必须是new []的结果或者0.
2. 没有* ->重载操作符,因为持有的不是一个普通指针。
3. 提供了[]重载操作符,像普通数组一样用下表访问。
4. 没有begin(), end()等类似容器的迭代器操作。
其实还是尽量少动态分配数组,尽量用vector替代。
shared_ptr非常有用,引用计数的引入,使其可以赋值,拷贝和任意的共享,也可以存放在容器中。
scoped_ptr很类似std::auto_ptr,但是其所有权更加严格,一旦获得不允许转让。
1 namespace boost { 2 template<typename T> class scoped_ptr : noncopyable { 3 public: 4 explicit scoped_ptr(T* p = 0); 5 ~scoped_ptr(); 6 7 void reset(T* p = 0); 8 9 T& operator*() const; 10 T* operator->() const; 11 T* get() const; 12 13 void swap(scoped_ptr& b); 14 }; 15 16 template<typename T> 17 void swap(scoped_ptr<T> & a, scoped_ptr<T> & b); 18 }
成员函数
explicit scoped_ptr(T* p=0)
构造函数,存储p的一份拷贝。注意,p 必须是用operator new分配的,或者是null.在构造的时候,不要求T必须是一个完整的类型。当指针p是调用某个分配函数的结果而不是直接调用new得到的时候很有用:因为这个类型不必是完整的,只需要类型T的一个前向声明就可以了。这个构造函数不会抛出异常。
~scoped_ptr()
删除指针所指向的对象。类型T在被销毁时必须是一个完整的类型。如果scoped_ptr在它被析构时并没有保存资源,它就什么都不做。这个析构函数不会抛出异常。
void reset(T* p=0);
重置一个 scoped_ptr 就是删除它已保存的指针,如果它有的话,并重新保存p. 通常,资源的生存期管理应该完全由scoped_ptr自己处理,但是在极少数时候,资源需要在scoped_ptr的析构之前释放,或者scoped_ptr要处理它原有资源之外的另外一个资源。这时,就可以用reset,但一定要尽量少用它。(过多地使用它通常表示有设计方面的问题) 这个函数不会抛出异常。
T& operator*() const;
该运算符返回一个智能指针中存储的指针所指向的对象的引用。由于不允许空的引用,所以解引用一个拥有空指针的scoped_ptr将导致未定义行为。如果不能肯定所含指针是否有效,就用函数get替代解引用。这个函数不会抛出异常。
T* operator->() const;
返回智能指针所保存的指针。如果保存的指针为空,则调用这个函数会导致未定义行为。如果不能肯定指针是否空的,最好使用函数get。这个函数不会抛出异常。
T* get() const;
返回保存的指针。应该小心地使用get,因为它可以直接操作裸指针。但是,get使得你可以测试保存的指针是否为空。这个函数不会抛出异常。get通常在调用那些需要裸指针的函数时使用。
operator unspecified_bool_type() const
返回scoped_ptr是否为非空。返回值的类型是未指明的,但这个类型可被用于Boolean的上下文(boolean context)中。在if语句中最好使用这个类型转换函数,而不要用get去测试scoped_ptr的有效性
void swap(scoped_ptr& b)
交换两个scoped_ptr的内容。这个函数不会抛出异常。
普通函数
template<typename T> void swap(scoped_ptr<T>& a,scoped_ptr<T>& b)
这个函数提供了交换两个scoped pointer的内容的更好的方法。之所以说它更好,是因为 swap(scoped1,scoped2) 可以更广泛地用于很多指针类型,包括裸指针和第三方的智能指针。scoped1.swap(scoped2) 则只能用于它的定义所在的智能指针,而不能用于裸指针。
用法
scoped_ptr的用法与普通的指针没什么区别;最大的差别在于你不必再记得在指针上调用delete,还有复制是不允许的。典型的指针操作(operator* 和 operator->)都被重载了,并提供了和裸指针一样的语法。用scoped_ptr和用裸指针一样快,也没有大小上的增加,因此它们可以广泛使用。使用boost::scoped_ptr时,包含头文件"boost/scoped_ptr.hpp". 在声明一个scoped_ptr时,用被指物的类型来指定类模板的参数。例如,以下是一个包含std::string指针的scoped_ptr:
boost::scoped_ptr<std::string> p(new std::string("Hello"));
当scoped_ptr被销毁时,它对它所拥有的指针调用delete 。
1 int main() 2 { 3 boost::scoped_ptr<string> sp(new string("hello world!")); 4 cout<<*sp<<endl; 5 cout<<sp->size()<<endl; 6 7 *sp = "hekexin"; 8 cout<<*sp<<endl; 9 cout<<sp->size()<<endl; 10 11 //重置一个 scoped_ptr 就是删除它已保存的指针,如果它有的话, 12 //并重新保存p. 通常,资源的生存期管理应该完全由scoped_ptr自己处理, 13 //但是在极少数时候,资源需要在scoped_ptr的析构之前释放,或者scoped_ptr 14 //要处理它原有资源之外的另外一个资源。这时,就可以用reset,但一定要尽 15 //量少用它。(过多地使用它通常表示有设计方面的问题) 这个函数不会抛出异常。 16 sp.reset(); 17 assert(sp.get() == 0); 18 assert(sp == 0); 19 assert(!sp); 20 21 return 0; 22 }
scoped_array: 包装了new[]而不是new,为动态数组提供了代理。与scoped_ptr设计思想一致,不能赋值,拷贝,只能在被声明的作用域内使用。接口也大体相同,特点:
1. 构造函数接受的指针必须是new []的结果或者0.
2. 没有* ->重载操作符,因为持有的不是一个普通指针。
3. 提供了[]重载操作符,像普通数组一样用下表访问。
4. 没有begin(), end()等类似容器的迭代器操作。
其实还是尽量少动态分配数组,尽量用vector替代。
int main() { boost::scoped_array<int> sap(new int[100]); std::fill_n(&sap[0], 100, 5); sap[0] = sap[2] + sap[3]; for (int i=0; i<100; ++i) { cout<<sap[i]<<endl; } return 0; }
shared_ptr非常有用,引用计数的引入,使其可以赋值,拷贝和任意的共享,也可以存放在容器中。
1 int main() 2 { 3 shared_ptr<int> sp(new int(10)); 4 cout<<*sp<<endl; 5 assert(sp.unique()); 6 7 shared_ptr<int> sp2 = sp; 8 assert(sp == sp2 && sp.use_count() == 2); 9 *sp = 100; 10 assert(!sp.unique()); 11 cout<<*sp2<<endl; 12 13 sp.reset(); 14 assert(!sp); 15 cout<<*sp2<<endl; 16 cout<<sp2.use_count()<<endl; 17 18 return 0; 19 }
1 class Shared 2 { 3 private: 4 shared_ptr<int> sp_; 5 6 public: 7 Shared(shared_ptr<int> p) : sp_(p) {} 8 void print() 9 { 10 cout<<"use count : "<<sp_.use_count()<<" val : "<<*sp_<<endl; 11 } 12 void print_func(shared_ptr<int> sp) 13 { 14 cout<<"use count : "<<sp.use_count()<<" val : "<<*sp<<endl; 15 } 16 17 void print_func1(shared_ptr<int>& sp) 18 { 19 cout<<"use count : "<<sp.use_count()<<" val : "<<*sp<<endl; 20 } 21 }; 22 23 int main() 24 { 25 shared_ptr<int> sp(new int(100)); 26 Shared s1(sp); 27 Shared s2(sp); 28 s1.print(); // 3, 100 29 s2.print(); // 3, 100 30 31 *sp = 200; 32 s1.print(); //3, 200 33 s2.print(); //3, 200 34 35 s1.print_func(sp); // 4, 200 36 37 s1.print(); // 3, 200 38 39 s1.print_func1(sp); //3, 200 40 41 return 0; 42 }
1 int main() 2 { 3 shared_ptr<string> sp = make_shared<string>("hello world!"); 4 shared_ptr< vector<int> > spv = make_shared< vector<int> >(10, 3); 5 assert(*sp == "hello world!"); 6 assert(sp.unique()); 7 assert(spv->size() == 10); 8 vector<int>& vec = *spv; 9 10 typedef vector<shared_ptr<int> > vs; 11 vs spVec(10); 12 cout<<spVec.size()<<endl; 13 int i = 0; 14 for (vs::iterator ite = spVec.begin(); ite != spVec.end(); ++ite) 15 { 16 *ite = make_shared(++i); 17 18 } 19 return 0; 20 }
相关文章推荐
- boost.smart_ptr库简介
- boost.smart_ptr-智能指针scoped_ptr
- 引领Boost(四)(Boost::smart_ptr)
- Boost.Smart_ptr/enable_share_from_this笔记
- 引领Boost(四)(Boost::smart_ptr)
- boost::smart_ptr
- Boost.smart_ptr.scoped_ptr--1
- 在smart_ptr中处理引用计数时使用swap概念(boost::shared_ptr.hpp)
- Boost源码剖析--<boost/smart_ptr/scoped_ptr.hpp>
- Boost.smart_ptr.shared_ptr--2
- boost::smart_ptr之智能指针
- Boost使用笔记(Smart_ptr)
- Boost之smart_ptr
- boost.smart_ptr-智能指针scoped_array
- boost.smart_ptr-智能指针scoped_array
- 初探boost之smart_ptr库学习笔记
- boost.smart_ptr-智能指针scoped_ptr
- boost smart_ptr -> scoped_ptr
- boost.smart_ptr-智能指针scoped_ptr
- boost学习: smart-ptr