스마트 포인터 쓰기
설치 ¶
- boost 에 가서 다운받고 설치한다.
- boost 라이브러리는 헤더 파일만이 존재한다. 모든 구현을 헤더 파일에 해 놓았기 때문이다. 바로 필살 헤더와 구현 분리하기 귀잖어 기술....본인은 애용한다...
shared_ptr ¶
- new 를 해주고 delete 하는 것 에서 해방을!
- 표준 라이브러리에도 auto_ptr 이라고 같은 개념의 클래스가 있지만, 버그가 있다. -_-;; auto_ptr를 컨테이너에 집어넣으면 버그땜시 스스로 삭제가 안되 메모리가 새는 아주 심각한 문제이다.
~cpp ... #include <boost/smart_ptr.hpp> ... using namespace boost; ... class Vertex3D {...} typedef shared_ptr<Vertex3D> Vertex3DSPtr; typedef vector<Vertex3DSPtr> Vertexs; // 단어 틀렸다는거 알지만 그냥 씀 -_- typedef Vertexs::size_type VertexsSize; typedef Vertexs::iterator VertexsItr; typedef shared_ptr<Vertexs> VertexsSPtr; ... { VertexsSPtr vertexs(new Vertexs); Vertex3DSPtr vertex(new Vertex3D); ... vertexs->push_back(vertex); ... }
- new 를 했지만 delete 를 안해도 지가 알아서 사라진다.
- 모든 객체에 스마트포인터를 쓰도록 프로그램 짜면 자바같은 느낌으로 짤수도 ...
shared_ptr_example ¶
shared_ptr_example.cpp
~cpp // Boost shared_ptr_example.cpp --------------------------------------------// // (C) Copyright Beman Dawes 2001. Permission to copy, // use, modify, sell and distribute this software is granted provided this // copyright notice appears in all copies. This software is provided "as is" // without express or implied warranty, and with no claim as to its // suitability for any purpose. // See http://www.boost.org for most recent version including documentation. // Revision History // 21 May 01 Initial complete version (Beman Dawes) // The original code for this example appeared in the shared_ptr documentation. // Ray Gallimore pointed out that foo_set was missing a Compare template // argument, so would not work as intended. At that point the code was // turned into an actual .cpp file so it could be compiled and tested. #include <vector> #include <set> #include <iostream> #include <algorithm> #include <boost/shared_ptr.hpp> // The application will produce a series of // objects of type Foo which later must be // accessed both by occurrence (std::vector) // and by ordering relationship (std::set). struct Foo { Foo( int _x ) : x(_x) {} ~Foo() { std::cout << "Destructing a Foo with x=" << x << "\n"; } int x; /* ... */ }; typedef boost::shared_ptr<Foo> FooPtr; struct FooPtrOps { bool operator()( const FooPtr & a, const FooPtr & b ) { return a->x > b->x; } void operator()( const FooPtr & a ) { std::cout << a->x << "\n"; } }; int main() { std::vector<FooPtr> foo_vector; std::set<FooPtr,FooPtrOps> foo_set; // NOT multiset! FooPtr foo_ptr( new Foo( 2 ) ); foo_vector.push_back( foo_ptr ); foo_set.insert( foo_ptr ); foo_ptr.reset( new Foo( 1 ) ); foo_vector.push_back( foo_ptr ); foo_set.insert( foo_ptr ); foo_ptr.reset( new Foo( 3 ) ); foo_vector.push_back( foo_ptr ); foo_set.insert( foo_ptr ); foo_ptr.reset ( new Foo( 2 ) ); foo_vector.push_back( foo_ptr ); foo_set.insert( foo_ptr ); std::cout << "foo_vector:\n"; std::for_each( foo_vector.begin(), foo_vector.end(), FooPtrOps() ); std::cout << "\nfoo_set:\n"; std::for_each( foo_set.begin(), foo_set.end(), FooPtrOps() ); std::cout << "\n"; // Expected output: // // foo_vector: // 2 // 1 // 3 // 2 // // foo_set: // 3 // 2 // 1 // // Destructing a Foo with x=2 // Destructing a Foo with x=1 // Destructing a Foo with x=3 // Destructing a Foo with x=2 return 0; }
shared_ptr_example2 ¶
shared_ptr_example2.hpp (헉 이너클래스가 되네.. 처음봤다 --;;)
~cpp // Boost shared_ptr_example2 header file -----------------------------------// #include <boost/shared_ptr.hpp> // This example demonstrates the handle/body idiom (also called pimpl and // several other names). It separates the interface (in this header file) // from the implementation (in shared_ptr_example2.cpp). // Note that even though example::implementation is an incomplete type in // some translation units using this header, shared_ptr< implementation > // is still valid because the type is complete where it counts - in the // shared_ptr_example2.cpp translation unit where functions requiring a // complete type are actually instantiated. class example { public: example(); example( const example & ); example & operator=( const example & ); void do_something(); private: class implementation; boost::shared_ptr< implementation > _imp; // hide implementation details };
shared_ptr_example2.cpp
~cpp // Boost shared_ptr_example2 implementation file -----------------------------// #include "shared_ptr_example2.hpp" #include <iostream> class example::implementation { public: ~implementation() { std::cout << "destroying implementation\n"; } }; example::example() : _imp( new implementation ) {} example::example( const example & s ) : _imp( s._imp ) {} example & example::operator=( const example & s ) { _imp = s._imp; return *this; } void example::do_something() { std::cout << "use_count() is " << _imp.use_count() << "\n"; }
shared_ptr_example2_test.cpp
~cpp // Boost shared_ptr_example2_test main program ------------------------------// #include "shared_ptr_example2.hpp" int main() { example a; a.do_something(); example b(a); b.do_something(); example c; c = a; c.do_something(); return 0; }