#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