Namespaces
Variants

std:: clock

From cppreference.net
< cpp ‎ | chrono ‎ | c
C++
Date and time library
C-style date and time utilities
Definido en el encabezado <ctime>
std:: clock_t clock ( ) ;

Devuelve el tiempo aproximado de procesador utilizado por el proceso desde el comienzo de una era definida por la implementación relacionada con la ejecución del programa. Para convertir el valor resultante a segundos divídalo por CLOCKS_PER_SEC .

Solo la diferencia entre dos valores devueltos por diferentes llamadas a std::clock es significativa, ya que el inicio de la era de std::clock no tiene que coincidir con el comienzo del programa.

std::clock puede avanzar más rápido o más lento que el reloj de pared, dependiendo de los recursos de ejecución proporcionados al programa por el sistema operativo. Por ejemplo, si la CPU es compartida por otros procesos, std::clock puede avanzar más lento que el reloj de pared. Por otro lado, si el proceso actual es multihilo y hay más de un núcleo de ejecución disponible, std::clock puede avanzar más rápido que el reloj de pared.

Contenidos

Valor de retorno

Tiempo de procesador utilizado por el programa hasta ahora.

  • Si el tiempo de procesador utilizado no está disponible, retorna ( std:: clock_t ) ( - 1 ) .
  • Si el valor del tiempo de procesador utilizado no puede ser representado por std::clock_t , retorna un valor no especificado.

Excepciones

No lanza nada.

Notas

En sistemas compatibles con POSIX, clock_gettime con el ID de reloj CLOCK_PROCESS_CPUTIME_ID ofrece una mejor resolución.

El valor devuelto por clock() puede desbordarse en algunas implementaciones. Por ejemplo, en dicha implementación, si std::clock_t es un entero de 32 bits con signo y CLOCKS_PER_SEC es 1 '000' 000 , se desbordará después de aproximadamente 2147 segundos (aproximadamente 36 minutos).

Ejemplo

Este ejemplo demuestra la diferencia entre el tiempo de clock() y el tiempo real.

Ejecutar este código 
#include <chrono>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <thread>
// The function f() does some time-consuming work.
void f()
{
    volatile double d = 0;
    for (int n = 0; n != 10000; ++n)
        for (int m = 0; m != 10000; ++m)
            d += d * n * m;
}
int main()
{
    const std::clock_t c_start = std::clock();
    auto t_start = std::chrono::high_resolution_clock::now();
    std::thread t1(f);
    std::thread t2(f); // f() is called on two threads
    t1.join();
    t2.join();
    const std::clock_t c_end = std::clock();
    const auto t_end = std::chrono::high_resolution_clock::now();
    std::cout << std::fixed << std::setprecision(2) << "CPU time used: "
              << 1000.0 * (c_end - c_start) / CLOCKS_PER_SEC << "ms\n"
              << "Wall clock time passed: "
              << std::chrono::duration<double, std::milli>(t_end - t_start) << '\n';
}

Salida posible: 

CPU time used: 1590.00ms
Wall clock time passed: 808.23ms

Véase también

convierte un objeto std::time_t a una representación textual
(función)
devuelve el tiempo actual del sistema como tiempo desde el epoch
(función)
Documentación C para clock