如何在C++中实现一个正确的时间循环器详解

如何在C++中实现一个正确的时间循环器

什么是时间循环器

时间循环器是一种计时器，它按照一定的时间间隔来触发事件。在游戏编程中，时间循环器经常被用来控制游戏的逻辑，例如更新游戏物体的位置、判断游戏事件是否发生等。

实现思路

实现一个时间循环器的关键在于利用计时器并按照一定的时间间隔来触发事件。这个过程可以通过以下步骤来完成。

1. 获取时间戳，记录当前时间。

2. 使用时间戳计时器来定时触发事件。

3. 在事件处理函数中，处理需要执行的逻辑。

4. 回到步骤1。

实现代码

以下是一个简单的时间循环器实现代码的示例。它使用了C++11标准的<chrono>库来操作时间戳和计时器。

#include <iostream>
#include <chrono>
#include <thread>

class Timer {
 public:
  Timer(int interval, std::function<void(void)> callback)
      : interval_(interval), callback_(callback) {}

  void Start() {
    thread_ = std::thread([this]() {
      while (!stop_) {
        auto start = std::chrono::high_resolution_clock::now();
        std::this_thread::sleep_for(std::chrono::milliseconds(interval_));
        auto duration = std::chrono::duration_cast
            <std::chrono::milliseconds>
            (std::chrono::high_resolution_clock::now() - start);
        if (!stop_) {
          callback_();
        }
      }
    });
  }

  void Stop() {
    stop_ = true;
    if (thread_.joinable()) {
      thread_.join();
    }
  }

 private:
  bool stop_ = false;
  int interval_;
  std::function<void(void)> callback_;
  std::thread thread_;
};

void OnTimer() {
  std::cout << "Timer triggered" << std::endl;
}

int main() {
  Timer timer(1000, OnTimer);
  timer.Start();
  std::this_thread::sleep_for(std::chrono::seconds(5));
  timer.Stop();
  return 0;
}

这个代码示例中，Timer类表示一个时间循环器，初始化时需要传入时间间隔interval和事件处理函数callback。当调用Start方法时，会在新线程中启动一个计时器，每隔interval毫秒就会触发一次事件，事件处理函数会在主线程中被执行。当需要停止计时器时，调用Stop方法即可停止计时器。

示例说明

这里提供两个示例说明。

示例1

在这个示例中，我们使用一个时间循环器来更新一个计数器。计数器初始值为0，时间循环器每隔500毫秒就会触发一次事件，在事件处理函数中将计数器加1，直到计数器的值达到10。

#include <iostream>
#include <chrono>
#include <thread>

class Timer {
 public:
  Timer(int interval, std::function<void(void)> callback)
      : interval_(interval), callback_(callback) {}

  void Start() {
    thread_ = std::thread([this]() {
      while (!stop_) {
        auto start = std::chrono::high_resolution_clock::now();
        std::this_thread::sleep_for(std::chrono::milliseconds(interval_));
        auto duration = std::chrono::duration_cast
            <std::chrono::milliseconds>
            (std::chrono::high_resolution_clock::now() - start);
        if (!stop_) {
          callback_();
        }
      }
    });
  }

  void Stop() {
    stop_ = true;
    if (thread_.joinable()) {
      thread_.join();
    }
  }

 private:
  bool stop_ = false;
  int interval_;
  std::function<void(void)> callback_;
  std::thread thread_;
};

void OnTimer() {
  static int counter = 0;
  std::cout << "Counter is " << counter << std::endl;
  if (counter == 10) {
    std::cout << "Timer stopped" << std::endl;
  } else {
    ++counter;
  }
}

int main() {
  Timer timer(500, OnTimer);
  timer.Start();
  while (true) {
    // Wait for timer to stop
  }
  return 0;
}

在这个示例中，我们定义了一个静态的计数器counter，初始值为0。当时间循环器触发事件时，它会将counter的值加1，并输出Counter is <counter>的信息。当计数器的值达到10时，时间循环器会自动停止，并输出Timer stopped的信息。

示例2

在这个示例中，我们使用一个时间循环器来实现一个简单的英语单词学习程序。程序将从一个文件中读取单词列表，每隔5秒钟就会输出一个单词，直到所有单词都被输出过一次。

#include <iostream>
#include <fstream>
#include <vector>
#include <chrono>
#include <thread>

class Timer {
 public:
  Timer(int interval, std::function<void(void)> callback)
      : interval_(interval), callback_(callback) {}

  void Start() {
    thread_ = std::thread([this]() {
      while (!stop_) {
        auto start = std::chrono::high_resolution_clock::now();
        std::this_thread::sleep_for(std::chrono::milliseconds(interval_));
        auto duration = std::chrono::duration_cast
            <std::chrono::milliseconds>
            (std::chrono::high_resolution_clock::now() - start);
        if (!stop_) {
          callback_();
        }
      }
    });
  }

  void Stop() {
    stop_ = true;
    if (thread_.joinable()) {
      thread_.join();
    }
  }

 private:
  bool stop_ = false;
  int interval_;
  std::function<void(void)> callback_;
  std::thread thread_;
};

void OnTimer(const std::vector<std::string>& words, int& index) {
  std::cout << words[index] << std::endl;
  ++index;
  if (index == words.size()) {
    std::cout << "All words displayed" << std::endl;
  }
}

int main() {
  std::ifstream input("words.txt");
  if (!input) {
    std::cerr << "Failed to open file 'words.txt'" << std::endl;
    return 1;
  }
  std::vector<std::string> words;
  std::string line;
  while (std::getline(input, line)) {
    words.push_back(line);
  }
  input.close();
  int index = 0;
  Timer timer(5000, [&words, &index]() { OnTimer(words, index); });
  timer.Start();
  while (index < words.size()) {
    // Wait for timer to stop
  }
  return 0;
}

在这个示例中，我们从一个文件中读取单词列表，并使用一个静态的索引index来记录当前的单词位置。当时间循环器触发事件时，它会输出当前索引对应的单词，并将索引加1。当所有单词都被输出过一次后，时间循环器会自动停止，并输出All words displayed的信息。