#include <map>
#include <string>

map<string, string> mydata;
mydata["mon"] = "월요일";
mydata["thu"] = "화요일";
cout << mydata["mon"] << endl;
				

struct ltstr
{
    bool operator(){const char *s1, const char *s2) const
    {
        return strcmp(s1, s2) < 0;
    }
};

int main()
{
    map<char *, char *, ltstr> mydata;
    mydata["mon"] = "월요일";
    mydata["thu"] = "화요일";
}
				

#include <map>
struct ltstr
{
   bool operator()(const char* s1, const char* s2) const
   {
      return strcmp(s1, s2) < 0;
   }
};

int main()
{
    multimap<const char*, int, ltstr> m;

    m.insert(pair<const char* const, int>("a", 1));
    m.insert(pair<const char* const, int>("a", 2));
    m.insert(pair<const char* const, int>("b", 3));
    m.insert(pair<const char* const, int>("c", 4));
    m.insert(pair<const char* const, int>("a", 5));
}
				

size_type count(const key_type &k);
				

iterator lower_bound(const key_type& k);
const_iterator lower_bound(const key_type& k) const;
iterator upper_bound(const key_type& k);  
const_iterator upper_bound(const key_type& k) const;
				

multimap<const char*, int, ltstr>::iterator start;
multimap<const char*, int, ltstr>::iterator end;

start = m.lower_bound("a");
end = m.upper_bound("a");

while(start != end)
{
    cout << start->first << ";" << start->second << endl;
    *start++;
}
				

multimap<const char*, int, ltstr>::iterator start;
start = m.find("a") ;
int count = m.count("a");
for (int i = 0; i < count; i++)
{
    cout << start->first << ":"<< start->second << endl;
    *start++;
}
				

#include <set>
#include <algorithm>
#include <vector>

struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

int main()
{
    set<char *, ltstr> mydata;
    set<char *, ltstr> mydata2;
    set<char *, ltstr> mydata3;

    vector<char *> myunion;

    mydata.insert("a");
    mydata.insert("z");
    mydata.insert("b");
    mydata.insert("c");
    mydata.insert("f");
    mydata.insert("g");
    mydata.insert("d");

    mydata2.insert("k");
    mydata2.insert("o");
    mydata2.insert("e");

    set_union(mydata.begin(), mydata.end(), mydata2.begin(), mydata2.end(),
                back_inserter(myunion), ltstr());

    for (int i = 0; i < myunion.size(); i++)
    {
        cout << myunion[i] << endl;
    }
}
				

#include <algorithm>
#include <vector>
#include <set> 
int main()
{
    const int N = 10;
    int a[N] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0};
    int b[N] = {4, 4, 2, 4, 2, 4, 0, 1, 5, 5};

    multiset<int> A(a, a+N);
    multiset<int> B(b, b+N);
    vector<int> C;

    set_union(A.begin(), A.end(), B.begin(), B.end(), back_inserter(C));

    for (int i = 0; i < C.size(); i++)
        cout << C[i] << endl;

    C.clear();
    set_intersection(A.begin(), A.end(), B.begin(), B.end(), back_inserter(C));
    cout << "==========" <<endl;
    for (int i = 0; i < C.size(); i++)
        cout << C[i] << endl;
}
				

size_type count(const key_type& k) const
iterator lower_bound(const key_type& k) const
iterator upper_bound(const key_type& k) const
				

#include <deque>

int main()
{
	deque<int> myque;	

	myque.push_back(100);
	myque.push_back(200);
	cout << myque[0] << endl;
	myque.pop_front();
	myque.push_back(300);
	myque.push_back(400);
	cout << myque[0] << endl;
	myque.pop_front();
	cout << myque[0] << endl;

	cout << "Size " << myque.size() << endl;
}
				

#include <string>

template <typename T>
T myadd(T x, T y)
{
	return x + y; 
}


int main()
{
	cout << myadd(4, 6) << endl;
	cout << myadd(1.6, 1.8) << endl;
}
				

  
string b2="hello";
string b3=" world";
cout << myadd(b2, b3) << endl;
				

bool operator+(myadd<double, long> &x)
{
    return x.first + x.second;
}
				

#include <string>

template <typename T1, typename T2>
class cal
{
    public:
        bool operator+(cal<double, long> &x)
        {
            return x.first + x.second;
        }

        void sum(T1 x, T2 y)
        {
            cout << x + y << endl;
        }

        void dif(T1 x, T2 y)
        {
            cout << x - y << endl;
        }

};

int main()
{
    cal<int, int> data;
    data.sum(1, 2);
    data.sum('a', 'b');

    cal<double, long> data2;
    data2.sum(1.2, 2);

    cal<double, double> data3;
    data3.dif(1.2, 1.5);
}
				

    +- data1    +- data3                      +- data8  
    |           |                             | 
 +-----+-----+-----+-----+-----+-----+-----+-----+
 |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |
 +-----+-----+-----+-----+-----+-----+-----+-----+
    |     | 
    |     +- data2
    +- data9
				

#include <string>
#include <pthread.h>

template <typename T>
class array
{
    private:
        // 저장소의 배열크기는 10으로 고정시킨다.  
        T container[10];
        int member_num, index_num;

        pthread_mutex_t mutex;
        pthread_cond_t  thread_cond;
    public:

        // 생성자
        // mutex 잠금과, 조건변수의 사용을 위한 초기화를 한다.
        array()
        {
            member_num = 0;
            index_num = -1;
            pthread_mutex_init(&mutex, NULL);
            pthread_cond_init(&thread_cond, NULL);
        }

        // 저장소 container 에 데이타를 
        // 입력하기 위한 함수 
        // 만약 10번째 배열까지 다 썼다면 
        // 다시 0번째 배열부터 쓰기 시작한다. 
        void push_back(T x)
        {
            pthread_mutex_lock(&mutex);
            cout << "push --> " << member_num%10 << endl;
            container[member_num%10] = x;
            member_num ++;
            pthread_cond_signal(&thread_cond);
            pthread_mutex_unlock(&mutex);
        }

        // 저장소에 있는 데이타를 읽어온다. 
        // 가장최근의 데이타를 가져오기 위해서 
        // 참조할 index 값을 가지는 변수 index_num 을 
        // 사용한다. 
        // pop() 를 한번 호출하면 index_num 을 1 증가 시켜서 
        // 다음헤 호출할때는 다음 데이타 값을 가져오도록 한다.  
        // 만약 저장소에 들어있는 데이타의 크기가 0이라면 
        // cond_wait 로 시그널을 기다린다. 
        T pop() 
        {
            T return_container;
            pthread_mutex_lock(&mutex);
            if (size() == 0)
            {
                pthread_cond_wait(&thread_cond, &mutex);
            }
            index_num++;
            return_container =  container[index_num%10];
            pthread_mutex_unlock(&mutex);

            return return_container;
        }

        // 저장소의 크기를 되돌려준다. 
        int size()
        {
            return member_num - (index_num + 1);
        }
};
				

#include "arr_tem.h"
#include <string>
#include <stdio.h>
#include <unistd.h>

typedef struct data
{
    int     data_num;
    string  name;
} man_info;

array<struct data> buff;

void *push(void *data)
{
    int i = 0;
    char name[12];
    man_info info;

    while(1)
    {
        i++;
        info.data_num = i;
        sprintf(name, "man_%d", i);
        info.name = name;
        buff.push_back(info);
        if (buff.size() == 10)
        {
            cout << "대기인원을 초과했습니다. 잠시 기다려주세요." << endl;
            sleep(12);   
        }
        else
        {
            sleep(random()%5);
        }
    }
}

void *pop(void *data)
{
    man_info info;
    while(1)
    {
        info = buff.pop(); 
        cout << "현재 대기 인원 : " << buff.size() << endl;
        cout << info.data_num << " : " << info.name << endl;
        sleep(3);
    }
}   
    
int main()
{
    int thr_id;
    int a, b, status;
    pthread_t p_thread[2];

    thr_id = pthread_create(&p_thread[0], NULL, push, (void *)&a);
    thr_id = pthread_create(&p_thread[1], NULL, pop, (void *)&b);

    pthread_join(p_thread[0], (void **)status);
    pthread_join(p_thread[1], (void **)status);
}
				

[root@localhost circular]# g++ -o main main.cc -lpthread