x17lab: решил заняться исследованием алгоритмов и структур данных

///
/// MindBlow.hpp
///
 
#ifndef MINDBLOW_GUARD
#define MINDBLOW_GUARD
 
#include <initializer_list>
#include <iostream>
#include <sstream>
 
 
template<typename MindBlowStreamType>
class MindBlow
{
public:
 
    /// <summary>
    /// Shortcut for a data type.
    /// </summary>
    using x17labMindStreamerT         = MindBlowStreamType;
 
    /// <summary>
    /// Shortcut for a pointer.
    /// </summary>
    using x17labMindStreamerPtrT      = x17labMindStreamerT*;
 
    /// <summary>
    /// Shortcut for a size.
    /// </summary>
    using x17labMindStreamerSizeTT   = size_t;
 
    /// <summary>
    /// Other definitions.
    /// </summary>
    #define x17labInline             inline
    #define x17labNoThrow            noexcept
    #define x17labThrow              throw
    #define x17labNullptr            nullptr
 
    /// <summary>
    /// Dynamically allocated (raw) array.
    /// </summary>
    x17labMindStreamerPtrT          x17labMindStreamerRAWRWX;
 
    /// <summary>
    /// Count of items (track counter).
    /// </summary>
    x17labMindStreamerSizeTT        x17labMindStreamerSynchro;
 
    /// <summary>
    /// Newly dynamically allocated array class with 1 single item, and it's default value is 1.
    /// </summary>
    explicit
    x17labInline
    MindBlow()
    {
        x17labDekTheRaw(1u);
    }
 
    /// <summary>`
    /// Newly dynamically allocated array class with given amount of items.
    /// </summary>
    /// <param name="Synchro">Count of items to initialize items.</param>
    explicit
    x17labInline
    MindBlow(x17labMindStreamerSizeTT Synchro)
    {
        x17labDekTheRaw(Synchro);
    }
 
    /// <summary>
    /// Newly dynamically allocated array class with initializer list in it.
    /// </summary>
    /// <param name="SuperNovaIL">Initializer list.</param> 
    explicit
    x17labInline
    MindBlow(std::initializer_list<x17labMindStreamerT> SuperNovaIL)
    {
        x17labDekTheRaw(SuperNovaIL.size());
 
        if ((SuperNovaIL.size()) <= (0u))
        {
            x17labThrow (std::invalid_argument("MindBlow:: invalid argument has been passed."));
        }
 
        decltype(x17labMindStreamerSynchro) ILIterator {0u};
        for (x17labMindStreamerT Picker : SuperNovaIL)
        {
            x17labMindStreamerRAWRWX[ILIterator++] = Picker;
        }
    }
 
    /// <summary>
    /// Destructor (deallocate and free memory used by this dynamically allocated array class).
    /// </summary>
    x17labInline
    ~MindBlow()
    {
        x17labEjector();
        x17labNullify();
    }
 
    /// <summary>
    /// Get the amount of items in this dynamically allocated array class.
    /// </summary>
    /// <returns>Amount of items.</returns>
    x17labInline
    x17labMindStreamerSizeTT x17labMindStreamerSynchrohronizer()
    {
        if ((x17labNull()) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labMindStreamerSynchrohronizer:: x17lab is fully zeroed."));
        }
 
        return (x17labMindStreamerSynchro);
 
    }
 
    /// <summary>
    /// Check dynamically allocated array is out of bounds (internal check).
    /// </summary>
    /// <param name="Synchro">Index to check.</param> 
    /// <returns>True if its in range.</returns>
    x17labInline
    bool x17labOverflow(x17labMindStreamerSizeTT Synchro)
    {
        if ((Synchro) >= (x17labMindStreamerSynchro))
        {
            x17labThrow (std::invalid_argument("x17labOverflow:: overflow has been detected."));
        }
        
        return (true);
    }
 
    /// <summary>
    /// Create dynamically allocated aray class with given amount of items,  provided in argument.
    /// </summary>
    /// <param name="x17labSynchro">Tracker of items.</param> 
    x17labInline
    void x17labDekTheRaw(x17labMindStreamerSizeTT Synchro) x17labNoThrow
    {
        x17labMindStreamerRAWRWX  = new (x17labMindStreamerT[Synchro])();
        x17labMindStreamerSynchro =  {Synchro};
    }
 
    /// <summary>
    /// Check if there are items in this dynamically allocated array class.
    /// </summary>
    /// <returns>True in case allocated array class has items.</returns>
    x17labInline
    bool x17labNull() x17labNoThrow
    {
        if ((x17labMindStreamerSynchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labNull:: Synchro has been nulled."));
        }
 
        return (true);
    }
 
    /// <summary>
    /// Check if there is an initialiizer list in this dynamically allocated array class.
    /// </summary>
    /// <param name="SuperNovaIL">Initializer list to perform the needed checks.</param> 
    /// <returns>True in case has an initializer list.</returns>
    x17labInline
    bool x17labSuperNovaILOverflow(std::initializer_list<x17labMindStreamerT> SuperNovaIL)
    {
        if ((SuperNovaIL.size()) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labSuperNovaILOverflow:: argument is out of range."));
        }      
 
        return (true);
    }
 
    /// <summary>
    /// Check if proveded dynamically allocated array and it's index is valid.
    /// </summary>
    /// <param name="MindStreamRaw">Dynamically allcated (raw) array to check.</param> 
    /// <param name="Synchro">Index to perform the needed checks.</param> 
    /// <returns>True in case array within the range.</returns>
    x17labInline
    bool x17labFlow(x17labMindStreamerPtrT MindStreamRaw, x17labMindStreamerSizeTT Synchro)
    {
        if ((MindStreamRaw) == (x17labNullptr) || (Synchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labFlow:: error has been detected."));
        }
 
        return (false);
    }
 
    /// <summary>
    /// Check if dynamically allocated array class has items in it.
    /// </summary> 
    /// <returns>True in case has items.</returns>
    x17labInline
    bool x17labIsAvailable() x17labNoThrow
    {
        if ((x17labMindStreamerSynchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labIsAvailable:: array has not items in it."));
        }
 
        return (true);
    }
 
    /// <summary>
    /// Assign item for this dynamically allocated array class to a provided one.
    /// </summary>
    /// <param name="StreamerValue">Value to set.</param>
    /// <param name="Synchro">Index to set.</param> 
    x17labInline
    void x17labYield(x17labMindStreamerT StreamerValue, x17labMindStreamerSizeTT Synchro)
    {
        if (x17labOverflow(Synchro))
        {
            x17labThrow (std::invalid_argument("x17labYield:: invalid argument."));
        }
 
        x17labMindStreamerRAWRWX[Synchro] = {StreamerValue};
    }
 
    /// <summary>
    /// Assign this dynamocally allocated array class to another array (raw).
    /// </summary>
    /// <param name="MindStreamerPtr">Raw array."</param>
    x17labInline
    void x17labYield(x17labMindStreamerPtrT MindStreamerPtr)
    {   
        if (x17labMindStreamerRAWRWX    == (x17labNullptr) ||
            MindStreamerPtr             == (x17labNullptr))
        {
            x17labThrow(std::invalid_argument("x17labYield:: invalid array."));
        }
 
        x17labMindStreamerRAWRWX = MindStreamerPtr;
    }
 
    // <summary>
    // Change the size of this dynamically allocated array class (raw array).
    // Allocate new buffer, and assign the new buffer to a raw array. 
    // </summary>
    // <param name="New">New size."</param>
    x17labInline
    void x17labShrinkify(x17labMindStreamerSizeTT New) x17labNoThrow
    {
        x17labMindStreamerPtrT MindStreamPtrNew = new x17labMindStreamerT[New]();
        if (MindStreamPtrNew != (x17labNullptr))
        {
            std::memcpy((MindStreamPtrNew), x17labMindStreamerRAWRWX, (x17labMindStreamerSynchro * sizeof(x17labMindStreamerT)));
            if (MindStreamPtrNew != (x17labNullptr))
            {
                x17labMindStreamerSynchro = New;
            }
        }
 
        x17labYield(MindStreamPtrNew);
 
        x17labEjector(MindStreamPtrNew);
        x17labNullify(MindStreamPtrNew);
    }
 
    /// <summary>
    /// Finds the summaty of all items in this dynamically allocated array class.
    /// </summary> 
    /// <returns>Summary of elements.</returns>
    x17labInline
    x17labMindStreamerSizeTT x17labSeekSummary() x17labNoThrow
    {
        x17labMindStreamerSizeTT Summary = {0u};
        for (x17labMindStreamerT (Picker) : x17labMindStreamerRAWRWX)
        {
            (Summary += (Picker));
        }
 
        return (Summary);
    }
 
    /// <summary>
    /// Check if this dynamically allocated array class is valid.
    /// </summary>
    /// <returns>True in case array is valid.</returns>
    x17labInline
    bool x17labIntegrity() x17labNoThrow
    {
        if (x17labMindStreamerRAWRWX != x17labNullptr)
        {
            x17labThrow(std::invalid_argument("x17labIntegrity:: invalid intergity."));
        }
 
        return (false);
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator (internal).
    /// </summary>
    x17labInline
    void x17labEjector() x17labNoThrow
    {
        if (x17labMindStreamerRAWRWX != (x17labNullptr))
        {
            delete [] x17labMindStreamerRAWRWX;
        }
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator.
    /// </summary>
    x17labInline
    void x17labEjector(x17labMindStreamerPtrT MindStreamerPtr) x17labNoThrow
    {
        if (MindStreamerPtr != (x17labNullptr))
        {
            delete [] MindStreamerPtr;
        }
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array class (internal). 
    /// </summary>
    x17labInline
    void x17labNullify() x17labNoThrow
    {
        x17labMindStreamerRAWRWX = (x17labNullptr);
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array class. 
    /// </summary>
    /// <param name="MindStreamerPtr">Raw."</param>
    x17labInline
    void x17labNullify(x17labMindStreamerPtrT MindStreamerPtr) x17labNoThrow
    {
        MindStreamerPtr = (x17labNullptr);
    }
 
    /// <summary>
    /// Print content by using console.
    /// </summary>
    x17labInline
    void x17labStringlyfi() x17labNoThrow
    {
        std::wstringstream WStreamStringlyfi{};
        for (decltype(x17labMindStreamerSynchro) SynchroIt{ 0u }; SynchroIt < x17labMindStreamerSynchro; SynchroIt++)
        {
            WStreamStringlyfi << "StreamerIdx: " << SynchroIt << " Value: " << x17labMindStreamerRAWRWX[SynchroIt] << " " << std::endl;
        }
 
        std::wcout << WStreamStringlyfi.str() << std::endl;
    }
};
 
#endif

std::wstring data(L""), old_data(L"BQUFBQlpNTFZ");
    //------------------------------ 
    std::ifstream fin(buf); 
    int ln_cout(0); // Посчитаем строки в файле
    if (fin.is_open()){
while (getline(fin, line))// =============== Читаем текст =============== && (int)line[n - 1] == 208
{
    bool repeat(false); ++ln_cout;
        //------------------------------
        char *cut_ptr = &line[0];
        if (*(cut_ptr + 4) == '-' && *(cut_ptr + 35) == '.' && *(cut_ptr + 40) == '0' && *(cut_ptr + 43) == ' ')
        {//Определяем строчку с датой с начала строки
            data = L"";
            std::wstring wsTmp(line.begin(), line.end());
            for (int i = 33; i < 43; ++i)data += wsTmp[i];
            data += L"  ";
            ++num;// строчка с датою - тоже строчка (подсчёт в массив)
        }
        else {

while (getline(fin, line))// =============== Читаем текст ===============
            {
            bool repeat(false); ++line_cout;
                //------------------------------
                char *cut_ptr = &line[0];
                if (*(cut_ptr + 4) == '-' && *(cut_ptr + 35) == '.' && *(cut_ptr + 40) == '0' && *(cut_ptr + 43) == ' ')
                {//Определяем строчку с датой с начала строки
                    memset(d_t, 0, 25);
                    for (int i = 33; i < 43; ++i)strncat(d_t, (const char*)cut_ptr + i, 1);
                    strncat(d_t, " ", 1);
                    ++num;// Строчки считает....
                }
                else {

//-------------------
    while (true) {  ++counter;// ================ ЦИКЛ =============
        short i;//                       ======== (ЗАТЫЧКА КОСТЫЛЬ for opencv-2.4.13)
    begin:
        if (!cap.read(frame)) //read a new frame from video if not success, goto begin 
        {           cout << "ERROR: Cannot read a frame from video file" << endl;
            if (++i < 8)goto begin;
            else break;     }

#include <opencv2/opencv.hpp>
#include "io.h"// if( access
#include <windows.h>
#include <Shlobj.h>
#include <direct.h>//  if (_mkdir
#include "resource.h"
#include <mmsystem.h>// Звук PlaySound
#pragma comment(lib, "winmm")// Звук
#include<vfw.h>
#include<mmeapi.h>
#pragma comment(lib, "Vfw32.lib")
using namespace cv;