Часы многопоточности

///----------------------------------------------------------------------------|
/// Часы.
/// Демо:
///     -  устнановка минут(только минут чисто для демо)
///     -  без остановки часов.
///----------------------------------------------------------------------------:
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <vector>
#include <ctime>
#include <conio.h>
#include <windows.h>
 
///----------------------------------------------------------------------------|
/// class Engine
///----------------------------------------------------------------------------:
class cConEngine
{
public:
    HANDLE hcon;
    cConEngine()
    {   setlocale(0, "");
        //SetConsoleCP      (1251);
        //SetConsoleOutputCP(1251);
        hcon = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTitle("CLOCK.");
    }
 
 
    void setpos(SHORT x, SHORT y)
    {   COORD xy = {x, y};
        SetConsoleCursorPosition(hcon, xy);
    }
 
    void anim_1980()
    {   static char a[] = {"+\\|/"};
        static char b[] = {"\b+"};
        static int  i   = 0;
        b[1] = a[i++];
        *this   << b;
        if(i == 4) i = 0;
    }
    
    std::mutex mx;
    template<class T>
    cConEngine& operator<< (T v)
    {   std::lock_guard lock(mx);
        std::cout << v;
        return *this;
    }
 
}engine;
 
///----------------------------------------------------------------------------|
/// Часы.
///----------------------------------------------------------------------------:
class cClock
{   int h, m, s;
public:
    cClock()
    {
        ///------------------------------------|
        /// Читаем время из системы.           |
        ///------------------------------------:
        time_t rawtime = time     (&rawtime);
        tm*   timeinfo = localtime(&rawtime);
    
        h = timeinfo->tm_hour;
        m = timeinfo->tm_min;
        s = timeinfo->tm_sec;
        
        check_good(h, m, s);
    }
    
    ///------------------------------------|
    /// Вывод вермени на экран.            |
    ///------------------------------------:
    void show()
    {   std::this_thread::sleep_for(std::chrono::milliseconds(16));
        work();
        
        engine.setpos(4, 2);
        engine << "\r" << h << ":" << m << ":" << s << "   \t";
    }
    
    ///------------------------------------|
    /// Установка времени с клавиатуры.    |
    ///------------------------------------:
    std::mutex mx2;
    void set(int _h, int _m, int _s)
    {   std::lock_guard lock(mx2);
        
        if(_h != -1 && check_good(_h, 0, 0))
        {   h = _h;
        }
        
        if(_m != -1 && check_good(0, _m, 0))
        {   m = _m;
        }
        
        if(_s != -1 && check_good(0, 0, _s))
        {   s = _s;
        }
    }
    
private:
    ///------------------------------------|
    /// Делаем тики.                       |
    ///------------------------------------:
    void work()
    {   s++;
        if(s > 59)
        {   s = 0;
            m++;
            if(m > 59)
            {   m = 0;
                h++;
                if(h > 23)
                {   h = 0;
                }
            }
        }
    }
    
    ///------------------------------------|
    /// Проверка диапазона значений.       |
    ///------------------------------------:
    bool check_good(int _h, int _m, int _s)
    {   bool b = true;
        if((0>_h)||(_h>24))
        {   engine << "ERROR:Hour not correctly!\n";    b = false;
        }
        if((0>_m)||(_m>59))
        {   engine << "ERROR:Minutes not correctly!\n"; b = false;
        } 
        if((0>_s)||(_s>59))
        {   engine << "ERROR:Seconds not correctly!\n"; b = false;
        }
        
        if(b) engine << "                              ";
        return b;
    }
}Clock;
 
///----------------------------------------------------------------------------|
/// Индикация.
///----------------------------------------------------------------------------:
void thread_clock_show(int n)
{   while(true)
    {   Clock.show();
    }
}
 
void thread_clock_control(int n)
{   ///------------------------------------|
    /// Управляющая клавиша.               |
    ///------------------------------------:
    char key = 0;
    char bufer[64];
    
    int input_pointer = 0;
    while(true)
    {   if (_kbhit()) key =  _getch();
        
        if(input_pointer)
        {   //engine.setpos(2+input_pointer, 4);
            //engine.anim_1980();
        }
        
        switch(key)
        {   case 0:
            {   break;
            }
            case 13:
            {   int m = atoi(bufer);
                Clock.set(-1, m, -1);
                input_pointer = 0;
                
                engine.setpos(2, 4);
                engine << "                                                ";
                break;
            }
            default:
            {   engine.setpos(2+input_pointer, 4);
                engine << key;
                bufer[input_pointer    ] = key;
                bufer[input_pointer + 1] = 0;
                input_pointer++;
            }
        }
        key = 0;
    }
}
 
///----------------------------------------------------------------------------|
/// Запуск.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
    
    ///------------------------------------|
    /// Жми ENTER чтобы установить время.  |
    ///------------------------------------:
    engine.setpos(0, 0); std::cout << "Установка времени без остановки часов!";
    engine.setpos(0, 4); std::cout << ">";
    
    ///-------------------------|
    /// Хранилище для потоков.  |
    ///-------------------------:
    std::vector<std::thread> threads;
                             threads.reserve(2);
    
    ///-------------------------|
    /// Создаем потоки.         |
    ///-------------------------:
    threads.emplace_back(thread_clock_show   , 1);
    threads.emplace_back(thread_clock_control, 2);
 
    ///-------------------------|
    /// Ждем погоду.            |
    ///-------------------------:
    for(auto& t: threads)
    {   t.join();
    }
    
    return 0;
}

///----------------------------------------------------------------------------|
/// Часы. (Windows)
/// Демо:
///     -  устнановка минут(только минут чисто для демо)
///     -  без остановки часов.
///----------------------------------------------------------------------------:
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <vector>
#include <ctime>
#include <conio.h>
#include <windows.h>
 
///------------|
/// ОДЫН.      |
///------------:
std::mutex mutx;
 
///----------------------------------------------------------------------------|
/// class Engine
///----------------------------------------------------------------------------:
class cConEngine
{
public:
    HANDLE hcon;
    cConEngine()
    {   setlocale(0, "");
        //SetConsoleCP      (1251);
        //SetConsoleOutputCP(1251);
        hcon = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTitle("CLOCK.");
        control_blink();
    }
 
    void setpos(SHORT x, SHORT y)
    {   COORD xy = {x, y};
        SetConsoleCursorPosition(hcon, xy);
    }
 
    void anim_1980()
    {   std::this_thread::sleep_for(std::chrono::milliseconds(50));
        static char a[] = {"+\\|/"};
        static char b[] = {"\b+"};
        static int  i   = 0;
        b[1] = a[i++];
        setcolor(14);
        std::cout << b;
        setcolor();
        if(i == 4) i = 0;
    }
    
    template<class T>
    cConEngine& operator<< (T v)
    {   std::cout << v;
        return *this;
    }
 
    void control_blink(BOOL _b = false)
    {   HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
        CONSOLE_CURSOR_INFO structCursorInfo;
        GetConsoleCursorInfo(handle, &structCursorInfo);
        structCursorInfo.bVisible = _b;
        SetConsoleCursorInfo( handle, &structCursorInfo );
    }
    
    void setcolor(WORD text = 7, WORD background = 0)
    {   SetConsoleTextAttribute(hcon, (background << 4) | text);
    }
}engine;
 
///----------------------------------------------------------------------------|
/// Часы.
///----------------------------------------------------------------------------:
class cClock
{   int h, m, s;
    COORD pos;
public:
    cClock(SHORT x, SHORT y) : pos{x, y}
    {   
        ///------------------------------------|
        /// Читаем время из системы.           |
        ///------------------------------------:
        time_t rawtime = time     (&rawtime);
        tm*   timeinfo = localtime(&rawtime);
    
        h = timeinfo->tm_hour;
        m = timeinfo->tm_min;
        s = timeinfo->tm_sec;
        
        check_good(h, m, s);
    }
    
    ///------------------------------------|
    /// Вывод вермени на экран.            |
    ///------------------------------------:
    void show()
    {   show_();
        std::this_thread::sleep_for(std::chrono::seconds(1));
        work();
    }
    void show_()
    {   
        ///-----------------------|
        /// Сторож.               |
        ///-----------------------:
        std::lock_guard lock(mutx);
        info();
    }
    
    ///------------------------------------|
    /// Установка времени с клавиатуры.    |
    ///------------------------------------:
    void set(int _h, int _m, int _s)
    {   
        if(_h != -1 && check_good(_h, 0, 0))
        {   h = _h;
        }
        
        if(_m != -1 && check_good(0, _m, 0))
        {   m = _m;
        }
        
        if(_s != -1 && check_good(0, 0, _s))
        {   s = _s;
        }
        
        if(b)
        {   info();
        }
    }
    
private:
    void info()
    {   engine.setcolor(10);
        engine.setpos(pos.X, pos.Y);
        engine << "|------------------|\n";
        
        engine.setpos(pos.X, pos.Y+1);
        engine << "|     " << h << ":" << m << ":" << s << "   ";
        engine.setpos(pos.X+19, pos.Y+1); engine << "|\n";
        
        engine.setpos(pos.X, pos.Y+2);
        engine << "|------------------|\n";
        engine.setcolor();
    }
    ///------------------------------------|
    /// Делаем тики.                       |
    ///------------------------------------:
    void work()
    {   if(++s > 59)
        {   s = 0;
            if(++m > 59)
            {   m = 0;
                if(++h > 23)
                {   h = 0;
                }
            }
        }
    }
    
    ///------------------------------------|
    /// Проверка диапазона значений.       |
    ///------------------------------------:
    bool b;
    bool check_good(int _h, int _m, int _s)
    {   b = true;
        if((0>_h)||(_h>24))
        {   engine << "ERROR:Hour not correctly!\n";    b = false;
        }
        if((0>_m)||(_m>59))
        {   engine << "ERROR:Minutes not correctly!\n"; b = false;
        } 
        if((0>_s)||(_s>59))
        {   engine << "ERROR:Seconds not correctly!\n"; b = false;
        }
        
        return b;
    }
}Clock(4, 2);
 
///----------------------------------------------------------------------------|
/// Индикация.
///----------------------------------------------------------------------------:
void thread_clock_show(int n)
{   while(true)
    {   Clock.show();
    }
}
 
void thread_clock_control(int n)
{   ///------------------------------------|
    /// Управляющая клавиша.               |
    ///------------------------------------:
    char key = 0;
    char bufer[64]; bufer[0] = 0;
    
    int input_pointer = 0;
    while(true)
    {   if (_kbhit()) key =  _getch();
        
        switch(key)
        {   case 0:
            {   break;
            }
            case 8:
            {   if(input_pointer > 0)
                {   input_pointer--;
                    bufer[input_pointer] = 0;
                }
                
                ///-----------------------|
                /// Сторож.               |
                ///-----------------------:
                std::lock_guard lock(mutx);
                
                engine.setpos(2+input_pointer, 6);
                engine << "  ";
                break;
            }
            case 13:
            {   if(bufer[0])
                {   int m = atoi(bufer);
                    input_pointer = 0;
                
                    ///-----------------------|
                    /// Сторож.               |
                    ///-----------------------:
                    std::lock_guard lock(mutx);
                
                    engine.setpos(2, 6);
                    engine << "     ";
                    Clock.set(-1, m, -1);
                }
                
                break;
            }
            default:
            {   bufer[input_pointer    ] = key;
                bufer[input_pointer + 1] = 0;
                
                ///-----------------------|
                /// Сторож.               |
                ///-----------------------:
                std::lock_guard lock(mutx);
                
                engine.setpos(2+input_pointer, 6);
                if(input_pointer == 0)
                {   engine << "                                               ";
                    engine.setpos(2 + input_pointer, 6);
                }
                input_pointer++;
                
                if(input_pointer > 2)
                {   input_pointer = 2;
                    bufer[input_pointer] = 0;
                    std::cout << "\a";
                }
                engine << key;
            }
        }
        key = 0;
        //if(input_pointer)
        {   
            ///-----------------------|
            /// Сторож.               |
            ///-----------------------:
            std::lock_guard lock(mutx);
            
            engine.setpos(3+input_pointer, 6);
            engine.anim_1980();
        }
    }
}
 
///----------------------------------------------------------------------------|
/// Запуск.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
    
    ///------------------------------------|
    /// Установка часов без их остановки.  |
    ///------------------------------------:
    engine.setpos(0, 0); std::cout << "Установка времени без остановки часов!";
    engine.setpos(0, 6); std::cout << ">";
    
    ///-------------------------|
    /// Хранилище для потоков.  |
    ///-------------------------:
    std::vector<std::thread> threads;
                             threads.reserve(2);
    
    ///-------------------------|
    /// Создаем потоки.         |
    ///-------------------------:
    threads.emplace_back(thread_clock_show   , 1);
    threads.emplace_back(thread_clock_control, 2);
 
    ///-------------------------|
    /// Ждем погоду.            |
    ///-------------------------:
    for(auto& t: threads)
    {   t.join();
    }
    
    return 0;
}