blocks|key|1721514|text|编译器将生成一个调用图来检测这些类型的东西，并防止它们。因此，它将看到函数调用自身，而不是内联。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721515|但它主要是由inline关键字和编译器开关控制的(例如，即使没有关键字，也可以让它自动内联小函数)。重要的是要注意，调试编译永远不应该内联，因为调用堆栈将不会被保留以镜像您在代码中创建的调用。|1721516|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The compiler will make a call graph to detect these sorts of things and prevent them. So it would see that the function calls itself and not inline. 

But mainly it is controlled by the inline keyword and compiler switches(For example, you can have it auto inline small functions even without the keyword.) Its important to note that Debug compilations should never be inlining as the callstack will not be preserved to mirror the calls you created in code.

blocks|key|1506387|text|编译器创建一个调用图；当检测到调用自身的循环时，函数在某个深度(n=1、10、100，无论编译器调到什么)之后不再内联。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506388|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|$]]

The compiler creates a call graph; when a cycle is detected calling itself, the function is no longer inlined after a certain depth(n=1, 10, 100, whatever the compiler is tuned to).

blocks|key|1721639|text|“编译器如何决定是否内联函数?”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721640|这取决于编译器，指定的选项，编译器的版本号，可能有多少内存可用，等等。|1721641|程序的源代码仍然必须遵守内联函数的规则。无论函数是否被内联，您都必须为它被内联的可能性(未知次数)做好准备。|1721642|维基百科声明递归宏通常是非法的，这一说法看起来相当不明智。C和C%2B%2B可以防止递归调用，但是转换单元不会因为包含看起来像是递归的宏代码而变得非法。在汇编程序中，递归宏通常是合法的。|1721643|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|$]]

"How does the compiler decide whether to inline a function or not ?"

That depends on the compiler, the options that were specified, the version number of the compiler, maybe how much memory is available, etc.

The program's source code still has to obey the rules for inlined functions. Whether or not the function gets inlined, you have to prepare for the possibility that it will be inlined (some unknown number of times).

The Wikipedia statement that recursive macros are typically illegal looks rather poorly informed. C and C++ prevent recursive invocations but a translation unit doesn't become illegal by containing macro code that looks like it would have been recursive. In assemblers, recursive macros are typically legal.

blocks|key|1506489|text|请参阅已经给出的答案，了解为什么这通常不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506490|作为“脚注”，您可以使用template+metaprogramming实现您正在寻找的效果(至少对于您正在用作示例的阶乘)。从维基百科粘贴：|offset|length|1506491|template+<int+N>
struct+Factorial+
{
++++enum+{+value+=+N+*+Factorial<N+-+1>::value+};
};

template+<>
struct+Factorial<0>+
{
++++enum+{+value+=+1+};
};|code-block|syntax|javascript|1506492|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Template_metaprogramming#Compile-time_class_generation^0|0|C|O|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

See the answers already given for why this won't typically work.

As a "footnote", you could achieve the effect you're looking for (at least for the factorial you're using as an example) using <a href="http://en.wikipedia.org/wiki/Template_metaprogramming#Compile-time_class_generation" rel="nofollow noreferrer">template metaprogramming</a>. Pasting from Wikipedia:

<pre><code>template &lt;int N&gt;
struct Factorial 
{
 enum { value = N * Factorial&lt;N - 1&gt;::value };
};

template &lt;&gt;
struct Factorial&lt;0&gt; 
{
 enum { value = 1 };
};
</code></pre>

blocks|key|1506535|text|如果可能的话，AFAIK+GCC将在递归函数上做尾部调用消除。但是，您的函数不是尾递归的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506536|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|$]]

AFAIK GCC will do tail call elimination on recursive functions, if possible. Your function however is not tail recursive.

blocks|key|1506578|text|一些递归函数可以转换为循环，从而有效地将它们无限内联。我相信gcc可以做到这一点，但我不知道其他编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1506579|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|$]]

Some recursive functions can be transformed into loops, which effectively infinitely inlines them. I believe gcc can do this, but I don't know about other compilers.

blocks|key|1721816|text|一些编译器(例如Borland+C%2B%2B)不内联包含条件语句(if、case、while等)的代码。因此，示例中的递归函数不是内联的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1721817|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|$]]

Some compilers (I.e. Borland C++) do not inline code that contains conditional statements (if, case, while etc..) so the recursive function in your example would not be inlined.

<pre><code>inline int factorial(int n)
{
 if(!n) return 1;
 else return n*factorial(n-1);
}
</code></pre>

As I was reading <a href="https://rads.stackoverflow.com/amzn/click/com/0201543303" rel="noreferrer" rel="nofollow noreferrer">this</a>, found that the above code would lead to "infinite compilation" if not handled by compiler correctly.

How does the compiler decide whether to inline a function or not ?

Can a recursive function be inline?

编译器

inline int factorial(int n){    if(!n) return 1;    else return n*factorial(n-1);}当我阅读时，我发现如果编译器没有正确处理上面的代码将导致“无限编译”。编译器如何决定是否内联函数？

问递归函数可以是内联的吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问递归函数可以是内联的吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问递归函数可以是内联的吗？
EN