C++初学者如何编写计时器程序-C++-PHP中文网

c++初学者如何编写计时器程序

对于C++初学者来说，编写计时器程序最直接的方法就是利用C++11及更高版本提供的

std::chrono

登录后复制

库。它能让你以非常精确且类型安全的方式测量时间，无论是做一个简单的秒表，还是实现一个倒计时器，

chrono

登录后复制

都是一个强大而现代的选择，远比那些老旧的C风格时间函数来得优雅和可靠。

解决方案

要搞定一个C++计时器，我们主要会用到

std::chrono

登录后复制

里的几个关键组件：时钟（

clock

登录后复制

）、时间点（

time_point

登录后复制

）和时长（

duration

登录后复制

）。

我们先从一个最基础的秒表程序入手，这能帮你理解核心概念。这个程序会测量从你按下回车键开始到再次按下回车键之间的时间。

#include <iostream>
#include <chrono>   // 计时器核心库
#include <thread>   // 如果需要暂停，会用到这个

int main() {
    // 告诉用户程序要干嘛
    std::cout << "这是一个简单的秒表程序。\n按下Enter键开始计时..." << std::endl;
    std::cin.ignore(); // 等待用户按下Enter键，并忽略输入缓冲区中的内容

    // 记录开始时间点
    // std::chrono::high_resolution_clock 通常是最高精度的时钟
    // 但有时候它只是 std::chrono::system_clock 或 std::chrono::steady_clock 的别名
    // 对于测量间隔时间，std::chrono::steady_clock 更可靠，因为它不会受系统时间调整的影响。
    auto start_time = std::chrono::steady_clock::now();

    std::cout << "计时已开始。按下Enter键停止计时..." << std::endl;
    std::cin.ignore(); // 再次等待用户按下Enter键

    // 记录结束时间点
    auto end_time = std::chrono::steady_clock::now();

    // 计算时长
    // std::chrono::duration_cast 用于将时长转换为指定的单位
    // 这里我们转换为毫秒 (milliseconds)
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);

    // 输出结果
    std::cout << "总共耗时: " << duration.count() << " 毫秒。" << std::endl;

    // 如果想显示秒数，可以这样：
    auto seconds_duration = std::chrono::duration_cast<std::chrono::duration<double>>(end_time - start_time);
    std::cout << "或者精确到秒: " << seconds_duration.count() << " 秒。" << std::endl;

    // 接下来，我们稍微改动一下，做一个简单的倒计时器。
    // 假设我们要倒计时5秒。
    std::cout << "\n现在来一个5秒倒计时器。\n";
    int countdown_seconds = 5;
    for (int i = countdown_seconds; i > 0; --i) {
        std::cout << i << "...\n";
        // 暂停1秒。std::this_thread::sleep_for 是非阻塞的，它会让当前线程休眠指定时长。
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "时间到！\n";

    return 0;
}

登录后复制

这个例子展示了

std::chrono

登录后复制

的基本用法，包括获取当前时间点、计算时间差以及将时间差转换为特定单位。对于初学者来说，理解这几个概念就能搭建起计时器的骨架了。

立即学习“C++免费学习笔记（深入）”；

C++中

std::chrono

登录后复制

库究竟有何魔力，它和传统时间函数有什么区别？

说实话，刚接触C++时间处理的时候，我个人是有点懵的。一会儿是

time_t

登录后复制

，一会儿是

clock()

登录后复制

，还有些平台特定的API，比如Windows下的

GetTickCount

登录后复制

或

QueryPerformanceCounter

登录后复制

。这些东西用起来要么精度不够，要么可移植性差，要么就是类型不安全，一不小心就可能算错。

std::chrono

登录后复制

的出现，在我看来，简直是C++时间处理领域的一场革命。它的“魔力”主要体现在几个方面：

类型安全与可读性： 你不会再混淆秒、毫秒或纳秒了。
```
std::chrono::seconds(10)
```
登录后复制
就明确表示10秒，
```
std::chrono::milliseconds(500)
```
登录后复制
就是500毫秒。这种强类型系统能有效避免单位转换错误，代码读起来也更清晰。相比之下，传统的
```
time_t
```
登录后复制
通常只是一个整数类型，你得自己记住它代表的是秒数，这在处理更精细的时间单位时就显得力不从心了。
精度与灵活度：
```
chrono
```
登录后复制
能提供纳秒级别的精度（取决于系统时钟），并且可以非常方便地在不同时间单位之间转换，比如从毫秒转换到微秒，或者从秒转换到分钟，只需要一个
```
duration_cast
```
登录后复制
。传统函数如
```
clock()
```
登录后复制
返回的是CPU时钟周期数，需要除以
```
CLOCKS_PER_SEC
```
登录后复制
才能得到秒数，而且它衡量的是CPU时间，而不是实际的“墙上时间”（wall-clock time），这在多任务或多线程环境中很容易造成误解。
可移植性：
```
chrono
```
登录后复制
是C++标准库的一部分，这意味着你的计时器代码在任何支持C++11及以上标准的平台上都能正常工作，无需为不同的操作系统编写不同的时间处理代码。这比那些依赖特定操作系统的API（比如Windows的
```
QueryPerformanceCounter
```
登录后复制
）要省心得多。
时钟选择：
```
chrono
```
登录后复制
提供了多种时钟类型，比如
```
system_clock
```
登录后复制
（与系统实时时间同步，可能受系统时间调整影响）、
```
steady_clock
```
登录后复制
（单调递增，不受系统时间调整影响，非常适合测量时间间隔）和
```
high_resolution_clock
```
登录后复制
（通常是精度最高的时钟，但具体实现可能与
```
system_clock
```
登录后复制
或
```
steady_clock
```
登录后复制
相同）。这种选择性让你能根据具体需求挑选最合适的时钟。

总而言之，

std::chrono

登录后复制

提供了一种现代、安全、精确且可移植的方式来处理时间，对于初学者而言，直接学习并使用它，能少走很多弯路。

编写实时或高精度计时器时，C++初学者常犯哪些错误，又该如何避免？

我个人在刚开始用C++写计时器的时候，也踩过不少坑。这些错误往往不是逻辑上的大问题，而是对时间概念和API细节理解不够深入导致的。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

误用
clock()
登录后复制
函数来测量实际时间间隔：这是个经典错误。
```
std::clock()
```
登录后复制
（来自
```
<ctime>
```
登录后复制
）返回的是程序所使用的CPU时间，而不是从程序开始运行到某个时间点经过的实际“墙上时间”（wall-clock time）。想象一下，如果你的程序在等待用户输入或者被操作系统调度出去执行其他任务了，
```
clock()
```
登录后复制
的计数基本不会增加。所以，如果你想测量一个操作实际花了多少时间，
```
clock()
```
登录后复制
是靠不住的。
- 避免方法： 始终使用
```
std::chrono::steady_clock
```
  登录后复制
  来测量时间间隔。它的时间点是单调递增的，不会因为系统时间调整而跳变，非常适合测量事件的持续时间。
对
high_resolution_clock
登录后复制
的误解：很多初学者看到
```
high_resolution_clock
```
登录后复制
就觉得它肯定是最精确的，所以无脑用它。但实际情况是，
```
high_resolution_clock
```
登录后复制
在某些系统上可能只是
```
system_clock
```
登录后复制
或
```
steady_clock
```
登录后复制
的别名，它的实际精度和稳定性取决于具体的实现。有时候，它甚至可能不是单调递增的，这就会导致一些奇怪的时间倒流现象（虽然不常见）。
- 避免方法： 除非你明确知道你的平台上的
```
high_resolution_clock
```
  登录后复制
  是稳定且高精度的，否则对于测量时间间隔，优先考虑使用
```
std::chrono::steady_clock
```
  登录后复制
  。它保证了单调性，是测量持续时间最稳妥的选择。
忙等待（Busy-waiting）而不是使用
sleep_for
登录后复制
：有些初学者为了实现一个固定延迟，可能会写一个循环，不断地检查当前时间是否达到了目标时间，比如这样：
```
auto start = std::chrono::steady_clock::now();
while (std::chrono::steady_clock::now() - start < std::chrono::seconds(1)) {
    // 什么也不做，或者做一些不重要的检查
}
```
登录后复制
这种“忙等待”会白白消耗CPU资源，让CPU一直处于100%负载，效率极低。
- 避免方法： 当你需要暂停线程一段时间时，使用
```
std::this_thread::sleep_for(std::chrono::seconds(1))
```
  登录后复制
  。它会告诉操作系统，当前线程暂时不需要CPU，让CPU去处理其他任务，从而节省资源。
时间单位转换的精度问题： 当你从一个高精度单位转换到低精度单位时，比如从毫秒转换到秒，如果直接进行整数除法，可能会丢失小数部分。
```
auto duration_ms = std::chrono::milliseconds(1234);
auto duration_s = std::chrono::duration_cast<std::chrono::seconds>(duration_ms); // 结果是1秒，0.234秒被截断了
```
登录后复制
- 避免方法： 如果你需要显示精确到小数的秒数，应该转换到以浮点数表示秒的
```
duration
```
  登录后复制
  类型：
```
auto duration_ms = std::chrono::milliseconds(1234);
auto duration_s_double = std::chrono::duration_cast<std::chrono::duration<double>>(duration_ms); // 结果是1.234秒
```
  登录后复制
  或者直接在计算时使用浮点数：
```
duration_ms.count() / 1000.0
```
  登录后复制
  。
用户输入阻塞计时： 如果你的计时器程序在等待用户输入（比如
```
std::cin >> var;
```
登录后复制
或
```
std::cin.ignore();
```
登录后复制
），那么在用户输入完成之前，计时器实际上是暂停的。这对于一个“实时”或交互式计时器来说，可能会导致不准确的体验。
- 避免方法： 对于简单的命令行计时器，你可能需要接受这种阻塞。但如果需要更复杂的交互式计时，你可能需要考虑非阻塞I/O或者将输入处理放在一个单独的线程中，但这对于初学者来说可能有点超纲，先了解有这个问题就行。

这些小细节，可能不经意间就会影响你计时器的准确性和程序的效率。多思考一下时间的概念，选择合适的API，就能避免这些常见的“坑”。

除了基本的计时功能，C++计时器还能玩出什么花样？（比如实现一个简单的游戏循环或性能测试）

计时器这玩意儿，说白了就是测量时间流逝的工具。一旦你掌握了它，能玩的花样可就多了去了，远不止一个简单的秒表或倒计时。

游戏循环中的“帧率控制”和“Delta Time”： 这是游戏开发里最基础也最重要的应用之一。一个游戏的核心就是一个大循环，每一帧都需要更新游戏状态（比如角色位置、物理模拟）和渲染画面。为了让游戏在不同性能的机器上运行速度保持一致，我们需要引入“Delta Time”（增量时间）。
- 怎么玩： 在游戏循环的每次迭代开始时，记录当前时间。然后计算与上一帧之间的时间差（这就是Delta Time）。所有依赖时间的物理计算、动画更新，都乘以这个Delta Time。
```
// 伪代码
auto last_frame_time = std::chrono::steady_clock::now();
while (game_is_running) {
auto current_time = std::chrono::steady_clock::now();
std::chrono::duration<double> delta_time = current_time - last_frame_time;
last_frame_time = current_time;

// 更新游戏逻辑，例如：
// player_position += player_velocity * delta_time.count(); // 确保速度单位与delta_time一致

// 渲染画面

// 帧率限制（可选）：如果一帧耗时太短，可以sleep_for一下，避免CPU空转
// std::this_thread::sleep_for(std::chrono::milliseconds(16) - (std::chrono::steady_clock::now() - current_time));
}
```
  登录后复制
  这样一来，即使你的电脑很快，一秒钟能跑1000帧，或者很慢只能跑30帧，游戏里的角色移动速度、动画播放速度都会保持一致，不会因为帧率高就跑得飞快。

代码性能测试（Benchmarking）： 想知道你的某个算法或函数到底有多快？计时器就是最好的裁判。在算法执行前后分别记录时间，一减，就知道它花了多久。这对于优化代码、比较不同实现方案的效率至关重要。

怎么玩：

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>

登录后复制

void sort_large_vector() { std::vector data(100000); // 填充数据... for (int i = 0; i < 100000; ++i) { data[i] = rand(); }

auto start = std::chrono::high_resolution_clock::now();
std::sort(data.begin(), data.end()); // 对数据进行排序
auto end = std::chrono::high_resolution_clock::now();

auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "排序10万个元素耗时: " << duration.count() << " 微秒。\n";

登录后复制

}

int main() { sort_large_vector(); return 0; }

通过这种方式，你可以精确地测量不同代码块的执行时间，从而找出性能瓶颈。

登录后复制

实现任务超时（Timeout）机制： 在进行网络通信、文件I/O或者等待某个耗时操作时，你可能不希望程序无限期地等待下去。这时候，计时器就可以用来实现一个超时机制。
- 怎么玩： 启动操作前记录一个开始时间点，然后在一个循环中执行操作，并不断检查当前时间是否超过了预设的超时时长。
```
// 伪代码
std::chrono::seconds timeout_duration(5); // 5秒超时
auto start_op_time = std::chrono::steady_clock::now();
```
  登录后复制
bool operation_completed = false; while (!operation_completed) { // 尝试执行某个耗时操作，例如： // operation_completed = try_receive_network_data();
```
if (std::chrono::steady_clock::now() - start_op_time > timeout_duration) {
    std::cout << "操作超时！\n";
    break; // 退出循环
}
// 为了不忙等待，可以适当sleep_for一下
std::this_thread::sleep_for(std::chrono::milliseconds(100));
```
登录后复制
} if (operation_completed) { std::cout << "操作成功完成。\n"; }
```
这种机制在很多实际应用中都非常有用，能让你的程序更加健壮。
```
登录后复制