Boost和STL的几种智能指针

1.scoped_ptr

scoped_ptr has similar characteristics to std::auto_ptr, with the important difference that it doesn't transfer ownership the way an auto_ptr does .

 

#include "boost/scoped_ptr.hpp" #include <string> #include <iostream> // The major difference between scoped_ptr and auto_ptr void scoped_vs_auto() { using boost::scoped_ptr; using std::auto_ptr; scoped_ptr<std::string> p_scoped(new std::string("Hello")); auto_ptr<std::string> p_auto(new std::string("Hello")); p_scoped->size(); p_auto->size(); //doesn't compile because a scoped_ptr cannot be copy constructed or assigned to. //scoped_ptr<std::string> p_another_scoped=p_scoped; //The auto_ptr can be both copy constructed and copy assigned auto_ptr<std::string> p_another_auto=p_auto; p_another_auto->size(); (*p_auto).size(); } int main() { { boost::scoped_ptr<std::string> p(new std::string("Use scoped_ptr often.")); // Print the value of the string if (p) std::cout << *p << '/n'; // Get the size of the string size_t i=p->size(); std::cout << "Size " << i << std::endl; // Assign a new value to the string *p="Acts just like a pointer"; std::cout << *p << std::endl; } // p is destroyed here, and deletes the std::string std::cin.get(); }

 

2.shared_ptr

These smart pointers eliminate the need to write complicated logic to control the lifetime of objects shared among two or more other objects. When the reference count drops to zero , no more objects are interested in the shared object, and so it is deleted automatically .

#include "boost/shared_ptr.hpp" #include <iostream> namespace SharedOne { class A { boost::shared_ptr<int> no_; public: A(boost::shared_ptr<int> no) : no_(no) { } void value(int i) { *no_=i; } }; class B { boost::shared_ptr<int> no_; public: B(boost::shared_ptr<int> no) : no_(no) { } int value() const { return *no_; } }; } using namespace SharedOne; using namespace std; int main() { boost::shared_ptr<int> temp(new int(14)); A a(temp); B b(temp); a.value(28); if(b.value()==28) { cout << "shared reference pointer" << endl; } else { cout << "error" << endl; } system("pause"); }

The following example shows how to store shared pointers in a Standard Library container.

#include "boost/shared_ptr.hpp" #include <vector> #include <iostream> namespace SharedTwo { class A { public: virtual void sing()=0; protected: virtual ~A() { }; }; class B : public A { public: virtual void sing() { std::cout << "Do B"; } }; boost::shared_ptr<A> createA() { boost::shared_ptr<A> p(new B()); return p; } } using namespace SharedTwo; int main() { typedef std::vector<boost::shared_ptr<A> > container_type; typedef container_type::iterator iterator; container_type container; for (int i=0;i<10;++i) { container.push_back(createA()); } std::cout << "The choir is gathered: /n"; iterator end=container.end(); for (iterator it=container.begin();it!=end;++it) { (*it)->sing(); std::cout << std::endl; } std::cin.get(); }

当shared_ptr对象销毁时，调用指定的函数对象

#include <boost/shared_ptr.hpp> #include <iostream> namespace Shared_ptrThree { class Light { public: void OpenLight() { std::cout << "Open light" << std::endl; } void CloseLight() { std::cout << "Close light" << std::endl; } }; class LightClosed { public: void operator()(Light * light) { light->CloseLight(); } }; } using namespace Shared_ptrThree; void main() { std::cout << "shared_ptr example with a custom deallocator./n"; { Light * lightPtr = new Light(); boost::shared_ptr<Light> myLight(lightPtr, LightClosed()); std::cout << "out of scope"; } std::cout << "The light has been closed!/n"; std::cin.get(); }