C++ std：：频率计时？

我正在实现一个非常简单的带通滤波器，它的输入参数是一个向量，包含信号、驻留时间以及高通和低通滤波器的截止频率：

typedef std::vector<double> vec;
vec bandPass(const vec& signal, double dwellTime, double lowCutoff, double highCutoff);

让我的函数把所有的单位转换成秒和赫兹进行计算。理想情况下，将毫秒和kHz相乘会得到与秒和Hz相乘相同的结果

有没有人遇到过类似的问题？是合法的C++编写任何代码，如代码＞1／10s < /代码>来指赫兹？< /p>

---

我没有太多的经验，STD：：（和C++，在这方面），希望我能收集一些智慧的话在这里定义我的接口。也欢迎任何其他建议。

频率可以视为周期的持续时间。因此，20赫兹可以被视为0.05秒

Chrono将全力支持这一点

您可能可以编写一个

Hz

类型或频率模板，该模板的作用与某些上下文中周期/持续时间的作用相反。遗憾的是，在内部存储持续时间并不能很好地工作，因为以秒为单位的int Hz作为以秒为单位的持续时间是失败的

template<
  class Rep,
  class Period = std::ratio<1>
>
struct frequency;

template<
  class Rep,
  std::intmax_t Num,
  std::intmax_t Denom>
>
struct frequency<Rep, std::ratio<Num, Denom>>
{
  // todo!
  frequency& operator+=(const frequency& d);
  frequency& operator-=(const frequency& d);
  frequency& operator*=(const Rep& rhs);
  frequency& operator/=(const Rep& rhs);
  frequency& operator%=(const frequency& rhs);
  Rep count() const;
  friend frequency operator+(frequency lhs, frequency const& rhs);
  friend frequency operator-(frequency lhs, frequency const& rhs);
  friend frequency operator*(frequency self, Rep const& scalar);
  friend frequency operator*(Rep const& scalar, frequency self);
  friend frequency operator/(frequency self, Rep const& scalar);
  friend frequency operator%(frequency lhs, Rep const& rhs);
  friend frequency operator%(frequency lhs, frequency const& rhs);
  friend bool operator==(frequency const& lhs, frequency const& rhs);
  friend bool operator!=(frequency const& lhs, frequency const& rhs);
  friend bool operator<=(frequency const& lhs, frequency const& rhs);
  friend bool operator>=(frequency const& lhs, frequency const& rhs);
  friend bool operator<(frequency const& lhs, frequency const& rhs);
  friend bool operator>(frequency const& lhs, frequency const& rhs);
  template<class ToFrequency>
  friend ToFrequency duration_cast(frequency const& self);
  // etc
};

template<class Rep>
using hertz = frequency<Rep>;

template<class T>
hertz<T> operator "" _hz(T t) {
  return hertz<T>(std::move(t));
}

模板<
班级代表，
课程周期=标准：：比率
>
结构频率；
模板<
班级代表，
std:：intmax\u t Num，
std:：intmax\U t Denom>
>
结构频率
{
//托多！
频率和操作员+=（恒定频率和d）；
频率和运算符-=（恒定频率和d）；
频率和操作员*=（常数代表和rhs）；
频率和操作员/=（施工代表和rhs）；
频率和操作员%=（恒定频率和rhs）；
Rep count（）常量；
友元频率运算符+（频率lhs、频率常数和rhs）；
朋友频率操作符-（频率lhs、频率常数和rhs）；
友元频率运算符*（频率自身、代表常数和标量）；
友元频率运算符*（表示常量和标量，频率自）；
友元频率运算符/（频率自身、代表常数和标量）；
朋友频率操作员%（频率左侧、代表常量和右侧）；
朋友频率操作员%（频率lhs、频率常数和rhs）；
friend bool运算符==（频率常数和lhs、频率常数和rhs）；
friend bool运算符！=（频率常数和lhs、频率常数和rhs）；
friend bool运算符=（频率常数和lhs、频率常数和rhs）；
friend bool运算符（频率常数和lhs、频率常数和rhs）；
模板
频率持续时间（频率常数和自身）；
//等
};
模板
使用赫兹=频率；
模板
赫兹运算符“”_赫兹（T）{
返回赫兹（标准：：移动（t））；
}

现在，

13_hz

是一个类型为

frequency

的对象，我认为您正在寻找一个专门用于表示时间间隔的对象。一个易于使用且比此解决方案更简单（但功能较弱）的解决方案存在疑问。

template<
  class Rep,
  class Period = std::ratio<1>
>
struct frequency;

template<
  class Rep,
  std::intmax_t Num,
  std::intmax_t Denom>
>
struct frequency<Rep, std::ratio<Num, Denom>>
{
  // todo!
  frequency& operator+=(const frequency& d);
  frequency& operator-=(const frequency& d);
  frequency& operator*=(const Rep& rhs);
  frequency& operator/=(const Rep& rhs);
  frequency& operator%=(const frequency& rhs);
  Rep count() const;
  friend frequency operator+(frequency lhs, frequency const& rhs);
  friend frequency operator-(frequency lhs, frequency const& rhs);
  friend frequency operator*(frequency self, Rep const& scalar);
  friend frequency operator*(Rep const& scalar, frequency self);
  friend frequency operator/(frequency self, Rep const& scalar);
  friend frequency operator%(frequency lhs, Rep const& rhs);
  friend frequency operator%(frequency lhs, frequency const& rhs);
  friend bool operator==(frequency const& lhs, frequency const& rhs);
  friend bool operator!=(frequency const& lhs, frequency const& rhs);
  friend bool operator<=(frequency const& lhs, frequency const& rhs);
  friend bool operator>=(frequency const& lhs, frequency const& rhs);
  friend bool operator<(frequency const& lhs, frequency const& rhs);
  friend bool operator>(frequency const& lhs, frequency const& rhs);
  template<class ToFrequency>
  friend ToFrequency duration_cast(frequency const& self);
  // etc
};

template<class Rep>
using hertz = frequency<Rep>;

template<class T>
hertz<T> operator "" _hz(T t) {
  return hertz<T>(std::move(t));
}