blocks|key|1378204|text|我通常遵循一个经验法则，用3-4个简单的语句作为内联来创建一个函数。但记住这只是对编译器的一个提示是很好的。使其内联或不内联的最后一个调用仅由编译器执行。如果有更多的语句，我将不会声明内联，因为对于愚蠢的编译器，这可能会导致代码膨胀。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378205|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I generally follow a thumb rule where I make a function with 3-4 simple statements as inline. But it is good to remember that it is just a hint to the compiler. The final call to make it inline or not is taken by the compiler only. If there are more than these many statements I will not declare inline as with a stupid compiler it may lead to code bloat.

blocks|key|1163054|text|告诉编译器内联一个函数是一种优化，最重要的优化规则是过早优化是万恶之源。总是写出清晰的代码(使用高效的算法)，然后分析你的程序，只优化耗时太长的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163055|如果你发现一个特定的函数非常简短简单，并且它在一个紧密的内部循环中被调用了数万次，那么它可能是一个很好的候选者。|1163056|不过，您可能会感到惊讶--许多C%2B%2B编译器会自动为您内联小函数--而且它们可能也会忽略您的内联请求。|1163057|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Telling the compiler to inline a function is an optimization, and the most important rule of optimization is that premature optimization is the root of all evil. Always write clear code (using efficient algorithms), then profile your program and only optimize functions that are taking too long.

If you find a particular function is very short and simple, and it's getting called tens of thousands of times in a tight inner loop, it might be a good candidate.

You might be surprised, though - many C++ compilers will automatically inline small functions for you - and they might ignore your request to inline, too.

blocks|key|1378274|text|最好的方法是分析你的程序，并标记那些被调用了很多次的小函数，这些函数会消耗掉inline的CPU周期。这里的关键字是“小”--一旦函数调用开销与花费在函数中的时间相比微不足道，那么内联它们就没有意义了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1378275|我建议的另一个用途是，如果您有一些小函数，这些函数在性能关键型代码中被频繁调用，从而导致缓存未命中相关，那么您可能也应该内联这些函数。同样，这也是分析器应该能够告诉您的。|1378276|entityMap^0|12|6|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

The best way to find out is to profile your program and mark small functions that get called lots of times and burn through CPU cycles that as <code>inline</code>. The keyword here is "small" - once the function call overhead is negligible compared to the time spent in the function, it's pointless to inline them.

The other use I'd suggest is if you've got small functions that get called in performance critical code often enough to make a cache miss relevant, you should probably inline those as well. Again, it's something the profiler should be able to tell you.

blocks|key|1378292|text|最好的方法是检查和比较生成的内联指令和非内联指令。但是，省略inline始终是安全的。使用inline可能会带来您不想要的麻烦。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1378293|entityMap^0|U|6|19|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

The best way would be to examine and compare the generated instructions for inlined and not inlined. However, it is always safe to omit <code>inline</code>. Using <code>inline</code> could lead to trouble you don't want.

blocks|key|1378326|text|过早优化是万恶之源！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378327|根据经验，我通常只内联"getters“和"setters”。一旦代码正常工作并稳定下来，分析就可以显示哪些函数可以从内联中受益。|1378328|另一方面，大多数现代编译器都有相当好的优化算法，并且会为你内联你应该内联的东西。|1378329|Reasuming+--编写内联的单行函数，以后再考虑其他函数。|1378330|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Premature optimization is the root of all evil!

As a rule of thumb I usually inline only "getters" and "setters". Once the code is working and is stable, profiling can show which functions could benefit from inlining. 

On the other hand, most modern compilers have quite good optimization algorithms, and will inline what you should have inlined for you. 

Reasuming -- write inline one-liner functions, and worry about others later.

blocks|key|1378346|text|我经常使用内联函数，而不是作为优化，而是为了使代码更具可读性。有时代码本身比注释、描述性名称等更短、更容易理解。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378347|void+IncreaseCount()+{+freeInstancesCnt%2B%2B;+}|code-block|syntax|javascript|1378348|读者可以立即了解代码的完整语义。|1378349|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I often use inline functions not as an optimization but to make the code more readable. Sometimes the code itself is shorter and easier to understand than comments, descriptive names etc. For example:

<pre><code>void IncreaseCount() { freeInstancesCnt++; }
</code></pre>

The reader immediately knows the complete semantics of the code.

blocks|key|1378373|text|此外，内联方法在维护大型项目时有严重的副作用。当内联代码改变时，所有使用它的文件都会被编译器自动重建(它是一个好的编译器)。这可能会浪费大量的开发时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378374|当inline方法被转移到源文件并且不再内联时，必须重新构建整个项目(至少这是我的经验)。当方法被转换为内联时也是如此。|offset|length|style|CODE|1378375|entityMap^0|0|1|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Also, an inline method has severe side effects when maintaining large projects. When the inline code is changed, all files that use it will be rebuild automatically by the compiler (it it is a good compiler). This could waste a lot of your development time. 

When an <code>inline</code> method is transferred to a source file and not inlined any more, the whole project must be rebuilt (at least this has been my experience). And also when methods are converted to inline.

blocks|key|1378395|text|当您认为您的代码足够小，可以用作内联函数并记住内联函数时，复制您的代码并将其粘贴到函数被调用时，因此它可能足以增加您的执行时间，但也增加了内存消耗。在使用循环/静态变量/递归/切换/goto/虚拟函数时，不能使用内联函数。虚拟意味着等到运行时，而内联意味着在编译期间，因此它们不能同时使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378396|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

When you think your code is small enough to be used as inline and remember inline function duplicate your code and paste it were the function is called so it may be good enough to increase your execution time but increased memory consumption also.
You can't use inline function when you are using a loop/static variable/recursive/switch/goto/Virtual function.
Virtual means wait until runtime and inline means during compilation so they can't be use simultaneously.

I know that inline is a hint or request to compiler and its used to avoid function call overheads.

So on what basis one can determine whether a function is a candidate for inlining or not ?
In which case one should avoid inlining ?

When to use inline function and when not to use it?

编译器

我知道内联是对编译器的一个提示或请求，它用来避免函数调用开销。那么，根据什么可以确定一个函数是否为内联的候选函数呢？在哪种情况下应该避免内联？

问什么时候使用内联函数，什么时候不使用它？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用内联函数，什么时候不使用它？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用内联函数，什么时候不使用它？
EN