Boost라이브러리의내부구조 20151111 서진택

BoostBoost 라이브러리의 내부 구조라이브러리의 내부 구조
에 사용된 기법을 응용하기에 사용된 기법을 응용하기
KOG, 서진택
jintaeks@gmail.com
2015 년 11 월 11 일

발표자 , jintaeks@gmail.com
 2000 년 ㈜ Kog 입사
– 프로그래머로 게임 개발 시작
 ~2015 년 9 월 ㈜ Kog 프로그래머
– 프로그래머로 게임 개발 및 기술 지원 프로그래밍
– 참여 게임
• 와일드랠리
• 범퍼킹재퍼
• 엘소드
• 얼티밋레이스
 저서
– 게임개발자를 위한 C++, 민프레스 , 2003
– MFC 의 구조와 원리 , 한빛미디어 , 2005
2

발표순서
 base-from-member idiom
 BOOST_FOREACH 의 내부 구조
– if-for combination idiom
– RAII idiom
– int-to-type idiom
– BOOST_TYPEOF
 boost::shared_ptr 의 내부 구조
– copy-and-swap idiom
– safe-bool idiom
 Q&A
3
 이 발표는 boost 라이브러리에서 가장 많이
사용하는 BOOST_FOREACH() 와
shared_ptr 의 내부 구조를 분석합니다 .
 그리고 바닥부터 해당 기능을 구현합니다 .
 이 과정을 통해서 boost 가 사용한 기법들
을 프로그래밍에 응용하는 방법을 제시합
니다 .

base-from-member: 문제 상황
class KObject
{
public:
KObject()
{
m_iInitialized = 99;
}
int GetInitialized() const
{
return m_iInitialized;
}
private:
int m_iInitialized;
};//KObject
4
class KBase
{
public:
KBase( KObject& obj_ )
{
std::cout << obj_.GetInitialized() << std::endl;
}
};//class KBase
 상속받은 클래스의 멤버를 베이스 클래스
가 접근하는 경우가 있습니다 .
 KBase 의 생성자에서 m_object 의 멤버를
호출하는 것은 객체가 아직 초기화되지 않
았으므로 안전하지 않습니다 .

base-from-member: 해결방법
struct KPrivateBase
{
KObject m_object;
};//struct KPrivateBase
class KDerived2 : protected KPrivateBase, public KBase
{
public:
KDerived2() : KBase( m_object )
{
}
private:
//KObject m_object;
};//class KDerived
5
 base-from-member idiom 은 문제를 해결하
기 위해 다중 상속에서 호출되는 클래스 생
성자의 순서를 이용합니다 .
 boost 의 많은 곳에서는 , 베이스 클래스의
생성자에서 완전히 초기화된 객체를 접근
하기 위해 이 방법을 사용합니다 .

BOOST_FOREACH 구현에 필요한 idiom
6

문제제기 : BOOST_FOREACH
std::vector<int> vecInt;
BOOST_FOREACH( int& a, vecInt )
{
}
7
 어떻게 매크로에 사용한 변수의 범위를 { 와 }
로 제한하는 것이 가능할까요 ?

관찰 : if 의 조건문에 사용한 변수
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/typeof/typeof.hpp>
void main()
{
if( int iBlockScope = 0 ) {}
else
{
iBlockScope = 3;
std::cout << iBlockScope << std::endl;
}
//std::cout << iBlockScope << std::endl; // invalid access
}//main()
8
 if 문에 선언된 변수는 if 블록의 하부에서 사용
할 수 있습니다 . 또한 if 블록을 빠져 나가면 접
근할 수 없습니다 .
 즉 if 문에 선언된 변수의 범위 scope 는 if- 블록
안으로 제한됩니다 .
 변수를 true 가 아닌 값으로 초기화하면 , else-
블록에서 접근하는 것이 가능합니다 .

관찰 : for 에 사용한 문장
#include <iostream>
void main()
{
else
for( printf( "hello worldrn" ); iBlockScope == 0; iBlockScope = 1 )
{
iBlockScope = 3;
}
/**
hello world
3
계속하려면 아무 키나 누르십시오 . . .
*/
}//main()
9
 for 문의 첫번째 문장에는 조건에 상관없이
자유롭게 문장 statement 을 적을 수 있습
니다 . 또한 for 문에서 선언된 변수는
block scope 를 가집니다 .

관찰 : { 와 } 사용이 가능한 RAII 매크로 정의
#include <iostream>
#define RAII( statement_ )
else
for( statement_; iBlockScope == 0; iBlockScope = 1 )
void main()
{
RAII( printf( "hello worldrn" ) )
{
iBlockScope = 3;
}//RAII()
/**
hello world
3
계속하려면 아무 키나 누르십시오 . . .
*/
}//main() 10
 RAII 는 초기화 initialize 코드와 마무리
finalize 코드가 자동으로 호출되도록 하
는 디자인 패턴입니다 . RAII 는 코드를 안
전하고 깔끔하게 만듭니다 .
 if-for 문장을 조합하면 , 블록 scope 를
가지는 변수를 , { 안에서만 사용하도록
매크로를 정의할 수 있습니다 .

int2type
template <int I>
struct Int2Type
{
enum { value = I };
};
template <class T, unsigned int N>
class Array : public std::array <T, N>
{
enum AlgoType { NOOP, INSERTION_SORT,
QUICK_SORT };
static const int algo = (N==0) ? NOOP
: (N==1) ? NOOP
: (N<50) ? INSERTION_SORT : QUICK_SORT;
void sort (Int2Type<NOOP>) {}
void sort (Int2Type<INSERTION_SORT>) {}
void sort (Int2Type<QUICK_SORT>) {}
public:
void sort()
{
sort (Int2Type<algo>());
}
11
int main(void)
{
Array<int, 1> a;
a.sort(); // No-op!
Array<int, 400> b;
b.sort(); // Quick sort
}
 컴파일 시간에 정수 상수를 타입
으로 취급하도록 합니다 .

관찰 : sizeof 에 표현식 사용
#include <iostream>
#include <vector>
#include <boost/mpl/int.hpp>
template<class T>
T type_encoder( T expression_ )
{
return expression_;
}
template<int ID>
struct typeid_wrapper
{
typedef typename extract_type<int_<ID> >::id2type id2type;
typedef typename id2type::type type;
};
12
 함수 템플릿은 파라미터로 전달
된 표현식의 타입을 자동으로
유추하는 역할로 사용할 수 있
습니다 .
 id 로 구분되는 유일한 타입을 생성하고 ,
typeid_wrapper<>::type 으로 접근합니다 .

관찰 : BOOST_TYPEOF 의 원리
#include <iostream>
#include <vector>
#include <boost/mpl/int.hpp>
…
void main()
{
int i = 1;
sizeof( type_encoder(i+3) );
typeid_wrapper<sizeof( type_encoder(i+3) ) >::type k;
BOOST_TYPEOF( i + 3 ) j;
j = 3;
std::cout << i << std::endl;
std::cout << j << std::endl;
}//main()
13
 sizeof() 에는 type 뿐만 아니라 unary
expression 을 전달할 수 있습니다 .
 함수 호출과 sizeof() 를 이용하면 표현식을
템플릿에 전달할 수 있습니다 .
 이런 원리를 사용하여 구현된 , BOOST_TYPEOF() 는
표현식의 타입을 구합니다 ! i+3 의 타입이 int 이므로
int j; 와 같은 문장입니다 .

응용 예 : KLOCK_BEGIN
KLOCK_DECLARE_INIT( KTest, m_int, (0) );

void main()
{
KLOCK_DECLARE( std::vector<int>, vecUserInfo );
std::cout << vecUserInfo.size() << std::endl;

//vecUserInfo.push_back( 3 ); // compile time error
//m_int.SetInt( 5 ); // compile time error

KLOCK_BEGIN( m_int )
KLOCK_BEGIN( vecUserInfo )
{
m_int.SetInt( 5 );
vecUserInfo.push_back( 5 );
}
std::cout << m_int.GetInt() << std::endl;
std::cout << vecUserInfo.size() << std::endl;
}
14
 특정한 멤버 변수를 읽는 것은 허용하
되 , 쓰는 동작은 에러가 나도록 할 수
있습니다 .
 KLOCK_DECLARE() 로 선언한 변수는
이러한 특징을 가지도록 합니다 .
 KLOCK_BEGIN() 으로 특정한 변수에
대한 쓰기 권한을 허용할 수 있습니다 .
 이러한 기법은 읽기와 쓰기 동작을 구
분하는 코드를 작성하도록 합니다 .
 변수를 변경할 때 실행되어야 하는 코
드를 지정함으로써 , 여러가지
housekeeping 동작을 숨길 수 있습니
다 .

Step1: for- 문장
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <boost/foreach.hpp>
void main()
{
std::vector<int> vecIntData;
vecIntData.push_back( 1 );
for( std::vector<int>::iterator vitor = vecIntData.begin();
vitor != vecIntData.end();
++vitor )
{
int& iData = *vitor;
std::cout << iData << std::endl;
}//for
}//main()
16
 for 문을 이용하여 vector 를
iteration 하는 코드를 작성했습니
다 .

Step2: set_true() 정의하기
bool set_true( bool& bInOutVariable_ )
{
bInOutVariable_ = true;
return false;
}
void main()
{
…
17
 set_true() 는 항상 false 를 리턴합니
다 . 인자로 전달된 bool 변수를
true 로 만드는 역할을 합니다 .

Step3: use BOOST_TYPEOF
…
//BOOST_FOREACH( int& iData, vecIntData )
if( bool bForBreaker = false ) {}
else
for( BOOST_TYPEOF(vecIntData)::iterator vitor = vecIntData.begin()
; bForBreaker == false && vitor != vecIntData.end()
; ++vitor )
{
if( set_true(bForBreaker) ) {}
else
for( int& iData = *vitor; bForBreaker == true; bForBreaker = false )
{
//break;
}//for
}//for
}//main()
18
 set_true() 는 변수를 항상 true 로 설정하지만 ,
false 를 리턴하므로 , 변수값을 변경하는 일만 합
니다 .
 set_true() 가 필요한 이유는 최종적으로 정의한 매
크로 안에서 break 를 사용했을 때 , break 문장이
바깥 for- 문장을 빠져나가도록 하기 위함입니다 .

Step4: { 를 제거하기
void main()
{
//BOOST_FOREACH( int& iData, vecIntData )
else
for( BOOST_TYPEOF(vecIntData)::iterator vitor = vecIntData.begin()
; bForBreaker == false && vitor != vecIntData.end()
; ++vitor )
else
for( int& iData = *vitor; bForBreaker == true; bForBreaker = false )
}//main()
19
 BOOST_TYPEOF() 를 사용하여 매크
로로 전달된 표현식의 iterator 를 접근
합니다 .
 RAII 구현을 위해서 { 와 } 는 포함되
지 않게 매크로 작성을 준비합니다 .

FOREACH 완성
#define FOREACH( statement_, container_ )
else
for( BOOST_TYPEOF(container_)::iterator vitor = container_.begin()
; bForBreaker == false && vitor != container_.end()
; ++vitor )
else
for( statement_ = *vitor; bForBreaker == true; bForBreaker = false )
void main()
{
FOREACH( int& iData, vecIntData )
{
//break;
}//FOREACH()
}//main()
20
 중첩된 FOREACH() 와 배열을 지원하기
위해서는 추가적인 처리가 필요합니다 .

응용 예 : ASSET_FOREACH
 기본적으로 구현한 FOREACH() 를 응용하여 , 프로그
램의 내부 로직에 의존적인 여러가지 매크로를 정의
할 수 있습니다 .
– 프로그램에서 현재 관리중인 모든 asset 들에 대한 커스텀
iteration 을 작성할 수 있습니다 .
– .xml 파일을 로드하고 나서 , 모든 element 에 대한 커스텀
iteration 을 작성할 수 있습니다 .
– 프로그램에서 현재 생성된 모든 게임 객체에 대한 커스텀 iteration
을 작성할 수 있습니다 .
21

shared_ptr 의 내부 구조
22

void 참조를 특화로 구현
23
template<class T> struct shared_ptr_traits
{
typedef T& reference;
};
template<> struct shared_ptr_traits<void>
{
typedef void reference;
};
 void 타입에 대한 reference 가 가능하도록
템플릿 특화 specialization 을 사용하여 미
리 구현해 둡니다 .
 기타 type-trait 에 대한 설명은 생략합니다 .

shared_ptr: 생성자 구현
24
template<class T> class shared_ptr
{
public:
typedef shared_ptr<T> this_type;
typedef T value_type;
typedef T* pointer;
typedef typename shared_ptr_traits<T>::reference reference;
public:
shared_ptr(T * p = 0) : px(p), pn(0)
{
if( px != NULL )
pn = new int(1);
}
 생성자에서는 전달받은 raw pointer 를 초
기화합니다 .
 참조 카운팅을 위한 메모리 할당을 하고 ,
참조 카운터를 1 로 초기화합니다 .

shared_ptr: 복사 생성자와 파괴자 구현
25
shared_ptr( const shared_ptr& right_ ) : px( 0 ), pn( 0 )
{
release();
px = right_.px;
pn = right_.pn;
if( px != NULL )
*pn += 1;
}
~shared_ptr()
{
release();
}
 복사 생성자는 먼저 이전에 할당되어 있는
리소스를 해제 합니다 .
 새로운 리소스에 대한 참조를 설정하고 ,
참조 카운터를 증가시킵니다 .

shared_ptr: operator=(), operator pointer()
26
shared_ptr& operator=( const shared_ptr& right_ )
{
release();
px = right_.px;
pn = right_.pn;
if( px != NULL )
*pn += 1;
return *this;
}
operator pointer() const
{
return px;
}
 대입 연산자는 복사 생성자와 거의 동일하
게 구현합니다 .
 타입에 대한 포인터 연산이 제대로 동작하
도록 operator T*() 를 정의합니다 .

shared_ptr: release() 구현
27
void release()
{
if( px != NULL && *pn >= 1 )
{
*pn -= 1;
if( *pn == 0 )
{
delete px;
px = NULL;
delete pn;
pn = NULL;
}//if
}//if
px = NULL;
pn = NULL;
}
 release() 는 먼저 참조 카운터를 감소합니
다 .
 참조 카운터가 0 이되면 , 실제 리소스를
해제 합니다 .

shared_ptr: reset(), use_count() 구현
28
void reset()
{
release();
}
void reset(T * p)
{
release();
px = p;
pn = NULL;
if( px != NULL )
pn = new int(1);
}
int use_count() const { return *pn; }
 reset() 은 해제 후 할당과 동일합니다 .
 완성된 shared_ptr 은 암시적 생성 implicit
construction 을 지원하지 않으므로 , reset()
구현이 반드시 필요합니다 .
 use_count() 는 현재 참조 카운터를 리턴합
니다 .

shared_ptr: operator*(), operator->() 구현
29
reference operator*() const // never throws
{
return *px;
}
T* operator->() const // never throws
{
return px;
}
private:
T* px;
int* pn;
};//template<class T> class shared_ptr
 간접지정 연산자와 화살표 연산자가 제대
로 동작하도록 함수를 작성합니다 .
 void* 에 대한 참조가 동작하도록 하기 위해
서는 void 에 대한 참조를 템플릿 특화로 미
리 구현해 두어야 합니다 .

main() 에서 테스트
30
int main()
{
typedef shared_ptr<int> IntPtr;
IntPtr spInt = new int(3); // spInt.use_count() == 1
if( spInt != NULL )
{
std::cout << *spInt << std::endl; // 3
}//if
IntPtr spInt2 = spInt; // spInt.use_count() == 2
IntPtr spInt3 = spInt; // spInt.use_count() == 3
spInt.reset( new int(4) ); // spInt.use_count() == 1
*spInt = 5; // 3 changed to 5
if( spInt2 != NULL ) // spInt2.use_count() == 2
{
std::cout << *spInt2 << std::endl; // 3
}//if
return 0;
}//int main()

copy-and-swap: swap() 메서드 구현
31
void swap( shared_ptr<T>& right_ ) // never throws
{
std::swap( px, right_.px );
std::swap( pn, right_.pn );
}
 exception safety
1) Basic: component 의 invariant 는 보존되고 , resource
leak 은 발생하지 않아야 합니다 .
2) Strong: 성공적으로 완료되었던지 예외를 던졌던
지 둘 중의 하나여야 합니다 .
3) No-throw: 예외를 던지지 않아야 합니다 .
 copy-and-swap 을 지원하기 위해서 shared_ptr 의
swap() 은 예외를 던지지 않도록 구현해야 합니다 .

shared_ptr: swap() 을 반영한 수정
32
shared_ptr& operator=( const shared_ptr& right_ )
{
//release();
//px = right_.px;
//pn = right_.pn;
//if( px != NULL )
// *pn += 1;
this_type(right_).swap(*this);
return *this;
}
void reset(T * p)
{
//release();
//px = p;
//pn = NULL;
//if( px != NULL )
// pn = new int(1);
this_type(p).swap(*this);
}

관찰 : if 의 조건문 표현식
33
class KBoolTest
{
public:
operator bool() const { return true; }
operator int() const { return 1; }
operator int*() const { return NULL; }
int GetValue() const { return 9; }
};
int main()
{
KBoolTest t;
if( t )
std::cout << t.GetValue() << std::endl;
return 0;
}//int main()
 if 문의 조건은 일반적인 bool 표현식이 아닌
C 가 허용하는 참인 조건식을 적을 수 있습니다
.
 평가의 partial order 의 순서는 bool  native
type  pointer 의 순입니다 .

safe bool idiom
34
//int* p = spInt; // (1)
//if( spInt < spInt ) // (2)
//{
//}  지금까지의 구현은 (1) 과 (2) 처럼 잘못된 사
용이나 , 의미없는 bool 표현식을 막지 못
합니다 .
template <typename T> void some_func(const T& t) {
if (t)
t->print();
}
 smart pointer T 에 대해 이 문장이 동작
하려면 T 는 bool 형에 대한 형 변환 연
산자를 제공해야 합니다 .

해결시도 1: operator bool() 구현
35
class Testable {
    bool ok_;
public:
    explicit Testable(bool b=true):ok_(b) {}

    operator bool() const {
      return ok_;
    }
};  shared_ptr 은 자신이 valid 한 raw pointer 를 가질 때 ,
true 를 리턴하는 operator bool() 을 작성할 수 있습니다 .

operator bool() cont.
36
test << 1; // (1)
int i=test; // (2)
Testable a;
AnotherTestable b;

if (a==b) { // (3)
}

if (a<b) { // (4)
}
 이 구현은 (1), (2) 같은 의미 없는 문장
이나 , (3), (4) 같은 의미 없는 bool 검
사를 막지 못합니다 .

해결시도 2: operator void*() 구현
37
operator void*() const {
return ok_==true ? this : 0;
}
 이 구현은 영리해 보이지만 , 아래의 문장처럼
delete 를 직접호출 할 수 있는 약점을 가집니다 .
Testable test;
delete test;

해결시도 3: nested class
38
class Testable {
    bool ok_;
public:

    class nested_class;

    operator const nested_class*() const {
      return ok_ ? reinterpret_cast<const nested_class*>(this) : 0;
    }
};
Testable b1,b2;

if (b1==b2) {
}

if (b1<b2) {
}
 safe bool 을 위한 nested class 구현 역시 의미없는 bool 검
사를 막지 못합니다 .
 이 문제를 해결하려면 포인터 형변환이 되지만 , < 같은 비교
연산자를 지원하지 않는 데이터 타입을 사용하는 것입니다 .
 흥미롭게도 멤버 함수에 대한 포인터가 그렇게 동작합
니다 !

최종 버전 : safe bool idiom
39
class Testable {
    bool ok_;
    typedef void (Testable::*bool_type)() const;
    void this_type_does_not_support_comparisons() const {}
public:

    operator bool_type() const {
      return ok_==true ?
        &Testable::this_type_does_not_support_comparisons : 0;
    }
};
 if- 문장의 조건 표현식에 포인터가 사용될 수
있는 점을 이용하여 , 함수 포인터를 리턴하
는 연산자 함수를 정의합니다 .

shared_ptr 의 내부 : unspecified_bool_type 사용
40
//operator pointer() const
//{
// return px;
//}
void unspecified_bool() const
{
}
typedef void (shared_ptr::*unspecified_bool_type)() const;
operator unspecified_bool_type() const // never throws
{
return px == 0 ? 0 : &shared_ptr::unspecified_bool;
}
 boost 의 실제 코드는
unspecified_bool_type() 을 사용합니다 .
 C++ 표준 라이브러리 뿐만 아니라 , 게임
엔진의 스마트 포인터 구현은 모두 이러한
기법을 사용합니다 .

shared_ptr 에 적용된 safe bool idiom
41
typedef shared_ptr<int> IntPtr;
IntPtr spInt = new int(3);
IntPtr spInt2 = spInt;
IntPtr spInt3 = spInt;
spInt.reset( new int(4) );
*spInt = 5;
if( spInt2 != NULL )
{
std::cout << *spInt << std::endl;
}//if
int* p = spInt; // (1) error
if( spInt2 < spInt3 ) // (2) error
{
}
 이제 (1) 과 (2) 같은 의미 없는 문
장은 컴파일 시간 에러가 발생합
니다 .

implicit constructor 문제 해결하기
42
void Test( shared_ptr<int> spInt_ )
{
}
int iData = 5;
Test( &iData );
 실제 포인터가 아닌 , 포인터 표현식에 대한
shared_ptr 생성을 막을 필요가 있습니다 .
 이 문제에 대한 해결방법은 명시적 생성만 가능하도록
클래스를 설계하는 것입니다 .
explicit shared_ptr(T * p = 0) : px(p), pn(0)
{
if( px != NULL )
pn = new int(1);
}

boost::weak_ptr 과 RAII 결합
43

weak_ptr<T>
44
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
class Test;
typedef boost::shared_ptr<Test> TestPtr;
typedef boost::weak_ptr<Test> TestWeakPtr;
class Test
{
public:
 shared_ptr 을 제공할 때 , 포인터 순환 참
조 문제등을 해결하기 위해서 weak_ptr 을
함께 제공합니다 .

weak_ptr<T> cont.
45
class TestRef
{
public:
TestRef(){}
void SetTest( TestPtr tp )
{
m_tp = tp;
}
void Print() const
{
if( TestPtr tp = m_tp.lock() )
{
tp->Print();
}
}
private:
TestWeakPtr m_tp;
};
 weak_ptr 을 사용하는 경우 , 지금 사용해
도 안전한 실제 포인터를 얻기 위해서
lock() 을 호출합니다 .
int main()
{
TestPtr tp = Test::CreateTest( 1 );
TestRef ref;
ref.SetTest( tp );
tp.reset();
ref.Print();
}//int main()

weak_ptr<T> lock()
46
 weak_ptr<T> 의 lock() 구현
shared_ptr<T, A, D> lock() const // never throws
{
// optimization: avoid throw overhead
if(expired()){
return shared_ptr<element_type, A, D>();
}
BOOST_TRY{
return shared_ptr<element_type, A, D>(*this);
}
}
 shared_ptr<T>( weak_ptr<Y> ) 구현
template<class Y>
explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
{
// it is now safe to copy r.px, as pn(r.pn) did not throw
px = r.px;
}

raw pointer 에서 shared_ptr 얻기 : factory
47
class X
{
private:
X() { ... }
public:
static shared_ptr<X> create()
{
shared_ptr<X> px(new X);
// use px as 'this_'
return px;
}
};
 shared_ptr<T> 로 관리되지 않는 raw 포
인터에서 shared_ptr<T> 을 얻을 필요가
있습니다 .
 클래스 객체가 shared_ptr<T> 로 관리되
더라도 , 생성자에서 shared_ptr<T> 를 얻
을 방법도 없습니다 .
 해결 방법은 weak_ptr 과 팩토리 함수를
사용하는 것입니다 .

factory: this 에 대한 shared_ptr<T>
48
class impl: public X, public Y
{
private:
weak_ptr<impl> weak_this;
impl(impl const &);
impl & operator=(impl const &);
impl() { ... }
public:
static shared_ptr<impl> create()
{
shared_ptr<impl> pi(new impl);
pi->weak_this = pi; // (1) 팩토리에서 weak_ptr<T> 을 초기화 해 놓습니다 .
return pi;
}
virtual void f() { ... }
virtual shared_ptr<X> getX()
{
shared_ptr<X> px(weak_this);
return px;
}
};
 대상 객체를 생성할 때 , weak_ptr 이 적절
하게 초기화되도록 합니다 .
 그러면 , 후에 필요하면 대상 객체에 대한
shared_ptr 을 얻을 수 있습니다 .

boost::enable_shared_from_this<T>
49
#include <iostream>
class Test;
typedef boost::shared_ptr<Test> TestPtr;
class Test : public boost::enable_shared_from_this<Test>
{
public:
static TestPtr CreateTest(int i)
{
TestPtr sp( new Test( i ) );
return sp;
}
Test(int i) : m_i(i) {}
void Print() const
{
std::cout << m_i << std::endl;
}
private:
int m_i;
};
 이 역할을 하는 boost 의 베이스 클래스가
enabled_shared_from_this 입니다 .

shared_from_this()
50
void TestFun( Test* pt )
{
TestPtr tp;
if( pt != NULL )
tp = pt->shared_from_this();
if( tp != NULL )
{
tp->Print();
}
}
 Test 가 enable_shared_from_this 를 상속받은 경ㅇ
우 , raw pointer 에서 shared_ptr 을 얻기 위해서는
shared_from_this() 를 호출합니다 .

응용 예 : RAII
51
#define KSmartPointer(type_)
class type_;
typedef boost::shared_ptr<type_> type_##SharedPtr;
typedef boost::weak_ptr<type_> type_##WeakPtr;
#define IF_MEMBER_WEAKPTR( member_name_ )
if( boost::shared_ptr<BOOST_TYPEOF(member_name_)::element_type> member_name_ = this-
>member_name_.lock() )
 게임 객체가 관리되는 리소스가 있는 경우에만 사용하려
고 하는 경우 , 리소스에 대한 weak_ptr 을 멤버로 가집니
다 .
 게임 객체가 실제 객체를 사용하려고 하면 , lock() 호출이
필요합니다 .
 이러한 패턴을 RAII 매크로로 작성했습니다 .

응용 예 cont.
52
class TestContainer
{
public:
TestContainer(){}
void SetTest( TestSharedPtr tp )
{
m_tp = tp;
}
void Print() const
{
IF_MEMBER_WEAKPTR( m_tp )
{
m_tp->Print();
}//if
}
private:
TestWeakPtr m_tp;
};
 IF_MEMBER_WEAKPTR() 은 RAII 스타일의 매크
로로 멤버에 대한 안전한 접근을 보장합니다 .

참고자료
 http://www.boost.org/doc/libs/1_35_0/libs/type_tra
 http://www.boost.org/doc/libs/1_37_0/libs/smart_pt
 http://www.artima.com/cppsource/safebool.html
54

Boost라이브러리의내부구조 20151111 서진택

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Boost라이브러리의내부구조 20151111 서진택

Ähnlich wie Boost라이브러리의내부구조 20151111 서진택 (20)

Mehr von JinTaek Seo

Mehr von JinTaek Seo (20)

Boost라이브러리의내부구조 20151111 서진택

Hinweis der Redaktion