# std::clock

> C++ Atlas: `cppatlas.com/w/cpp/chrono/c/clock` | Source: https://en.cppreference.com/w/cpp/chrono/c/clock | Domain: Date and time utilities

Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <ctime>
std::clock_t clock();
```

Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution. To convert result value to seconds divide it by `CLOCKS_PER_SEC`.

Only the difference between two values returned by different calls to `std::clock` is meaningful, as the beginning of the `std::clock` era does not have to coincide with the start of the program.

`std::clock` time may advance faster or slower than the wall clock, depending on the execution resources given to the program by the operating system. For example, if the CPU is shared by other processes, `std::clock` time may advance slower than wall clock. On the other hand, if the current process is multithreaded and more than one execution core is available, `std::clock` time may advance faster than wall clock.

### Return value

Processor time used by the program so far.

- If the processor time used is not available, returns `(std::clock_t)(-1)`.
- If the value of the processor time used cannot be represented by `std::clock_t`, returns an unspecified value.

### Exceptions

Throws nothing.

### Notes

On POSIX-compatible systems, `clock_gettime` with clock id `CLOCK_PROCESS_CPUTIME_ID` offers better resolution.

The value returned by `clock()` may wrap around on some implementations. For example, on such an implementation, if `std::clock_t` is a signed 32-bit integer and `CLOCKS_PER_SEC` is `1'000'000`, it will wrap after about 2147 seconds (about 36 minutes).

### Example

This example demonstrates the difference between `clock()` time and real time.

```cpp
#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';
}
```

Possible output:

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

### See also

- [`ctime`](https://en.cppreference.com/w/cpp/chrono/c/ctime): converts a `std::time_t` object to a textual representation (function)
- [`time`](https://en.cppreference.com/w/cpp/chrono/c/time): returns the current time of the system as time since epoch (function)
- [C documentation for `clock`](https://en.cppreference.com/w/c/chrono/clock)

---
Attribution: content from https://en.cppreference.com/w/cpp/chrono/c/clock (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.