What is the correct way to multiply and divide ints in C to avoid overflow? I want to determine how many ticks of a timer running at freq (in Hz) will take to make a delay (in ms). This should be ticks = freq * delay / 1000.

在C中乘除整数以避免溢出的正确方法是什么？我想确定以频率(以赫兹为单位)运行的计时器延迟(以毫秒为单位)将花费多少滴答声。这应该是TICKS=freq*Delay/1000。

But, that line looks dangerous to me. If we write (freq * delay) / 1000 we run the risk of overflow. If instead we write freq * (delay / 1000), we will get into floats - which are unnecessary and error prone, esp. on a microcontroller.

但是，在我看来，这条线很危险。如果我们写入(freq*Delay)/1000，我们就有溢出的风险。相反，如果我们编写freq*(Delay/1000)，我们将进入浮点数-这是不必要的，而且容易出错，例如。在微控制器上。

What is the correct way to do this?

正确的做法是什么？

Code is running on a Cortex M4 ARM microcontroller. Ticks are from SysTick timer. All vars are uint32_t or volatile uint32_t.

代码在Cortex M4 ARM微控制器上运行。滴答来自SysTick Timer。所有变量都是uint32_t或易失性uint32_t。

Your suggested:

您的建议：

freq * (delay / 1000)

Is not a floating point operation. That would require:

不是浮点运算。这将需要：

freq * (delay / 1000.0)

But you are correct that it is not necessary. Far better would be:

但你说得对，这是没有必要的。更好的办法是：

(freq / 1000) * delay

So long as freq is a multiple of 1000, that will result in no loss of precision, and avoids at least a "premature" overflow (i.e. an overflow that occurs at lower values due to a poor choice of operation order).

只要freq是1000的倍数，就不会导致精度损失，并且至少可以避免“过早”溢出(即，由于操作顺序选择不当而在较低值时发生的溢出)。

An overflow of course remains possible, but this expression gives the maximum range possible for delay without resorting to a larger type. For example if the expression is of type uint32_t, delay can be up to 2³²/1000, or nearly 72 minutes.

当然，溢出仍然是可能的，但此表达式给出了在不求助于更大类型的情况下延迟的最大可能范围。例如，如果表达式的类型为uint32_t，则延迟可能高达232/1000，即近72分钟。

Critically, the reordering enables the range of delay to be deterministic across any system. It is no longer dependent on the value of freq - it will always be 72 minutes.

关键的是，重新排序使延迟范围在任何系统上都是确定的。它不再依赖于freq的值-它将始终是72分钟。

If 72 minutes is not long enough, you might even then consider a lower resolution delay (whole seconds for example) before resorting a larger data type (which will be less efficient and may add atomicity issues). Long delays seldom require millisecond precision, and your clock may not be millisecond precise over that length of time in any case - even TCXO's are accurate to typically 2ppm, giving a potential 1ms drift after 500 seconds.

如果72分钟不够长，那么您甚至可以考虑较低的分辨率延迟(例如整秒)，然后再使用较大的数据类型(这将降低效率，并可能增加原子性问题)。较长的延迟很少需要毫秒精度，而且您的时钟在任何情况下都可能不会在该时间长度上精确到毫秒-即使TCXO的精度通常也达到2ppm，在500秒后可能会出现1ms的漂移。

Simply, think how long maximum delay you can have.

简单地说，想想你可以有多长时间的最大延迟。

If using 32bit unsigned number (negative numbers for delay are not very practical because I do not know how to have a negative delay which would take us back in time). The maximum uint32_t is 4,294,967,295 which is enough for more than one hour delay.

如果使用32位无符号数字(延迟的负数不是很实际，因为我不知道如何有一个负的延迟，这将使我们回到过去)。最大uint32_t为4,294,967,295，足以满足一个多小时的延迟。

If you set your timer to increment every 1/1000 sec then uint32_t will be enough to delay 49.7102696181 days

如果您将计时器设置为每1/1000秒递增一次，则uint32_t将足以延迟49.7102696181天

If you need more use a larger unsigned integer in your calculations: ((uint64_t)freq * delay) / 1000

如果需要更多，请在计算中使用更大的无符号整数：((Uint64_T)freq*Delay)/1000

to determine how many ticks of a timer running at freq (in Hz) will take to make a delay (in ms). This should be ticks = freq * delay / 1000.

• Use sufficiently width enough math, perhaps uint64_t to prevent multiplication overflow.

  使用足够宽的数学运算，或许可以使用uint64_t来防止乘法溢出。

  
  



• Consider unsigned math in this case to simplify rounding.

  在本例中考虑无符号数学，以简化四舍五入。

  
  



• Physical quantities often deserve a rounded answer. Round by adding 1/2 the denominator before division.

  物理量往往需要一个全面的答案。在除法前加上1/2的分母进行舍入。

  
  



• Clearly identify physical units.

  清楚地识别物理单元。

  
  



• Avoid naked magic numbers.

  避免赤裸裸的魔术数字。

  
  

uint32_t ticks(uint32_t freq /* Hz */, uint32_t delay /* ms */) {
  #define ms_PER_s 1000
  return (uint32_t) (( (uint64_t)freq*delay + ms_PER_s/2) / ms_PER_s);
}