크레이지J의 탐구생활

cpp stack

include <stack>

LIFO로 디자인된 자료구조. push/pop

+ member functions

empty    ; 비었는지 테스트

size    ; 스택 엘리먼트 개수

top    ; 가장 위의 엘리먼트 접근

push    ; 삽입. (가장 위에 추가)

emplace(c++11) ; construct & push

pop    ; top(가장 위) 엘리먼트를 제거

swap(c++11) ; 다른 스택과 바꿈. 

+ex)

std::stack<int> st1 ;

st1.push(1) ;

st1.push(2) ;

st1.push(3) ;

st1.size()    // => size=3

st1.top()    // => 3

st1.pop()    // => size=2

st1.top()    // => 2

st1.empty()    // => false

while(  !st1.empty() ) {    // 일반적인 스택 데이터를 전부 하나씩 추출하는 방법.

std::cout << '  ' << st1.top() ;    // 최상위 노드 접근.

st1.pop() ;    // 최상위 노드 삭제.

}

+ swap ex)

std::stack<int> foo, bar ;

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

bar.push(11) ; bar.push(22) ;

foo.swap(bar) ;     // foo와 bar가 바뀜.

foo.size() ;    // 2

bar.size() ;    // 3

++ queue

FIFO 방식의 자료구조

include <queue>

+members

empty

size

front    ; 가장 앞 노드의 값

back    ; 가장 뒤 노드의 값

push ; 노드를 가장 뒤에 추가

emplace (c++11)

pop ; 가장 앞의 노드를 제거

swap (c++11)

ex)

std::queue<int> q1 ;

q1.push(1) ;

q1.push(2) ;

q1.push(3) ;

while( !q1.empty() ) {

std::cout << ' ' << q1.front() ;     // 가장 앞 노드값 출력

q1.pop()    ;    // 가장 앞 노드 제거.

}

cpp cstring

c string and array

include <cstring>

+함수들

void * memcpy (void *dest, const void *src, size_t num) ; dest return.

void * memmove(void *dest, const void *src, size_t num)  ; memcpy와 유사하나 차이점은 dest와 src가 overlap이 되어도 된다. 따라서 성능상은 memcpy가 더 좋음. 그러나 overlap이 필요하면 memmove를 사용한다. 

char* strcpy(char *dest, const char *src) ; dest return. null 문자까지 복사.

char* strncpy(char *dest, const char *src, size_t num) ; num크기까지 복사한다. num전에 null문자가 있으면 null전까지 복사하고 나머지는 null로 패딩한다.  

char* strcat (char *dest, const char *src) ; src문자를 dest뒤에 붙인다. dest return.

char* strncat (char *dest, const char *src, size_t num) ; src의 num 크기만큼만 dest 뒤에 붙인다. 마지막에 null문자 추가. 

int memcmp (const void *ptr1, const void *ptr2, size_t num) ; 두 메모리 블록을 비교한다. strcmp와 다르게 null문자가 있어도 중간에 멈추지 않고 지정된 크기만큼  비교한다.  return ;  ptr1<ptr2 이면 <0,  ptr1>ptr2이면 >0 , ptr1=ptr2 이면 0.

int strcmp (const char *str1, const char *str2) ; 두 스트링을 비교한다. return ; <0, >0, 0

int strncmp(", ", size_t num) 

등

char * strchr( char *str, int ch) ; 스트링에서 지정한 문자를 찾아 위치를 리턴. 

char* strrchr (char *str, int ch) ; 스트링에서 지정한 문자를 뒤에서 부터 찾아 위치를 리턴.

char* strstr (char *str1, const char *str2) ; str1 스트링에서 str2 스트링을 찾아 위치를 리턴.

char* strtok (char *str, const char *delimeters) ; 스트링을 토크닝함. 딜리미터로 지정된 문자열 가운데 아무 문자나 맞으면 자른다. 다음 토큰 검색시에는 str을 NULL로 준다. 주의! thread-unsafe! . thread에서는 strtok_r() 사용.

void* memset (void *ptr, int val, size_num) ; 메모리 블록을 특정 값으로 초기화. ptr is returned.

size_t strlen(const char *str) ; 스트링 길이를 리턴.

+잘 안쓰는 함수

void * memchr(void *ptr, int val, size_num) ; 메모리 블록에서 지정된 값을 찾는다. return ; 처음 val이 발견된 주소. 없으면 null

size_t strcspn (const char *str1, const char *str2) ; str1에서 str2의 임의의 문자가 가장 먼저 나오는 곳 이전까지의 길이.  str2를 any delimeter로 보고 첫 번째 토큰의 길이.

char * strpbrk (char *str1, const char *str2) ; str2를 any delimeter로 보고 처음 나오는 delimeter의 위치 포인터 리턴.

char* strerror(int errnum) ; 에러코드를 에러스트링으로 변환.

cpp mutex

include <mutex>

+ mutex 사용하기

std::mutex mtx ;

void func(int id, int &v) {

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

     mtx.lock() ;

    ++v ;

    mtx.unlock() ;

   }

}

int v=0 ;

std::thread t1 (func, 0, std::ref(v) ) ;

std:;thread t2(func, 1, std::ref(v) ) ;

t1.join();

t2.join() ;

-lock() ; 다른 쓰레드에 의해 lock되어 있지 않는 경우, 현재 쓰레드에서 락을 건다. unlock을 할 때까지 현재 쓰레드가 뮤텍스를 소유함. 

이미 다른쓰레드가 뮤텍스를 소유하고 있으면, 해제될때까지 블로킹 된다.

- lock을 얻은 상태에서 또 lock()을 하면 안된다. 데드락 발생.  (중복 lock을 하려면 recursive_mutex 사용)

+ bool try_lock() ; lock을 얻지 못하면 바로 리턴한다. 블로킹되지 않는 것이 lock()과 차이. 

뮤텍스를 얻었으면 true를 리턴하고, 작업 완료시 unlock()을 해주어야 한다.

다른 쓰레드가 뮤텍스 소유하고 있으면 false를 바로 리턴한다.

+ recursive_mutex  ; mutex와 비슷하나, lock 등급이 가능.

락을 얻은 상태에서 또 락을 얻을 수 있다. 뮤텍스 소유 레벨을 올림.

나중에 unlock()을 lock() 횟수만큼 해줘야 한다.

==> Mutex를 직접사용하지 말고 아래(lock_guard, unique_lock) 를 사용하기를 권장함.

+ lock_guard  ; 함수 내부에서 사용하여 간단하게 동기화 처리.

내부적으로 mutex를 사용하여 항상 락이 되도록 유지.

constructor에서 락을 얻고, destructor에서 언락을 한다.

std::mutex mtx ;

void func(int id) {

try {

   std::lock_guard<std::mutex> lck(mtx) ;

} catch ( std::logic_error & ) {

}

}

+unique_lock ; 뮤텍스를 사용하여 동기화 처리. lock_guard와 비슷하나 구동 시점을 지정할 수 있다.

lock, unlock을 사용 가능하며, 굳이 사용 안 해도 lock_guard 처럼 작동한다.

함수 일부분내에서 동기화 해제해도 되는 구간이 있을 경우에 사용하면 될 것 같다.

생성시점에 락을 안 걸 수도 있다.

guard(mutex, std::defer_lock) ; 이렇게 초기화하면 락을 얻지 않는다.