1 
class MyClass
{
    public:
        MyClass()
        {
            m_dbLoopStart   = 0.0;
            m_dbLoopStop    = 100.0;
            m_dbLoopStep    = 0.001;
        }

        // Which of the following methods complete in a shorter time?

        void Foo1() const   // This one?
        {
            for (double x=m_dbLoopStart; x<=m_dbLoopStop; x+=m_dbLoopStep)
            {
                f(x);
            }
        }

        void Foo2() const   // Or, this one?
        {
            for (double x=m_dbLoopStart; x<=m_dbLoopStop; x+=m_dbLoopStep)
            {
                2.0 * x + 1.0;
            }
        }

    private:
        double m_dbLoopStart, m_dbLoopStop, m_dbLoopStep;

        inline static double f(double x)
        {
            return 2.0 * x + 1.0;
        }
};

在Foo1()和之间Foo2()，哪一个会更快完成？

4

4 回答 4

3

在这种情况下，使用“内联”是多余的，因为在类定义中定义的函数默认是内联的。
话虽如此，将函数定义为内联并不意味着该函数必须内联，并且不将其定义为内联并不意味着编译器不会内联该函数。

正如其他人已经说过的那样，在这种情况下，它不会有所作为，优化后，即使循环也应该优化为没有代码，x 被分配 m_dbLoopStop 的值（无论 x 可能是什么）。

于 2012-01-03T13:46:05.683 回答
2

如果您使用内联函数，编译器仍可能选择不复制函数本身的主体，从而导致函数调用。如果你显式地编写函数体，那么肯定不会调用任何函数。

所以严格理论上，它更快。

于 2012-01-03T13:32:46.453 回答
1

使用参数调用内联函数与仅使用复制/粘贴代码或#define 宏之间通常存在细微的语义差异。例如，考虑宏和函数：

extern void some_extern_function(int x);
#define foo1(x) (some_extern_function((x)), some_extern_function((x)))
无效内联 foo2(int x) {some_extern_function(x); some_extern_function(x); }

现在假设有人调用它们：

  外部易失性 int some_volatile_int;
  foo1(some_volatile_int);
  foo2(some_volatile_int);

在这种情况下，内联函数foo2必须制作一个副本，some_volatile_int然后将该副本传递给some_extern_function. 相比之下，宏必须加载some_volatile_int两次。根据调用约定，任何一种方法都可能比另一种更快。

于 2012-01-16T20:41:22.843 回答
1

内联函数可能更快，因为它们避免了函数调用的成本和返回开销。请记住，编译器可能会选择不内联函数。

在大多数翻译器中，必须传递函数参数并为参数和任何函数本地存储分配空间。在返回端，必须删除函数局部变量，并且通常返回一个值。

对于简单的函数，例如getter和setter，函数调用和返回的开销比函数中的代码要大。因此内联将加速这些功能。

内联函数还删除了调用函数的分支指令。这减少了处理器清除指令缓存/管道的机会。尽管现代处理器已经实现了算法来减少分支指令的负面影响。

在我的编程实践中，我内联了小（3 行或更小）方法。如果出于性能原因我要内联，我将在内联之前进行概要分析。

于 2012-01-16T21:09:04.280 回答