Реализовать критическую секцию на основе объекта синхронизации типа "событие"

#include <cstdlib>
#include <iostream>
#include <windows.h>
 
using namespace std;
/////////////////////////////////////////////////////////////////////////////
struct TCriticalSection
{
    DWORD Thread; //ID владеющего потока
    HANDLE HEvent; // событие, на котором основана КС
    LONG Count; // сколько раз поток вошёл
};
void Create(TCriticalSection CS) // ПРОЦЕДУРА, СОЗДАЮЩАЯ КРИТИЧЕСКУЮ СЕКЦИЮ
{
    if(CS.HEvent!=INVALID_HANDLE_VALUE)
    {
        CS.Thread=0;
        CS.Count=0;
        CS.HEvent=CreateEvent(NULL,false,true,NULL); //создание события
    }
    else 
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
 
void Enter(TCriticalSection CS) // ПРОЦЕДУРА ВХОДА В КРИТИЧЕСКУЮ СЕКЦИЮ
{
    if(WaitForSingleObject(CS.HEvent,INFINITE)!=WAIT_FAILED) // ожидание события и установка в несигнальное состояние
    {
        CS.Count++;
        CS.Thread = GetCurrentThreadId();
    }
    else
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
void Leave(TCriticalSection CS) // ПРОЦЕДУРА ПОКИДАНИЯ КРИТИЧЕСКОЙ СЕКЦИИ
{
    if(CS.Count>1) // уменьшение кол-ва вхождений потока
            CS.Count--; 
    else
    {
        if(SetEvent(CS.HEvent)!=false) // установка события в сигнальное состояние
        {
            CS.Thread=0;
            CS.Count=0; // уменьшение числа вошедших потоков на 1
        }
        else
        {
            HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
            DWORD dwError = GetLastError();
            cout<< (PCTSTR)dwError<< endl;
        }
    }
    
}
 
void Kill(TCriticalSection CS) // ЗАКРЫТИЕ КРИТИЧЕСКОЙ СЕКЦИИ
{
    CloseHandle(CS.HEvent); // закрытие дескриптора события
}
 
//////////////////////////////////////////////////////////////////////////////
 
const int ArSize=300;
unsigned short q[ArSize];
unsigned short index;
 
void Init(){index=1;}
 
void Push(unsigned short m)
{
    if(index<=ArSize)
        q[index]=m;
        index++;
}
 
unsigned short Pop()
{
  if (index>1)
    index--;
    return(q[index]);
}
 
unsigned short Peek(){return(q[1]);}
 
bool Empty(){return(index==1) ;}
 
unsigned short Size(){return(ArSize);}
 
void Kill(){index=1;}
 
//////////////////////////////////////////////////////////////////////////////
CriticalSection CS; // КС
unsigned int d1,d2,d3; // ID потоков
unsigned short n=5,m;
HANDLE h[3]; // дескрипторы потоков
 
unsigned int WINAPI proc1(PVOID pvParam) // ПРОЦЕДУРА ДОБАВЛЯЮЩЕГО ПОТОКА
{
    int i,th;
    if(d1 == GetCurrentThreadId()) th=1;
    else th=2;
    if(CS.HEvent!=INVALID_HANDLE_VALUE)
    {
        Enter(CS); // вход в КС
        for(i=0;i<n;i++) // помещение n чисел в очередь
        {
            m=rand()%1000+1; // случайное сгенерированное число, значение до 1000
            Push(m); // вставка числа в очередь
            if(th==1)
                printf("\n%i-st thread has put element #%i - %d\n",th,i,m);
            else
                printf("\n%i-nd thread has put element #%i - %d\n",th,i,m);
            fflush(stdout); // принудительный спуск буфера вывода
            _sleep(100); // ожидание = 100 мс
        }
        Leave(CS); // выход из КС
        return 0; // результат функии proc1
    }
    else
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
unsigned int WINAPI proc2(PVOID pvParam) // ПРОЦЕДУРА ВЫНИМАЮЩЕГО ПОТОКА
{
    unsigned short x;
    int i=1;
    _sleep(0);
    if(CS.HEvent!=INVALID_HANDLE_VALUE)
    {
        Enter(CS); // вход в КС
        while(i<=2*n) // до тех пор, пока не извлечено n чисел
        {
            if(!Empty()) // проверка очереди на пустоту
            {
                x=Pop(); // извлечение числа
                printf("\n3-rd thread has put element #%i - %d\n",i,x);
                fflush(stdout);
                _sleep(10);
                i++;
            }
        }
        Leave(CS); // покидание КС
        return 0;
    }
    else 
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
unsigned int WINAPI proc3(PVOID pvParam) // ПРОЦЕДУРА ДОБАВЛЯЮЩЕГО ПОТОКА
{
    int i,th;
    if(d1 == GetCurrentThreadId()) th=1;
    else th=2;
    if(CS.HEvent!=INVALID_HANDLE_VALUE)
    {
        for(i=0;i<n;i++) // помещение n чисел в очередь
        {
            m=rand()%1000+1; // случайное сгенерированное число, значение до 1000
            Push(m); // вставка числа в очередь
            if(th==1)
                printf("\n%i-st thread has put element #%i - %d\n",th,i,m);
            else
                printf("\n%i-nd thread has put element #%i - %d\n",th,i,m);
            fflush(stdout); // принудительный спуск буфера вывода
        }
        return 0; // результат функии proc1
    }
    else
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
unsigned int WINAPI proc4(PVOID pvParam) // ПРОЦЕДУРА ВЫНИМАЮЩЕГО ПОТОКА
{
    unsigned short x;
    int i=1;
 
    if(CS.HEvent!=INVALID_HANDLE_VALUE)
    {
        while(i<=2*n) // до тех пор, пока не извлечено n чисел
        {
            if(!Empty()) // проверка очереди на пустоту
            {
                x=Pop(); // извлечение числа
                printf("\n3-rd thread has put element #%i - %d\n",i,x);
                fflush(stdout);
                i++;
            }
        }
        return 0;
    }
    else 
    {
        HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
        DWORD dwError = GetLastError();
        cout<< (PCTSTR)dwError<< endl;
    }
}
 
 
 
void Thread1()
{
    Create(CS);
    Init();// инициализация очереди
        h[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc1,NULL,0,(LPDWORD)&d1);
        h[1] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc2,NULL,0,(LPDWORD)&d2);
        h[2] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc3,NULL,0,(LPDWORD)&d3);
    if((h[0] == INVALID_HANDLE_VALUE)&&(h[1] == INVALID_HANDLE_VALUE)&&(h[2] == INVALID_HANDLE_VALUE))
        {
            HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
            DWORD dwError = GetLastError();
            cout<< (PCTSTR)dwError<< endl;
        }
    else
    {
        WaitForMultipleObjects(3,h,true,INFINITE);// ожидание завершения всех потоков
        CloseHandle(h[0]);// закрытие дескриптора 1-ого потока
        CloseHandle(h[1]);// 2-ого потока
        CloseHandle(h[2]);// 3-его потока
        Kill(CS);
        Kill();//закрытие КС
    }
}
void Thread2()
{
    Init();// инициализация очереди
        h[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc3,NULL,0,(LPDWORD)&d1);
        h[1] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc3,NULL,0,(LPDWORD)&d2);
        h[2] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)proc4,NULL,0,(LPDWORD)&d3);
    if((h[0] == INVALID_HANDLE_VALUE)&&(h[1] == INVALID_HANDLE_VALUE)&&(h[2] == INVALID_HANDLE_VALUE))
        {
            HLOCAL hlocal = NULL; // буфер для строки с описанием ошибки
            DWORD dwError = GetLastError();
            cout<< (PCTSTR)dwError<< endl;
        }
    else
    {
        WaitForMultipleObjects(3,h,true,INFINITE);// ожидание завершения всех потоков
        CloseHandle(h[0]);// закрытие дескриптора 1-ого потока
        CloseHandle(h[1]);// 2-ого потока
        CloseHandle(h[2]);// 3-его потока
        Kill(CS);
        Kill();//закрытие КС
    }
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    AllocConsole();
    int fl = 1;
    char act;
    while(fl)
    {   
        //system("cls");
        cout << endl << "1. with CS";
        cout << endl << "2. without CS";
        cout << endl << "0. Exit" << endl;
        cin >> act;
        switch(act)
        {
            case '1':Thread1();break;
            case '2':Thread2();break;
            case '0':fl = 0; break;
        }
    }
    system("pause");
    FreeConsole();
}