블로그 이미지
Every unexpected event is a path to learning for you.

카테고리

분류 전체보기 (2328)N
Unity3D (572)N
Programming (472)
Unreal (4)
Gamebryo (56)
Tip & Tech (185)
협업 (34)
3DS Max (3)
Game (12)
Utility (116)
Etc (92)
Link (31)
Portfolio (19)
Subject (90)
iOS,OSX (38)
Android (13)
Linux (5)
잉여 프로젝트 (2)
게임이야기 (1)
Memories (19)
Interest (37)
Thinking (36)
한글 (26)
PaperCraft (5)
Animation (408)
Wallpaper (2)
재테크 (19)
Exercise (3)
나만의 맛집 (2)
냥이 (9)
육아 (9)
Total1,346,224
Today30
Yesterday132
Statistics Graph

달력

« » 2019.12
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31        

공지사항

태그목록

1. 개요

오브잭트 자원관리를 하다보면 오브잭트가 죽거나 더이상 어떤이유로 필요없어질 경우에 리스트에서 제거를 하려면 순회도중 죽었는지 검사해서 루프를 도는 도중 삭제를 해야한다.

 

2. 구현

it = list1.begin();
while(it != list1.end())
{
    if(*it == 죽었나?) list1.erase(it++);
    else ++it;	 	   
}
3.원리
원리는 먼저 it값이 erase()로 복사되어 넘어가고, 
it++가 실행되고, 마지막으로 erase()로 넘어간 복사된 it이 할 일을 마치고 무효화됨. 



[출처]
stl list 순회도중 삭제하기|작성자 도플광어
Posted by blueasa
TAG list, STL, 삭제

댓글을 달아 주세요

#include <iostream>
#include <list>
using namespace std;

 

template<typename T> 
class Stack
{
public:
 Stack() : m_bLIFO(true) { Clear(); }

 // 저장 방식을 설정한다.
 void SetLIFO( bool bLIFO ) { m_bLIFO = bLIFO; }

 // 초기화 한다.
 void Clear()
 {
  if( false == m_Datas.empty() )
   m_Datas.clear();
 }

 // 스택에 저장된 개수
 int Count() { return static_cast( m_Datas.size() ); }

 // 저장된 데이터가 없는가?
 bool IsEmpty() { return m_Datas.empty(); }


 // 데이터를 저장한다.
 void push( T data )
 {
  m_Datas.push_back( data ); 
 }

 // 스택에서 빼낸다.
 bool pop( T* data )
 {
  if( IsEmpty() )
  {
   return false;
  }


  if( m_bLIFO )
  {
   memcpy( data, &m_Datas.back(), sizeof(T) );
   m_Datas.pop_back();
  }
  else
  {
   memcpy( data, &m_Datas.front(), sizeof(T) );
   m_Datas.pop_front();
  }

  return true;
 }

private:
 list<T> m_Datas;
 bool  m_bLIFO; // true 이면 후입선출, false 이면 선입선출
};

 

void main()
{

 Stack<int> Int_Stack;

 Int_Stack.SetLIFO(true);

 Int_Stack.push(10);
 Int_Stack.push(20);
 Int_Stack.push(30);

 int Value = 0;
 Int_Stack.pop(&Value);
 //마지막에 넣은게 처음 나온다.
 cout << "Last In First Out pop : " << Value << endl <<  endl;
 
 //데이터 초기화
 Int_Stack.Clear();

 //FIFP로 설정
 Int_Stack.SetLIFO(false);

 Int_Stack.push(10);
 Int_Stack.push(20);
 Int_Stack.push(30);

 Int_Stack.pop(&Value);
 //처음에 넣은게 처음 나온다.
 cout << "First In First Out pop : " << Value << endl <<  endl;

}

 출처 : http://cafe.naver.com/jgcafe/694

Posted by blueasa
TAG FIFO, LIFO, list, STL

댓글을 달아 주세요

1. pair란?

  STL의 기본적인 유틸 클래스이다. 두가지의 값을 하나인것 마냥 사용할수 있도록 해주는 클래스이다.

 

2. pair 소스

      template<class _Ty1, class _Ty2>

      struct pair
      { 

             // store a pair of values
             typedef pair<_Ty1, _Ty2> _Myt;
             typedef _Ty1 first_type;
             typedef _Ty2 second_type;

            

             // 기본 생성자

             pair()  : first(_Ty1()), second(_Ty2())
             { 
             }

 

             // 복사 생성자

             pair(const _Ty1& _Val1, const _Ty2& _Val2) : first(_Val1), second(_Val2)
             { 

             }

             

             // 암시적 형변환시 사용되는 생성자      

             template<class _Other1,  class _Other2>
             pair(const pair<_Other1, _Other2>& _Right)  : first(_Right.first), second(_Right.second)
             { 

             }

 

            void swap(_Myt& _Right)
            {

                    if (this != &_Right)
                   { 

                         std::swap(first, _Right.first);
                         std::swap(second, _Right.second);
                   }
             }

             _Ty1 first; // the first stored value
             _Ty2 second; // the second stored value
       };

 

  두개의 탬플릿을 이용해서 값을 전달한다. 그 값이 명시적 형변환이냐 암시적 형변환이냐에 따라서 생성자를 호출하고 first와 second를 초기화 시켜준다. first와 second에 값을 넣어 주기 때문에 두개의 값을 하나로 사용할수 있다고 말해주는 것 같다.

 

3. 어디서? 어떻게? 사용을 할까?

  이제 막 STL 책에서 가장 앞쪽 부분만을 보고서 이렇게 글을 쓰다 보니 아주 조그만한 부분에서 사용되는것밖에 모르겠다. 일반적으로 우리는 vector, map, multimap등을 자주 사용하게 된다. 이런 부분에서 사용을 하면 매우 유용하다. 특히 map과 multimap의 경우에는 두개의 key와 value를 사용하게 되는데 이때 make_pair를 사용하면 매우 유용하다. make_pair는 아래와 같다.

 

                                    templateclass T1, class T2 >

                             namespace std {

                                    pair<T1, T2> make_pair( const T1& x, const T2& y )

                                    {

                                              return std::pair< T1, T2 >(x, y);

                                     }

                             }

 

  보면 알겠지만 pair<T1, T2>(x, y)를 리턴하기때문에 두개의 값을 하나로 쓰는 거라고 할수 있다. 그렇기 때문에 map과 multimap등에서 사용이 가능하다. 아래는 make_map을 사용한 예제 이다.

 

                                  using namespace std;

                            int main()

                            {

                                     typedef multimap< int, string > intStringMap;

                                     intStringMap coll;

 

                                     coll.insert( make_pair( 1"this" ) );

                                     coll.insert( make_pair( 2"that" ) );

                                     coll.insert( make_pair( 3"she" ) );

                                     coll.insert( make_pair( 4"you" ) );

 

                                     intStringMap::iterator pos;

                                     for( pos = coll.begin(); pos != coll.end(); pos++ )

                                     {

                                              printf("key : %d, value : %s\n", pos.first, pos.second.c_str() );

                                      }

 

                                      return 0;

                             }

 

  뭐 대충 이런 식으로 사용을 하면 유용하게 사용할수 있을 것 같다. 물론 이렇게 사요하지 않아도 된다. 위 소스는 multimap에 값을 넣고 반복자를 이용해서 값을 출력한 예제이다. 매우 간단하니 그냥 훓어보기만 하면 될것같다.

  pair 같은 경우는 STL에서 유용하게 사용되는 유틸 클래스이다. 이런 사용은 일반적인 경우이고 내부적으로 더욱 많은 부분에서 사용되고 있다고 한다.

 

4. 결론

  결국 처음에 말했던것과 같이 내가 이해한 pair는 두가지의 서로 다른 값을 하나와 같이 사용할수 있는 값의 집합이라고 보면은 매우 편한것 같다. 오늘 책을 잠깐 봤는데 읽으면서 나는 이렇게 이해했다. 책에서도 x, y값을 담는 POINT 구조체와 비슷한 느낌인것같다. 다른 점이라고한다면 template을 사용해서 서로 다른 타입의 변수를 대입할수 있다는 점인것 같다.


[출처]
 [STL] 유틸 클래스 pair|작성자 sangtakeg

Posted by blueasa
TAG Pair, STL

댓글을 달아 주세요

    문자열(std::string)을 키로 가지는 맵 같은 경우, 문자열 비교 자체에 걸리는 시간 때문에 검색이 느려질 수 있다. 이 경우, 키로 사용하는 문자열이 별로 중요한 내용이 아니라면 아래와 같은 클래스를 사용함으로서 성능을 약간 증가시킬 수 있다. 
    ////////////////////////////////////////////////////////////////////////////////
    /// \class cStringKey
    /// \brief STL 컨테이너를 위한 문자열 키
    ////////////////////////////////////////////////////////////////////////////////
    
    class cStringKey
    {
    private:
        enum
        {
            BYTE_SIZE = 32,
        };
    
        char m_Text[BYTE_SIZE]; ///< 문자열
    
    
    public:
        /// \brief 생성자
        cStringKey()
        {
            memset(m_Text, 0, sizeof(m_Text));
        }
    
        /// \brief 생성자
        cStringKey(const char* text)
        {
            memset(m_Text, 0, sizeof(m_Text));
            memcpy_s(m_Text, sizeof(m_Text), text, std::min(sizeof(m_Text), strlen(text)));
        }
    
        /// \brief 생성자
        cStringKey(const std::string& text)
        {
            memset(m_Text, 0, sizeof(m_Text));
            memcpy_s(m_Text, sizeof(m_Text), text.c_str(), std::min(sizeof(m_Text), text.size()));
        }
    
        /// \brief 복사 생성자
        cStringKey(const cStringKey& rhs)
        {
            memcpy_s(m_Text, sizeof(m_Text), rhs.m_Text, sizeof(m_Text));
        }
    
    
    public:
        /// \brief 대입 연산자
        inline const cStringKey& operator = (const cStringKey& rhs)
        {
            if (this != &rhs)
                memcpy_s(m_Text, sizeof(m_Text), rhs.m_Text, sizeof(m_Text));
    
            return *this;
        }
    
        /// \brief 비교 연산자
        ///
        /// 이 함수는 약간 유의해야 하는데, 속도를 위해 루프를 풀어버렸기 때문이다.
        /// 클래스의 크기가 변경되면, 이 함수도 같이 변경해줘야 한다.
        inline bool operator < (const cStringKey& rhs) const
        {
            const int* buf1 = reinterpret_cast<const int*>(this);
            const int* buf2 = reinterpret_cast<const int*>(&rhs);
    
            if (*buf1 != *buf2) return *buf1 < *buf2; // 0-3
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 4-7
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 8-11
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 12-15
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 16-19
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 20-23
    
            ++buf1; ++buf2;
            if (*buf1 != *buf2) return *buf1 < *buf2; // 24-27
    
            ++buf1; ++buf2;
            return *buf1 < *buf2; // 28-31
        }
    };

    대소문자 구별없이 비교를 할 수 없다는 점이 좀 아쉽다. 어셈블리도 좀 안다면 비교 연산자를 좀 더 깔끔하게 만들 수 있을 텐데. 어쨌든 테스트해보니, 릴리즈 빌드에서 약 25~33% 정도의 성능이 향상되었다. 
    typedef std::map<std::string, std::string> OLD_MAP;
    typedef std::map<cStringKey, std::string> NEW_MAP;
    
    OLD_MAP oldMap;
    NEW_MAP newMap;
    
    for (int i=0; i<1000; ++i)
    {
        std::string key = generic::to_string(rand() % 1000, 4);
        std::string value = generic::to_string(rand() % 1000, 4);
        oldMap.insert(OLD_MAP::value_type(key, value));
        newMap.insert(NEW_MAP::value_type(key, value));
    }
    
    DWORD begin = 0, oldTime = 0, newTime = 0;
    int repetition = 200000;
    
    begin = timeGetTime();
    for (int i=0; i<repetition; ++i)
    {
        oldMap.find(generic::to_string(rand() % 1000, 4));
    }
    oldTime = timeGetTime() - begin;
    
    begin = timeGetTime();
    for (int i=0; i<repetition; ++i)
    {
        newMap.find(generic::to_string(rand() % 1000, 4));
    }
    newTime = timeGetTime() - begin;
    
    std::cout << "OLD: " << oldTime << std::endl;
    std::cout << "NEW: " << newTime << std::endl;


Posted by blueasa

댓글을 달아 주세요

#################
 컨테이너 종류
#################

표준 STL 시퀀스 컨테이너 : vector, string, deque, list
표준 STL 연관 컨테이너 : set, multiset, map, multimap

비표준 시퀀스 컨테이너 : slit, rope
비표준 연관 컨테이너 : hash_set, hash_multiset, hash_map, hash_multimap

string 대한 vector<char>

표준 연관 컨테이너 대신 사용 되는 vector

STL에 속하지 않는 표준 컨테이너 : 배열, bitset, valarray, stack, queue, priority_queue

-------------------------
 연속 메모리 컨테이너
-------------------------
삽입 삭제시 메모리가 밀려 지거나 땡겨 지는 컨테이너(무효화!!! <-- 특히 이넘을 조심 해야 함.)
vector, string, deque.

---------------------
 노드 기반 컨테이너
---------------------
삽입 삭제시 메모리 포인터만 영향을 받음. 밀리는 현상 없음.
list, slist, set, multiset, map, multimap,
hash_set, hash_multiset, hash_map, hash_multimap


#######################################
STL은 복사에서 시작 하고 복사로 끝난다.
#######################################
값을 얻거나 넣거나 할때 모두 복사로 이루어 집니다.

상속된 클래스를 사용할 경우 베이스 클래스로 형 지정 했다면,
복사라는 특징 때문에 상속된 클래스는 잘리게 됩니다.(slicing problem)

이에 대한 해결 책은 클래스 포인터를 사용 하는 것입니다.(추후 설명)


배열
T w[maxT];

사이즈 0
vector<T> vw;

max T 만큼 미리 확보
vector<T> vw;
vw.reserve(maxT);


######################################
size() == 0을 쓰지 말고 empty()를 써라
######################################

size()를 제공 하지 않는 것도 있다. 예 list


######################################
단일 요소 반복 대신 범위 함수를 쓰자
######################################

void container::assign(시작, 끝)

void container::contrainer(시작, 끝)

void container::insert(삽입위치, 삽입 시작, 끝)

iterator container::erase(시작, 끝)     - 시퀀스 컨테이너

void container::erase(시작, 끝) - 연관 컨테이너(반복자의 반환으로 성능 저하 되므로...)


#####################
C++의 어이 없는 동작
#####################

 

#include <iostream>

class T {
public:
        T() { cout << "ok" << endl;}
};

int main() {
        T t1(); // 함수 선언, nothing...

        T t2;   // t 객체 생성, out "ok"
}

같은 원리로...

ifstream dataFile("ints.dat");
list<int> data(istream_iterator<int>(dataFile), istream iterator<int>());       // 단순한 함수 선언에 불과 하다.

list<int> data((istream_iterator<int>(dataFile)), istream iterator<int>());     // 해결, 범용성 떨어짐

<해결>
ifstream dataFile("ints.dat");
istream_iterator<int> dataBegin(dataFile);
istream_iterator<int> dataEnd;
list<int> data(dataBegin, dataEnd);


############################################################################
new로 생성한 포인터 컨테이너는 컨테이너가 소멸 되기 전에 포인터를 delete하자
############################################################################


vector<Widget *> vwp;

for(int i=0; i<NUM; ++i) {
        vwp.push_back(new Widget);      // new로 생성
}

//... 사용

for(vectro<Widget *>::iterator i = vwp.begin(); i!=vwp.end(); ++i)
        delete *i;              // delete로 소멸


<문제>
1. for루프는 for_each보다 명확하지 못하다.
2. 사용 중에 vwp가 예외를 던진 다음 메모리 누수 문제는 여전히 남는다.

<1번 해결>
struct Delete Object {
        template<typename T>
        void operator()(const T*ptr) const {
                delete ptr;
        }
};

for_each(vwp.begin(), vwp.end(), DeleteObject());

<2번 해결>
www.boost.org의 스마트 포인터 라이브러리를 사용 합니다.

void doSomething()
{
        typedef boost::shared_ptr<Widget> SPW;

        vector<SPW> vwp;

        for(int i=0; i<NUM; ++i)
                vwp.push)back(SPW(new Widget));
        ...
}

doSomething()함수가 끝나더라도, 예외가 발생 해도 메모리가 새지 않습니다.


##############################
auto_ptr 은 절대로 쓰지 말아라
##############################
auto_ptr은 스마트 포인터가 아니다. 자세한것은 Effective STL 참조!!!


##################
삭제의 조심 스러움
##################

무효화된 i에 대하여 ++i를 하고 있다.


AssocContainer<int> c;  // AssocContainer는 연관 컨테이너.
...
for(AssocContainer<int>::iterator i=c.begin(); i!=c.end(); ++i) {
        if(badValue(*i)) c.erase(i);
}

<해결>
AssocContainer<int> c;
...
for(AssocContainer<int>::iterator i=c.begin(); i!=c.end(); ) {
        if(badValue(*i)) c.erase(i++);
        else ++i;
}


연속 컨테이너인 경우 i++시 전체가 무효화 됩니다.

<해결>
for(SeqContainer<int>::iterator i=c.begin(); i!=c.end();) {
        if(badValue(*i)) {
                i = c.erase(i);
        }
        else ++i;
}


######################################################
STL 쓰레드는 쓰레드에 안전하지 않다.(직접 관리 해야함)



출처 : http://blog.naver.com/jinowin/6000269089

Posted by blueasa

댓글을 달아 주세요

내가 STL에 조예가 깊어서 글을 남기는 것이 아니라, Effecitve STL 을 공부하는 사람들이 이 글을 보고, 도움이 되었으면 하는 생각과, 혹시 내가 틀린것이 있다면 지적해 주시지 않을까 란 생각으로 글을 올리는것임을 미리 밝힙니다.  - 최익필

저번 26항목에서 각 iterator 간의 변환 과정을 그림(?) 으로 보여 주었었다.

              const_iterator
         ↗                       ↖
iterator                              ↖  base()
         ↘↖base()                   ↖
              reverse_iterator    →   const_reverse_iterator


다시 정리 하자면,
1. 화살표 방향은 컴파일러에 의해서 암시적으로 바뀐다.(안그런 컴파일러도 있으니 해결방법은 26항목)
2. base() 는 함수이고, 명시적으로 사용자가 호출해야지만, 변환이 가능하다는 것이다.

여기서 잠깐,
혹시 iterator 를 casting 하면 되지 않을까? 란 생각을 했다면, 아직 iterator 가 어떻게 구현되었는지 분석하지 않은듯 보이는데, iterator는 .. class객체이며, 각 iterator 마다 각기 다른 class 이다. 그렇기 때문에 cating 을 해도 정상 작동하지 않는다.

본론으로 들어와서.. const_iterator ---> iterator 방향으로 변환이 되지 않는데, 어떻게 저자는 바꿀수 있다고 할수 있는가?
그 꽁수가 distance 함수와 advance 함수를 사용하는것이다. 아래 코드도 포함한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
// ikpil.com or ikpil.tistory.com
// MSVC2005 distance 내부
template<class _InIt> inline
    typename iterator_traits<_InIt>::difference_type
    __CLRCALL_OR_CDECL distance(_InIt _First, _InIt _Last)
{   // return distance between iterators
    // typename 잘 썻고~ Off 선언하고~
    typename iterator_traits<_InIt>::difference_type _Off = 0;
    // 두 인자 사이의 거리를 Off에 기록 하고
    _Distance2(_First, _Last, _Off, _Iter_cat(_First));
    // Off 리턴~
    return (_Off); 
}

즉 두 같은 타입의 두 iterator를 받아 드리어, 그 사이를 리턴해 준다.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// ikpil.com or ikpil.tistory.com
// MSVC2005 advance 내부
template<class _InIt,
class _Diff> inline
    void __CLRCALL_OR_CDECL advance(_InIt& _Where, _Diff _Off)
{   // increment iterator by offset, arbitrary iterators
    // 레퍼런스로 받은 Where 을 다시 _Advace에 넣는다.
    _Advance(_Where, _Off, _Iter_cat(_Where));
}
// MSVC2005 _Advance 내부
template<class _InIt,
class _Diff> inline
    void __CLRCALL_OR_CDECL _Advance(_InIt& _Where, _Diff _Off, input_iterator_tag)
{   // increment iterator by offset, input iterators
 
#if _HAS_ITERATOR_DEBUGGING
    //  if (_Off < 0)
    //      _DEBUG_ERROR("negative offset in advance");
#endif /* _HAS_ITERATOR_DEBUGGING */
 
    for (; 0 < _Off; --_Off)
        // &로 받은 .. Where을 전위연산하여 Off 만큼 증가 시킨다.
        ++_Where;
}

std::advace()의 인자값으러 넣은 iterator를 Off 길이 만큼 이동 시켜 준다.


자.. 두 함수의 설명은 끝났고. 이제 이 두 함수를 이용하여, const_iterator 를 iterator 로 변환해 보자. 주의해야 할것은 std::distance 는 한가지 타입의 iterator만 받는 템플릿 함수이므로 그냥 호출하면 const_iterator 를 iterator 로 변환을 시도하여, 컴파일타임 에러를 발생시킬 것이다.


그래서 명시적으로 const_iterator 라고 알려 주기만 하면 된다. 그래서 아래의 코드처럼 하면 iterator 로 변환 완료!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// ikpil.com or ikpil.tistory.com
 
#include <deque>
#include <algorithm>
#include <iostream>
 
typedef std::deque<int> Container;
 
int main( void )
{
    Container Test;
     
    Test.push_back(1);
    Test.push_back(1);
    Test.push_back(1);
    Test.push_back(1);
 
    typedef Container::const_iterator Const_It;
    Const_It cit = Test.end(); // 끝을 가리키게 한다.
 
    typedef Container::iterator Nomal_It;
    Nomal_It it = Test.begin(); // 꼭 초기화를 해줘야 한다.
     
     
    // distance 는 템플릿 함수이므로 명시적으로 지정 가능하다.
    std::advance(it, std::distance<Const_It>(it, cit));
 
    if( cit == it )    // <-- 왜 cit 을 먼저 썻는지 알 것이다.
        std::cout << "같습니다." << std::endl;
    else
        std::cout << "다릅니다.." << std::endl;
}


그런데 눈치 빠른 분들은 이런 생각을 하게 될 것이다. "이거 쓸때 없는 비용 많이 무는거 같은데..? 거리가 멀면 멀어질수록 더 느려지잖아?" .. 맞다. 역시 당신은 똑똑했다.  그래서 const_iterator 보다 iterator 를 사용하라고 26장에서 설명했던 것이다.


이것 만은 잊지 말자.
1. const_iterator 를 iterator 로 바꿀수 있다!
2. 대신 좀 시간이 걸린다. 속편히 iterator 를 사용하는것을 염두하자.


관련링크
http://lagoons.net/tt/594 <-- 깔끔한 설명
http://alones.kr/blog/626?TSSESSIONaloneskrblog=1e73a3a9327170d3301688495e6aeb41 <-- 다른 경우


Posted by blueasa

댓글을 달아 주세요


출처: http://mech12.springnote.com/pages/690403

 

튜토리얼

http://www.boost.org/doc/libs/1_35_0/libs/libraries.htm

 

빌드

부스트 빌드법  http://azyu.i-i.st/moniwiki/wiki.php/Boost/GettingStarted

부스트 최신 빌드법 : http://dblab.co.kr/entry/boost-%EC%84%A4%EC%B9%98

 

인스톨버젼

http://www.boost-consulting.com/products/free

 

 관련 한글 URL

http://www.redwiki.net/wiki/wiki.php/boost

 http://jacking75.cafe24.com/Boost/libraries.htm

 

 Serialization 사용

http://www.pie.pe.kr/cgi-bin/moin.cgi/boost/serialization

http://www.boost.org/libs/serialization/doc/index.html

 

부스트 자료링크.

http://reiot.springnote.com/pages/125236

 

 

부스트 가변인자

http://www.boost.org/libs/assign/doc/index.html

 

Lambda

http://jacking75.cafe24.com/Boost/lambda/index.htm#introduction

 

 

 

 boost스터디  ( 부스트 입문자를 위한 소개 글입니다. )

1_부스트-개론.ppt

2_부스트-2_스트링.ppt

3_부스트-4_함수.ppt

4_부스트-5_spirit.ppt

5_부스트-10시스템.ppt

Posted by blueasa

댓글을 달아 주세요

////////////////////////////////////////////////////////////////////////////////////
// ysoftman
// int -> string, string -> int 로 변환하기
////////////////////////////////////////////////////////////////////////////////////
#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string>
#include <sstream>


int main()
{
 int num = 0;
 
 // Numeric Type (int, float, double)을 string으로 변환해주기 위한 객체
 std::ostringstream ostr;

 for (num=1; num<=10; num++)
 {
  // 초기화
  ostr.str("");
  // int를 string으로 변환
  ostr << num;
  printf("[int -> string] ostr = %s\n", ostr.str().c_str());
 }

 

 std::string str = "12345";
 num = atoi(str.c_str());
 printf("[string -> int] num = %d\n", num);

 

 return 0;
}


Posted by blueasa
TAG STL

댓글을 달아 주세요

  1. 2012.01.23 01:41 comment maigrir  댓글주소  수정/삭제  댓글쓰기

    웹사이트 .처럼 우리는 이것이 정말 내 중 하나입니다 사실은 정말로 재미 에 읽기 .

 

'Programming > STL' 카테고리의 다른 글

부스트(boost) 관련 스프링노트  (0) 2010.06.11
C++ STL int -> string, string -> int 로 변환하기  (1) 2010.04.27
괜찮은 참고 사이트  (0) 2010.04.20
effective_stl-hermet  (0) 2010.04.08
STL  (0) 2010.03.22
STL Container 조합하기  (0) 2010.03.21
Posted by blueasa
TAG STL강좌

댓글을 달아 주세요


'Programming > STL' 카테고리의 다른 글

C++ STL int -> string, string -> int 로 변환하기  (1) 2010.04.27
괜찮은 참고 사이트  (0) 2010.04.20
effective_stl-hermet  (0) 2010.04.08
STL  (0) 2010.03.22
STL Container 조합하기  (0) 2010.03.21
About STL : C++ STL 프로그래밍  (0) 2010.03.21
Posted by blueasa

댓글을 달아 주세요