[C++/C#] Implementação do temporizador Timer

1. Introdução

        O temporizador é implementado através de várias bibliotecas de classes em C++ e C#, e o temporizador é usado para contar o tempo permitido pelo programa.No uso real, o temporizador de milissegundos é suficiente.

2. Temporizador de milissegundos

#include<ctime>
class Timer_milisecode{//
public:
    Timer_milisecode(){
        tbegin=clock();
        tend=clock();
    }

    void begin(){
        tbegin=clock();
    }
    void end(){
        tend=clock();
    }

    double spent(){
        return double(tend-tbegin)/CLOCKS_PER_SEC*1000;
    }

    double getCurrentTime(){
        return double(clock());
    }
private:    
    // const int clock_per_second=CLOCKS_PER_SEC; 
    clock_t tbegin,tend;
};

O arquivo de cabeçalho é #include<ctime>, explicação detalhada

        Existe um tipo clock_t (longo) em ctime, e uma função correspondente clock(), cujo valor de retorno é do tipo clock_t, e há uma constante CLOCKS_PER_SEC, que representa o número de ticks por segundo. Em teoria, clock() deveria ser Acerte cada milissegundo. Ao calcular o intervalo de tempo, subtraia os dois números clock_t e corrija-os para obter o número de milissegundos.

3. Temporizador de microssegundos

#include<Windows.h>
class Timer_microseconds{
public:
    Timer_microseconds(){
        QueryPerformanceFrequency(&tc);
    }
    void begin(){
        QueryPerformanceCounter(&t1);
    }
    void end(){
        QueryPerformanceCounter(&t2);
    }
    double spent(){
        return  (double(t2.QuadPart-t1.QuadPart)*1000000.0)/tc.QuadPart;
    }

private:
    LARGE_INTEGER t1,t2,tc;

};

O arquivo de cabeçalho é #include<windows.h>

        Semelhante ao acima. A primeira é definir três variáveis ​​LARGE_INTEGER. Existem duas funções QueryPerformanceFrequency(), que consulta a frequência baixa por segundo, e QueryPerformanceCounter(), que é um contador. Então aqui, teoricamente, o valor de tc.QuadPart é 10_000_000 por segundo, ou seja, 10 serão contados a cada microssegundo. Isso é mais preciso.

4. Contador de microssegundos

#include<chrono>
class Timer_chrono{
public:
    Timer_chrono(){

    }

    void begin(){
        start=std::chrono::high_resolution_clock::now();
    }
    void end(){
        spentTime=std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now()-start).count();
    }
    double spent(){
        return (double)spentTime;
    }

private:
    std::chrono::time_point<std::chrono::high_resolution_clock> start;
    long long spentTime;
};

Você precisa usar o arquivo de cabeçalho <chrono>, que é como o acima.

5. Temporizador C#

    class Timer
    {
        private DateTime dt;
        private TimeSpan tSpen;
        public Timer()
        {
            dt= DateTime.Now;
        }

        public void begin()
        {
            dt= DateTime.Now;
        }
        public void end()
        {
            tSpen=DateTime.Now-dt;
        }
        public double spent()
        {
            return tSpen.TotalMilliseconds;
        }
    }

Na verdade, C# não deveria precisar de nenhum temporizador, apenas das classes DateTime e TimeSpan. A maior precisão é de milissegundos.

6. Obtenha a hora atual em C++

    time_t tm0;
    time(&tm0);
    std::cout<<tm0<<endl;
    cout<<ctime(&tm0)<<endl;

A saída é segunda-feira, 20 de março, 23:29:15 de 2023. ctime é formatar os segundos em uma string

    tm ttm= *localtime(&tm0);
    cout<<ttm.tm_year<<"\t"<<ttm.tm_mon<<"\t"<<ttm.tm_mday<<endl;

struct tm, produz o ano e a hora desde 1900.