์ค๋งํธ ํฌ์ธํฐ ์ฐ๊ธฐ
----
----
์ค์น ¶
- boost ์ ๊ฐ์ ๋ค์ด๋ฐ๊ณ ์ค์นํ๋ค.
- boost ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํค๋ ํ์ผ๋ง์ด ์กด์ฌํ๋ค. ๋ชจ๋ ๊ตฌํ์ ํค๋ ํ์ผ์ ํด ๋์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ก ํ์ด ํค๋์ ๊ตฌํ ๋ถ๋ฆฌํ๊ธฐ ๊ท์์ด ๊ธฐ์ ....๋ณธ์ธ์ ์ ์ฉํ๋ค...
shared_ptr ¶
- new ๋ฅผ ํด์ฃผ๊ณ delete ํ๋ ๊ฒ ์์ ํด๋ฐฉ์!
- ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ auto_ptr ์ด๋ผ๊ณ ๊ฐ์ ๊ฐ๋
์ ํด๋์ค๊ฐ ์์ง๋ง, ๋ฒ๊ทธ๊ฐ ์๋ค. -_-;; auto_ptr๋ฅผ ์ปจํ
์ด๋์ ์ง์ด๋ฃ์ผ๋ฉด ๋ฒ๊ทธ๋์ ์ค์ค๋ก ์ญ์ ๊ฐ ์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ ์์ฃผ ์ฌ๊ฐํ ๋ฌธ์ ์ด๋ค.
...
#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
// 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 (ํ ์ด๋ํด๋์ค๊ฐ ๋๋ค.. ์ฒ์๋ดค๋ค --;;)
shared_ptr_example2.cpp
shared_ptr_example2_test.cpp
----
See Also Boost์ shared_ptr
----
BoostLibrary
// 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
};
// 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"; }
// 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;
}
See Also Boost์ shared_ptr
BoostLibrary










