1.49 버전의 대부분은 기존 라이브러리의 버그 수정과 기능 추가입니다.


신규 라이브러리는 아래와 같습니다.
Heap
: 우선 순위 큐 구조의 구현


버그 수정 및 기능 추가된 라이브러리
Asio
Chrono
Container
Filesystem
Geometry
Graph
Icl
Interprocess
Intrusive
Lexical cast
Locale
Move
Property Tree
Spirit
Thread
Unordered
Uuid
저작자 표시
신고
by 흥배 2012.02.26 17:32

앞서 소개한 boost::move와 같이 Boost 1.48 버전에서는 C++11의 컨테이너가 추가되었습니다. 그래서 이 컨테이너들을 사용하면 RValue ReferencePlacement Insert 기능이 구현된 것을 사용할 수 있습니다(현재 VC++ 10STL 컨테이너들은 Placement Insert는 구현되어 있지 않습니다).

 

Boost의 컨테이너들은 기본적으로 기존의 STL 컨테이너들과 같으며 다만 C++11의 새로운 기능이 추가되어 있습니다.

 

기존에는 vector를 사용하기 위해서는

std::vector를 사용했다면 boost용 컨테이너를 사용하기 위해서는

boost::container 라는 이름 공간을 사용하기 때문에

boost::container::vector로 사용합니다.

저작자 표시
신고
by 흥배 2011.12.15 09:00
오픈 소스 C++ 라이브러리인 'Boost 라이브러리'가 11월 15일에 1.48 버전이 나왔습니다.
boost 라이브러리는 근래에 업데이트를 할 때 새로운 C++ 표준인 C++11에 맞춘 업데이트를
종종 하고 있습니다.

그 중 이번 1.48에서는 boost::move 라는 것이 추가 되었습니다.
C++11을 공부하신 분들은 이게 뭔지 딱 바로 아실겁니다^^

네 바로 RValue Reference를 위한 것입니다.
현재 VC++ 10을 사용하지 못하는데 RValue Reference를 사용하고 싶다면
당장 boost 라이브러리를 설치하고 사용하세요.

사용 방법은 VC++ 10과 같습니다. 차이는 네임스페이스만 다릅니다.

std::vector<int> v1;
v1.push_back(10);
v1.push_back(12);
 
 
std::vector<int> v2 = boost::move(v1);



ps) 위의 move는 올바르게 동작하지 않습니다. 이유는 아직 VC++ 8,9의 stl 컨테이너에는
RValue Reference 기능을 정의하지 않았기 때문입니다.
그래서 이 문제를 해결하는 방법이 또 있습니다. 이것은 다음 글에 알려드리겠습니다^^


저작자 표시
신고
by 흥배 2011.12.09 09:00

boost::any

 

abstract

필요한 헤더

<boost/any.hpp>

가능한 일

거의 어떤한()이라도 저장 가능한 동적형 변수

레퍼런스

en / jp

 

sample

#include <iostream>

#include <boost/any.hpp>

using namespace std;

 

struct Point

{

        Point(int ix=0,int iy=0) : x(ix), y(iy) {}

        int x, y;

};

 

static char* hw = "hello world.";

 

int main()

{

        boost::any a, b;

        a = 100; // 정수를 넣는다.

        b = hw;  // 문자열을 넣는다.

        a = b;   // any동사의 대입

        b = Point(10,20); // 사용자 정의 형도 넣어보자..

 

        // 값을 빼낸다.

        cout << boost::any_cast<Point>(b).x << endl;

        if( a.type() == typeid(int) )

               cout << "int입니다." << endl;

        else if( a.type() == typeid(char*) )

               cout << "문자열입니다." << endl;

 

        return 0;

}

출력

10.

문자열입니다.


any_cast 실패하면  bad_any_cast 던진다.

 

etc

생성자랑 대입 연산자가 template로 되어 있어서 넘겨진 오브젝트의 형에 따라서 대응하는 holder 클래스를 만들어 그것을 기저 클래스의 포인터에 의해서 any 중에 보관한다 라는 것으로 구현 되어 있다.


출처 : http://www.kmonos.net/alang/boost/classes/any.html
저작자 표시
신고
by 흥배 2010.08.02 09:00

"unordered"의 의미

표준 C++ 라이브러리에는 set, multiset, map, multimap 4개의 컨테이너가 준비되어 있습니다. 이것들은 binary-tree를 그 구현에 이용한 것입니다. 대소 관계에 근거해 요소를 binary-tree로 나누어 내린 것으로 삽입이나 검색에 필요로 하는 시간 계산량은 Ο(logN) 즉 요소 수의 log에 비례합니다.

 

이번 TR1에서 새롭게 추가된 unordered_set, unordered_multiset, unordered_map, unordered_multimap은 종래의 set, multiset, map, multimap 과 각각 기능적으로는 같습니다. 다른 것은 그 구현이 binary-tree는 아니고 해시표(hash-table)가 이용되고 있습니다. 최대의 특징은 그 스피드에 있습니다.

 

 

해시표가 빠른 이유

해시표는 간단하게 말하면 「일렬로 줄선 버켓」입니다. 각각의 버켓에는 일련 번호가 붙어 있어 각 버켓에는 복수의 볼(요소)을 저장 할 수 있습니다. 버켓은 볼을 요소로 하는 가변장 배열이라고 생각해도 좋을 것입니다.

 

여기에 버켓이 한 개 있고 N개의 볼이 들어가 있다고 합시다. 볼에는 번호가 써 있습니다. 이 때 적당한 번호를 지정하고 그 번호가 쓰여진 볼을 버켓안에서 찾아오는 것을 생각합니다.

버켓 안의 볼은 무 순서이기 때문에 목적의 볼을 찾아내려면 한개씩 꺼내어 그것이 목적의 것인지를 조사하지 않으면 안됩니다. 행운이 있다면 첫번째에 바로 찾을 수 있지만 최악의 케이스는 끝까지 조사했지만 발견되지 않았을 때입니다. 평균하면 볼 찾기에 필요한 비교 회수는 N/2 즉 검색에 필요로 하는 시간은 N에 비례합니다.

 

그럼 버켓을 두 개 준비하여 짝수 차례의 볼을번 버켓에 / 홀수 차례의 볼을번 버켓에 넣는다고 약속해 둡니다. 그러면 적당한 번호의 볼을 찾아내려면 그 번호가 짝수라면번 버켓 / 홀수라면 1  버켓의 내용만을 조사하면 된다. 볼의 번호에 큰 편향이 없으면 각 버켓 내의 볼은 거의 동수의 N/2 이니까 검색에 필요로 하는 시간은 버켓 한 개의 경우의 반입니다.

 

이 상태로 버켓 수를 M개로 하여 각 볼은 거기에 붙은 번호를 M으로 나눈 나머지가 나타내 보이는 버켓에 넣읍시다. 그러면 검색 시에 조사하지 않으면 안 되는 볼의 수, 즉 검색에 필요로 하는 시간은 N/M으로 단축됩니다.

 

그 말은 M N과 같은 정도로 해 두면 N/M이 대체로 1이 됩니다. 이것은 볼의 총수에 관계없이 거의 순간에 검색이 종료하는 것을 의미합니다. 요소의 검색 대상이 되는 모집단의 요소 수를 1로 접근하는 것으로 검색 스피드를 올리려는 전략입니다.

 

여기서 중요한은 각 볼을 어느 버켓에 저장 할까를 결정하는 수단입니다. 상기의 예에서는 「볼 번호를 버켓 수로 나눈 나머지」라고 하고 있습니다만 만약 볼 번호에 큰 편향이 있으면 버켓 내의 볼수에 편향이 생겨 검색 시간이 성장해 버립니다. 볼이 많이 찬 버켓과 거의 텅 빔의 버켓이 가능하게 되니까요.

 

요소()x 로부터 어떠한 일의인 값(버켓 번호)을 도출하는 함수를 「해쉬 함수 h(x)」라고 이름 붙입시다.

해쉬 함수 h가 채우지 않으면 안 되는 조건은:

x = y 이라면 h(x) = h(y)

입니다. 그렇지 않으면 볼 검색시에 들어가 있어야할 "모레의 버켓"안을 찾아 버리게 될테니까.

다만 x ≠ y  h(x) = h(y) 되는 일이 있습니다. 해쉬 함수 버켓 번호를 결정하므로 x y는 같은 버켓에 저장 됩니다.

해쉬 함수가 돌려주는 값(해시 값)이 같은 요소군을 동의어(synonym:동의어)라고 부르고 있습니다.

 

클래스 템플릿: unordered_set

TR1에는 해시표를 사용한 4종의 컨테이너가 정의되고 있습니다.

unordered_set : 요소의 중복을 허락하지 않는 집합

unordered_multise t: 요소의 중복을 허락하는 집합

unordered_map : 요소의 중복을 허락하지 않는 사전

unordered_multimap : 요소의 중복을 허락하는 사전

 

 

이것들을 대표하여 unordered_set에 대해서 그 개요를 설명합니다.

namespace std {

namespace tr1 {

// [6.3.4.3] Class template unordered_set

template < class Value,

class Hash = hash,

class Pred = std::equal_to,

class Alloc = std::allocator >

class unordered_set;

}

}

 

unordered_set 의 템플릿 인수는4.

Value : 컨테이너 요소의 형태

Hash : Value 로부터 해시 값을 요구하는 함수 오브젝트

Pred : Va lue 가 동일할 때 true 되는 함수 오브젝트

Alloc : allocater

 

Hash 의 디폴트 인수는 hash Value를 인수로 하여 size_t를 돌려주는 operator()를 구현합니다. 편입형과 문자열에 대해서는 표준 헤더 functional 에 정의되고 있습니다. 이것들 이외의 형태를 요소로 하는 unordered컨테이너를 이용할 때는 적절한 해쉬 함수 오브젝트를 주지 않으면 안됩니다.

 

 헤더: functional 에 정의된 hash

namespace std {

namespace tr1 {

template < class T>

struct hash : public std::unary_function size_t >

{

std:: size_t operator ()(T val) const ;

};

 

template <> struct hash< bool >;

template <> struct hash< char >;

template <> struct hash< signed char >;

template <> struct hash< unsigned char >;

template <> struct hash< wchar_t >;

template <> struct hash< short >;

template <> struct hash< unsigned short >;

template <> struct hash< int >;

template <> struct hash< unsigned int >;

template <> struct hash< long >;

template <> struct hash< unsigned long >;

template <> struct hash< float >;

template <> struct hash< double >;

template <> struct hash< long double >;

template<class T> struct hash<T*>;

template <> struct hash<std::string>;

template <> struct hash<std::wstring>;

}

}

 

컨테이너에 대한 요소의 삽입/삭제/검색 및 열거에 관한 인터페이스는 종래의 set과 다르지 않습니다:

insert : 요소의 삽입


erase
: 요소의 삭제


clear
: 모든 요소를 삭제하여 컨테이너를 비운다


find
: 요소의 검색


count
: 검색에 의해서 일치한 요소 수


equal_range
: 검색에 의해서 일치하는 요소 위치의 범위

 

unordered 컨테이너 독자적인 멤버 함수를 이하에 나타냅니다

 

 

bucket_count

size_type bucket_count() const

  컨테이너 내의 버켓의 수를 돌려줍니다.

 

max_bucket_count

size_type max_bucket_count() const

 컨테이너 내에 내포 할 수 있는 버켓의 최대수를 돌려줍니다.


bucket

size_type bucket(k)

 요소 k가 저장 될 버켓의 번호를 돌려줍니다.


bucket_size

size_type bucket_size(n)


 n번째의 버켓에 격납된 요소수를 돌려줍니다.

 

begin

local_iterator begin(n)

const_local_iterator begin(n) const

 n번째의 버켓에 저장된 요소의 선두 위치를 돌려줍니다.


end

local_iterator end(n)

const_local_iterator end(n) const

 n번째의 버켓에 격납된 요소의 마지막 위치를 돌려줍니다.


load_factor

float load_factor() const

 버켓에 저장 되고 있는 요소 수의 평균 값 즉 요소 수/버켓 수를 돌려줍니다.


max_load_factor

float max_load_factor() const

 버켓에 저장되는 요소 수의 평균 값의 상한을 돌려줍니다. 요소의 삽입에 의해서 이 상한 값을 넘었을 때 새로운 버켓이 추가되어 각 요소가 버켓에 재 배분됩니다.

 

void max_load_factor( float z)

 버켓에 저장 되는 요소 수의 평균 값의 상한을 z로 설정합니다.


rehash

void rehash(size_type n)

 버켓 수가 적어도  n이 되도록 버켓 수가 조정되어 각 요소가 재배분됩니다.

 

 

 

set 과의 속도 비교

마지막으로 해시표에 의한  unordered_set binary-tree에 의한 set 과의 속도를 비교해 봅시다. 1~100000의 난수를 2백만개 삽입했을 때의 각각의 소요 시간을 계측합니다.

 

set    unordered_set 속도 비교

// min/max매크로의 간섭 방지

#define NOMINMAX

#include <windows.h>

#include <iostream>

#include <set>

#include <unordered_set>

#include <unordered_map>

#include <random>

 

using namespace std;

 

int main()

{

set< int > s;

tr1::unordered_set< int > us;

const int N = 100000;

tr1::mt19937 rng; // 메르센누·트이스타

tr1::uniform_int<> dice(1,N); // 정수일 모양 분포

tr1::variate_generator     <tr1::mt19937&, tr1::uniform_int<> > sample(rng, dice);

 

long t;

const int TIMES = 2000000;

rng.seed(12345);

t = GetTickCount();

for ( int i = 0; i < TIMES; ++i ) {

s.insert(sample());

}

t = GetTickCount() - t;

cout << t << "(set)\n" ;

 

rng.seed(12345);

//us.rehash(N); /* 버켓수의 조정 */

t = GetTickCount();

for ( int i = 0; i < TIMES; ++i ) {

us.insert(sample());

}

 

t = GetTickCount() - t;

cout << t << "(unordered_set)\n" ;

}

}

 

< 실행 결과 >

1562(set)

1188(unordered_set)

 

 

25% 정도 unordered_set 쪽이 빠른 것 같습니다. 그다지 큰 속도 차이가 나지 않았습니다만 이것은 컨테이너 내에 요소가 추가되는것에 따라서 버켓 수의 확장과 요소의 재 배분이 자주 행해지는데 필요로 하는 시간을 포함하고 있습니다. 코드 중간의 //us.rehash(N); 의 코멘트를 없애고 처음부터 충분한 수의 버켓을 확보했을 경우 실행 결과는:

 

1563(set)

875(unordered_set)

되어 set 의 약2배의 속도를 얻을 수 있었습니다.

 

 

출처 : http://codezine.jp/a/article/aid/2171.aspx

 

 

저작자 표시
신고
by 흥배 2010.03.17 08:30

표준 C++ 라이브러리가 제공하는 다양한 함수에는 1(혹은 2)의 인수를 주는 함수 오브젝트를 인도하는 것이 다수 있습니다.

 

정수는 몇 개?

#include <iostream>
#include <algorithm>

using namespace std;

 

// n정수라면 true를 돌려준다

bool is_positive( int n)

{

return n > 0;

}

 

int main()

{

const int N = 8;

int data[N] = { -3, -2, -1, 0, 1, 2, 3, 4 };

   /* count_if(first, last, pred):

* first이상 last미만의 범위에 있 x에 대해

* pred(*x) true (!=0) 되는 것의 개수를 돌려준다 */

cout << count_if(data, data+N, &is_positive) << " positives\n" ;

}

 

< 실행 결과 >

4 positives

 

 

표준 C++ 라이브러리의 함수 오브젝트 less를 사용 하여 상기의 is_positive로 옮겨지지 않는지 생각해 봅시다.

함수 오브젝트 less의 멤버 함수 operator()는 인수를 2개 취하여 1 인수가 2 인수 보다 작으면 true를 돌려줍니다.

 

 

함수 오브젝트 less

std::less< int > int_less;

bool result = int_less(1,2); // true

result = int_less(2,1); // false

result = int_less(2,2); // false

 

 

less를 방금 전의 알고리즘 :count_if의 제3인수에 사용하기 위해 binder1stless::operator() 1 인수를 0으로 속박(고정) 합니다.

 

bind1st/bind2nd에 의한 속박

#include <iostream>
#include <algorithm>
#include <functional>

using namespace std;

 

int main()

{

const int N = 8;

int data[N] = { -3, -2, -1, 0, 1, 2, 3, 4 };

// 1인수를 0으로 속박 하는 것으로,

// 인수가 정수라면 true를 돌려주는 함수 오브젝트가 된다.

cout << count_if(data, data+N, bind1st(less< int >(),0)) << " positives\n" ;

// 2인수를 0으로 속박 하면 정수라면 true를 돌려준다.

cout << count_if(data, data+N, bind2nd(less< int >(),0)) << " negatives\n" ;

}

 

< 실행 결과 >

4 positives

3 negatives

 

 

그러면 「-3 이상, 3 미만의 요소 수」를 요구하려면 어떻게 할까요.

mid lo 이상, hi 미만이라면 true를 돌려준다

template <typename T>

bool in_between(T lo, T mid, T hi) {

return lo <= mid && mid < hi;

}

 

이런 함수 in_between 을 준비하여 제1인수를 -3, 3인수를 3으로 속박 하면 좋겠습니다만 표준 C++이 준비해 주고 있는 바인더(속박 함수) 2항 함수 오브젝트에 대한 bind1st bind2nd 뿐입니다.

TR1은 이와 같이 제한의 어려운 바인더를 일반 화해, operator() 에게 주는 임의의 인수를 속박 하는 범용 바인더 : bind 를 제공해 줍니다.

 

 

bind를 사용해 -3 이상, 3 미만의 요소를 센다

#include <iostream>

#include <algorithm>

#include <functional>

#include <boost/tr1/functional.hpp>

using namespace std;

 

// lo <= mid < hi 이라면 true를 돌려준다

template <typename T>

bool in_between(T lo, T mid, T hi) {

return lo <= mid && mid < hi;

}

 

int main()

{

const int N = 8;

int data[N] = { -3, -2, -1, 0, 1, 2, 3, 4 };

// 플레이스홀더: _1, _2, ... 를 유효하게 한다

using namespace tr1::placeholders;

// in_between의 제1,3인수를 각각 -3,3으로 속박 한다

cout << count_if(data, data+N,

tr1::bind(&in_between< int >, -3, _1, 3)) << " numbers are [-3,3)\n" ;

}


실행 결과

6 numbers are [-3,3)

 

 

플레이스홀더의 수/위치/순서는 자유롭게 선택할 수 있기 때문에 이하의 샘플과 같이 3항 함수의 인수 1개를 속박 해  2항 함수로 할 수도 있습니다.

 

요소의 소트

#include <iostream>

#include <algorithm>

#include <functional>

#include <boost/tr1/functional.hpp>

 

using namespace std;

 

// 오름/내림차순의 어느 쪽에도 사용할 수 있는 비교 함수

template <typename T>

bool compare(T x, T y, bool descend) {

return descend ? (x < y) : (y < x);

}

 

int main()

{

const int N = 8;

int data[N] = { 0, -1, 1, -2, 2, -3, 3, 4 };

using namespace tr1::placeholders;

// 내림차순로 소트sort의 제3인수는 2항 함수 오브젝트

sort(data, data+N, tr1::bind(&compare< int >, _1, _2, false ));

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

// 승순으로 소트

sort(data, data+N, tr1::bind(&compare< int >, _1, _2, true ));

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

// 이것도 역시 승순으로 소트(플레이스홀더의 순서에 주목)

sort(data, data+N, tr1::bind(&compare< int >, _2, _1, false ));

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

}


실행 결과

4 3 2 1 0 -1 -2 -3-3 -2 -1 0 1 2 3 4-3 -2 -1 0 1 2 3 4

 

 

한층 더 bind 는 클래스의 멤버 함수마저도 바인드 해 줍니다.

 

멤버 함수의 바인드

#include <iostream>

#include <string>

#include <boost/tr1/functional.hpp>

 

using namespace std;

 

class Sandwitch {

string mid_;

public :

Sandwitch( const string& mid) : mid_(mid) {}

string make( const string& head, const string& tail) const {

return head + mid_ + tail;

}

};

 

int main()

{

Sandwich s( " and " );

Sandwich* p = &s;

using namespace tr1::placeholders;

// s.make("boys,"girls")

cout << tr1::bind(&Sandwich::make, s, "boys" , _1)( "girls" ) << endl;

// p->make("ladies","gentlemen")

cout << tr1::bind(&Sandwich::make, p, "ladies" , _1)( "gentlemen" ) << endl;

// p->make("black","white")

cout << tr1::bind(&Sandwich::make, p, _2, _1)( "while" ,"black" ) << endl;

// s.make("hit","away")

cout << tr1::bind(&Sandwich::make, _1, "hit" , "away" )(s) << endl;

// p->make("adam","eve");

cout << tr1::bind(&Sandwich::make, _1, "adam" , "eve" )(p) << endl;

// s.make("love","peace")

cout << tr1::bind(&Sandwich::make, _1, _2, _3)(s, "love" ,"peace" ) << endl;

}


실행 결과

boys and girls

ladies and gentlemen

black and while

hit and away

adam and eve

love and peace

 

 

출처 : http://codezine.jp/a/article/aid/2158.aspx

저작자 표시
신고
by 흥배 2010.03.15 08:30

요소의 접근

 

tuple(0을 기점으로서) n번째의 요소는 함수 get을 개입시켜 접근 합니다. 다만 n은 정수가 아니면 안됩니다. get은 참조를 돌려주므로 좌변 값으로 이용하는 것으로 요소에 대입이 가능합니다.

    

get에 의한 참조와 대입

#include <iostream>

#include <string>

#include <boost/tr1/tuple.hpp> // tuple

 

using namespace std;

 

int main()

{

tr1::tuple exam;

tr1::get<0>(exam) = "Steve" ;

tr1::get<1>(exam) = 567;

tr1::get<2>(exam) = tr1::get<1>(exam) / 5.0;

cout << tr1::get<0>(exam) << "너의"

" 득점=" << tr1::get<1>(exam) <<

" 평균=" << tr1::get<2>(exa m) << endl;

}

 

 

  pair와의 인터페이스의 통일 때문에  pair에 대해서도 함수  get 적용할 수 있습니다.
    

pair에 대해서 get 한다

#include <iostream>

#include <string>

#include <utility>  // pair

#include <boost/tr1/tuple.hpp>// tuple

 

using namespace std;

 

int main()

{

pair police = make_pair( "???" , 110);

tr1::get<0>(police) = "순경" ;

 

cout << tr1::get<0>(police) << ':' << tr1::get<1>(police) << endl;

}

 

 

 

일괄 대입 / 일괄 참조

 

pair에 있어서 make_pair와 같이 tuple에는 함수 make_tuple 준비되어 있습니다. 또 함수  tie 에 의해서 복수의 변수를 일괄해 읽어낼 수 있습니다.

    

make_pair/tie

#include <iostream>

#include <string>

#include <boost/tr1/tuple.hpp>   // tuple

 

using namespace std;

 

int main()

{

tr1::tuple exam;

exam = tr1::make_tuple( "Steve" , 567, 567/5.0);

string name;

double mean;

// tie:사용하지 않는 요소에는 ignore(무시)를 지정 할 것

tr1::tie(name, tr1::ignore, mean) = exam;

cout << name << "너의 평균점은" << mean << endl;

}

 

 

 

비교

 

tuple의 비교 연산 == , != , <, <= , >, >= 은 각 요소를 왼쪽에서 순서 대로 비교합니다. 비교 도중에 진위가 확정하면 그 이후의 비교는 행해지지 않습니다.

     

tuple의 비교는 shortcut 된다

#include <iostream>

#include <boost/tr1/tuple.hpp>  // tuple

 

using namespace std;

 

struct Value

{

int n_;

Value( int n) : n_(n) {}

};

 

bool operator ==( const Value& x, const Value& y)

{

bool result = ( x.n_ == y.n_ );

cout << x.n_ << (result ? "==" :"!=" ) << y.n_ << endl;

return result;

}

 

bool operator <( const Value& x, const Value& y)

{

bool result = ( x.n_ < y.n_ );

cout << x.n_ << (result ? "<" :">=" ) << y.n_ << endl;

return result;

}

 

int main()

{

typedef tr1::tuple triple;

triple x(12,34,56);

triple y(12,43,56);

// 2 요소까지의 비교로 진위가 확정 되기 때문에

// 3 요소의 비교는 행해지지 않는다

cout << "x == y :" << boolalpha << (x == y) << endl;

cout << "x < y :" << boolalpha << (x < y) << endl;

}

 

< 실행 결과 >

12==12

34!=43

x == y : false

12>=12

12>=12

34<43

x < y : true

 

 

 

tuple_size,tuple_element

 

tuple_size::value Tuple의 요소 수, tuple_element::type Tuple N번째의 요소의 형태가 됩니다.

 

tuple_size, tuple_element

#include <iostream>

#include <string>

#include <boost/tr1/tuple.hpp>   // tuple

 

using namespace std;

 

// Tuple의 요소

template <<span style="font-family:굴림체; font-size:9pt; color:#0000ff;"> typename Tuple>

int members( const Tuple&)

{

return tr1::tuple_size::value;

}

 

// Tuple N번째를 '+' 한다

template <<span style="font-family:굴림체; font-size:9pt; color:#0000ff;"> int N, typename Tuple>

typename tr1::tuple_element::type

plus( const Tuple& x, const Tuple& y)

{

return tr1::get(x) + tr1::get(y);

}

 

int main()

{

tr1::tuple t1( "Hello" ,12);

tr1::tuple t2( "World" ,34);

cout << members(t1) << " members." << endl;

cout << plus<0>(t1,t2) << endl;

cout << plus<1>(t1,t2) << endl;

}

 

< 실행 결과 >

2 members.

HelloWorld

46

 

출처 : http://codezine.jp/a/article/aid/2134.aspx


저작자 표시
신고
by 흥배 2010.03.09 08:30

표준 C++ 라이브러리에는 두 개의 요소를 가지는 구조체: pair가 정의되어 있습니다.

  

pair

#include <iostream>

#include <string>

#include <utility> // pair

 

using namespace std;

 

int main()

{

   const int N = 3;

   pair phone[N];

 

  phone[0] = pair( "경찰" , 110); // 대입 1

  phone[1].first = "시보" ; // 대입 2

  phone[1].second = 117;

  phone[2] = make_pair( "소방" , 119); // 대입3

 

  phone[0].swap(phone[2]); // 교환

 

  for ( int i = 0; i < N; ++i ) {

    cout << phone[i].first << ':' << phone[i].second << endl;

  }

}


<
실행 결과>

소방:119

시보:117

경찰:110

 


pair로 묶을 수 있는 요소 수는 2개로 한정되기 때문에 그 이상의 요소 수를 정리하는 것은 많이 귀찮습니다.

   

pair에 억지로 3개의 요소 사용

#include <iostream>

#include <string>

#include <utility> // pair

 

using names pace std;

 

// pair string pair

struct musician : pair,string> {

typedef pair,string> base;

musician(string f, string m, string l) : base(make_pair(f,m),l) {}

};

 

ostream& operator <<(ostream& st ream, const musician& m) {

return stream << m.first.first << ' '

<< m.first.second << ' '

<< m.second;

}

 

int main()

{

musician wam( "Wolfgang" ,"Amadeus" ,"Mozart" );

musician jsb( "Johann" ,"Sebastian" ,"Bach" );

cout << wam << endl << jsb << endl;

}

 

< 실행 결과 >

Wolfgang Amadeus Mozart

Johann Sebastian Bach

 

 

TR1에서 제공 되는 tuple은 두 개 묶음인 pair를 확장 하여 임의의 N개의 요소를 묶음으로 할 수 있습니다(N은 구현 의존 boost1.34.1에서는 최대 9개였습니다).

    

tr1::tuple판 '음악가'

#include <iostream>

#include <string>

#include <boost/tr1/tuple.hpp> // tuple

 

using name space std;

 

struct musician : tr1::tuple<string,string,string> {

typedef tr1::tuple<string,string,string> base;

musician(string f, string m, string l) : base(f,m,l) {}

};

 

ostream& operator <<(ostream& stream, const musician& m) {

return stream << tr1::get<0>(m) << ' '

<< tr1::get<1>(m) << ' '

<< tr1::get<2>(m);

}

 

int main()

{

musician wam( "Wolfgang" ,"Amadeus" ,"Mozart" );

musician jsb( "Johann" ,"Sebastian" ,"Bach" );

cout << wam << endl << jsb << endl;

}


le(2/2


출처 : http://codezine.jp/a/article/aid/2134.aspx



저작자 표시
신고
by 흥배 2010.03.08 08:30

function

그런데 범용 바인더 bind 에 의해서 생성된 함수 오브젝트를 변수로 저장하여 얼마든지 알고리즘으로 사용해서 돌리는 것을 생각해 봅시다. 그러기 위해서는 bind가 생성한 함수 오브젝트의 ''을 가지는 변수를 선언하지 않으면 안됩니다.

   

 

bind의 생성하는 함수 오브젝트의 ''

cout << typeid (tr1::bind(&Sandwich::make, _1, _2, _3)).name();

 

실행 결과

class boost::_bi::bind_t< class std::basic_string< char ,

struct std::char_traits< char >,class std::allocator< char > >,

class boost::_mfi::cmf2< class std::basic_string< char ,

struct std::char_traits< char >,class std::allocator< char > >,

class Sandwich,class std::basic_string< char ,

struct std::char_traits< char >,class std::allocator< char > > const &,

class std::basic_string< char ,struct std::char_traits< char >,

class std::allocator< char > > const &>,

class boost::_bi::list3< class boost::arg<1>,class boost::arg<2>,class boost::arg<3> > >

 

……터무니없고 복잡한 형태가 만들어져 있습니다. 이것으로는 변수를 선언할 수 없습니다. 클래스 템플릿 function 은 함수 오브젝트의 범용적인''으로서 기능합니다.

 

 

함수 오브젝트를 통일적으로 취급한다

#include <iostream>

#include <algorithm>

#include <functional>

#include <boost/tr1/functional.hpp>

 

using namespace std;

 

// x < y 이라면 true를 돌려준다

bool less_int( int x, int y) {

return x < y;

}

 

// 승순/내림차순 어느 쪽에도 사용할 수 있는 비교 함수

template <typename T>

bool compare(T x, T y, bool descend) {

return descend ? (x < y) : (y < x);

}

 

int main()

{

const int N = 8;

int data[N] = { 0, -1, 1, -2, 2, -3, 3, 4 };

// template 인수가 조금 특수.

// 반환값 (변수,변수...) 라고 하는 형식.

tr1::function< bool ( int ,int)> comp;

// 승순으로 소트

using namespace tr1::placeholders;

comp = tr1::bind(&compare< int >, _1, _2, true );

sort(data, data+N, comp);

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

// 같은 승순으로 소트

comp = &less_int;

sort(data, data+N, comp);

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

// 이것도 역시 내림차순으로 소트

comp = less< int >();

sort(data, data+N, comp);

for ( int i = 0; i < N; ++i ) cout << data[i] << ' '; cout << endl;

}

 

 

 

출처 : http://codezine.jp/a/article/aid/2158.aspx

 

저작자 표시
신고
by 흥배 2010.03.07 08:30

InterThreads

작자 : Vicente J. Botet Escriba

리뷰매니저 : 필요함

다운로드 : http://www.boostpro.com/vault/index.php?action=downloadfile&filename=interthreads.zip&directory=Concurrent%20Programming&

 

설명 :

Boost.InterThreadsBoost.Threads에 몇 개의 기능을 확장합니다

 

o         thread_decorator : 스레드에 의해서 한 번만 불리는 setup/cleanup 함수를 정의하는 것을 가능하게 합니다

setup은 스레드 함수의 앞, cleanup은 스레드 함수를 나올 때 불립니다.

o         shared_ptr 특유의 스레드:이것은 다른 스레드로부터 그 스레드 특유의 문맥으로의 접근을 제공하는 thread_specific_ptr의 확장입니다. 그것이 공유되도록 저장하는 포인터는 Raw포인터 대신에 shared_ptr입니다.

o         thread keep alive mechanism:이 메카니즘은 그것들이 keep_alive_point를 정기적으로 부르는 것으로 살아 있는 것을 나타내지 않는 스레드를 검지하는 것을 가능하게 합니다. 스레드가 죽어 있도록 선언되는 경우 유저가 제공한 함수를 부르면 디폴트로 프로그램을 종료(abort)합니다.

o         스레드 tuples:스레드 수를 정적으로 알고 있는 스레드를 구축 시에 작성된 스레드 그룹을 정의합니다.

o         set_once:대기하고 있는 모든 변수를 한 번만 설정하는 변수 값에 통지하는 동기 장치.

o         thread_tuple_oneceset_once동기 장치를 사용하여 최초로 종료한 스레드를 연결(join)하는 것을 가능하게 하는 boost::thread_tuple의 확장.

o         thread_group_onceset_once 동기 장치를 사용하여 최초로 종료한 스레드를 연결(join)하는 것을 가능하게 하는 boost::thread_group의 확장.

 

 

thread_decoratorthread_specific_shared_ptr

Roland Schwarz에 의해서 만들어진 threadalert의 오리지날 구현에 근거합니다.

 

Boost.InterThreads는 스레드 setup/cleanup decorator, 스레드 특유의 공유 pointer, keep alive mechanism thread tuples를 더해 Boost.Threads를 확장합니다.

 

 

 

Bitfield

작자 : Vicente J. Botet Escriba

리뷰매니저 : 필요함

다운로드 : https://svn.boost.org/svn/boost/sandbox/bitfield/

문서 : https://svn.boost.org/svn/boost/sandbox/bitfield/libs/integer/doc/html/index.html

 

설명 :

범용적인 비트 필드 특성.

Boost.Bitfield는 아래의 것으로 구성됩니다:

 

genericgetter/setter 메소드를 제공하는 generic 비트 필드 특성 클래스

•비트 필드 특성 및 비트 필드의 getter/setter를 용이하게 정의한 BOOST_BITFIELD_DCL 매크로

 

 

 

Lockfree

작자 : Tim Blechmann

리뷰매니저 : 필요함

다운로드 : http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost_lockfree-241109.zip&directory=Concurrent%20Programming&

http://tim.klingt.org/git?p=boost_lockfree.git

문서 : http://tim.klingt.org/boost_lockfree/

 

설명 :

Boost.Lockfreelock-free 데이터 구조의 구현을 제공합니다.

lock-free 데이터 구조는 가이드와 같은 동기화를 블로킹 없이 다수의 스레드로부터 접근 할 수 있습니다.

lock-free 데이터 구조는 알고리즘의 블로킹이 높아서 최악의 경우 실행 시간에 연결될지도 모르는 리얼타임 시스템에서 priority 반전을 회피하든가, 혹은 멀티 프로세서 머신용의 확장성을 높이기 위해서 사용할 수 있습니다.

 

Boost.Lockfree는 아래를 제공합니다:

boost::lockfree::fifo lock-free fifo queue

boost::lockfree::stack lock-free stack

 




2009 12 Boost 리뷰 현황 - 1

2009 12 Boost 리뷰 현황 - 2

2009 12 Boost 리뷰 현황 - 3

 


2차 출처 : http://d.hatena.ne.jp/faith_and_brave/20091208/1260252728#tb

1차 출처 : http://groups.google.com/group/boost-list/browse_thread/thread/1b1d5855452f0890#


저작자 표시
신고
by 흥배 2010.03.05 08:30
| 1 2 3 4 5 6 7 |