blocks|key|2221222|text|虚拟成员函数基本上是指向函数的指针，该函数指向要调用的正确函数，具体取决于类层次结构实现。(请注意，它不一定是一个指针，但它通常是这样实现的，因为它似乎是这种抽象最有效的实现)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2221223|这表明知道哪个函数将被调用仅在运行时确定。|2221224|那么，如何内联一个只有在运行时才知道的函数呢？不可能。|2221225|除非你有一个|2221226|编译器:)+-+the_drow|blockquote|2221227|2221228|2221229|是真的。这并不常见，而且您可能会在启动时丢失一些性能，但仍然是正确的。|2221230|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

A virtual member function is basically a pointer to a function that points to the correct function to call depending on the class hierarchy implementations. (note that it don't have to be a pointer, but it's often implemented as this because it seems to be the most efficient implementation for this abstraction).

That suggest that knowing wich function will be called is only determined at runtime.

So how would it be possible to inline a function that is only known at runtime? Impossible.

<blockquote>
 Unless you have a JIT compiler :) –
 the_drow
</blockquote>

True. Not common and you might loose some performance on boot, but still true.

blocks|key|123022|text|给定：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|123023|struct+T+{
+++virtual+void+foo()+{+/*+something+*/+}
};|code-block|syntax|javascript|123024|使用多态性的(如果您通过pointer-to-T或reference-to-T调用foo()+)|offset|length|style|BOLD|CODE|123025|T*+ptr+=+get_ptr_somehow();
ptr->foo();|123026|如果编译器知道T是其继承树中的唯一节点，它可能会放弃虚拟调用并潜在地内联函数。然而，这是一个难以置信的不可能的情况，我怀疑它是否可能被检测到。在所有其他情况下，由于运行时分派，内联是不实用的。|123027|静态分派(如果对bog标准对象调用foo()+)|123028|T+obj;
obj.foo();|123029|在这种情况下，编译器知道obj的动态类型是T，它不需要虚拟调度，因此如果需要的话，可以内联函数代码。|123030|T*+ptr+=+get_ptr_somehow();
ptr->T::foo();|123031|在这种情况下，编译器不知道obj的动态类型，但它知道它将调用哪个函数，知道它不需要虚拟分派，因此如果它想要的话，可以内联函数代码。|123032|entityMap^0|0|0|6|16|C|C|P|E|15|5|0|0|0|2O|7|1|0|0|O|H|5|0|0|0|1E|C|3|L|1|0|0|0|1T|D|3|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@$I|16|J|17|K|L]|$I|18|J|19|K|M]|$I|1A|J|1B|K|M]|$I|1C|J|1D|K|M]]|9|@]|A|$]]|$1|N|3|O|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|P|3|Q|5|6|7|1F|8|@$I|1G|J|1H|K|L]|$I|1I|J|1J|K|M]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1K|8|@$I|1L|J|1M|K|L]|$I|1N|J|1O|K|M]]|9|@]|A|$]]|$1|T|3|U|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1Q|8|@$I|1R|J|1S|K|L]|$I|1T|J|1U|K|M]|$I|1V|J|1W|K|M]]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|Z|3|10|5|6|7|1Y|8|@$I|1Z|J|20|K|L]|$I|21|J|22|K|M]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|12|$]]

Given:

<pre><code>struct T {
 virtual void foo() { /* something */ }
};
</code></pre>

Using polymorphism (If you're calling <code>foo()</code> through a <code>pointer-to-T</code> or a <code>reference-to-T</code>)

<pre><code>T* ptr = get_ptr_somehow();
ptr-&gt;foo();
</code></pre>

If a compiler knows that <code>T</code> is the only node in its inheritance tree, it could forego the virtual calls and potentially inline the function. However, this is an incredibly unlikely scenario and I doubt whether it could even feasibly be detected. In all other cases, inlining is not practical due to the run-time dispatch.

Static dispatch (If you're calling <code>foo()</code> on a bog-standard object)

<pre><code>T obj;
obj.foo();
</code></pre>

In this case, the compiler knows that the dynamic type of <code>obj</code> is <code>T</code>, that it does not require virtual dispatch, and therefore may inline the function code if it wants to.

<pre><code>T* ptr = get_ptr_somehow();
ptr-&gt;T::foo();
</code></pre>

In this case, the compiler doesn't know the dynamic type of <code>obj</code>, but it knows which function it's going to call, knows that it does not require virtual dispatch, and therefore may inline the function code if it wants to.

blocks|key|2221251|text|不，虚函数确实可以内联。虚拟分派仅在以多态方式调用虚拟方法时使用(例如，在指向对象的指针或引用上)。但是，当在对象值上调用虚方法时，不使用虚调度，编译器可以自由地内联它认为合适的内联。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2221252|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|$]]

No, virtual functions can indeed be inlined. Virtual dispatch is only used when calling a virtual method polymorphically (i.e., on a pointer or reference to an object). However, when a virtual method is called on an object value, virtual dispatch is not used and the compiler is free to inline as it sees fit.

blocks|key|123081|text|例如，在堆栈或类内部声明的对象不需要对其被调用的虚函数进行动态调度，因为编译器实际上知道堆栈上所有对象的类型，因此基本上是任何值。虚函数调度仅通过指针或引用发生。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|123082|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|$]]

Objects declared on the stack or inside classes, for example, do not need dynamic dispatch on their virtual functions which are called, because the compiler knows for a fact the types of all objects on the stack, so basically any value. Virtual function dispatch only occurs through pointers or references.

blocks|key|2226498|text|当涉及到优化时，几乎没有什么是正确的。通常，如果编译器无法分辨对象的实际类型，则必须在运行时解析虚函数。如果你有一个实际的实例(Class+an+&)，那么编译器可以确定。如果你有一个引用，它将不得不猜测；如果调用函数本身是内联的，它可能会以这种方式标识静态类型，也可能不会。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2226499|请注意，在这种情况下，指针和引用之间没有区别。在这两种情况下，您都会得到运行时多态性。|2226500|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|$]]

When optimizations are concerned, very little is always true. In general, if the compiler can not tell what the actual type of an object is, virtual functions have to be resolved at runtime. If you have an actual instance (Class versus Class&amp;) then the compiler can be sure. If you have a reference, it will have to guess; if the calling function is itself inlined, it might identify the static type that way or it might not. 

Note that in this case, there is no difference between a pointer and a reference. In either case, you get runtime polymorphism.

blocks|key|1741301|text|虚函数(方法)可以内联。请记住，inline关键字是对编译器的建议，而不是必需的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1741302|内联代码非常类似于将函数按原样粘贴到可执行文件中需要的位置。不会创建独立函数。|1741303|当有指向内联函数的指针时(由编译器在内部或由程序员在外部)，内联可能不会被使用。当有指针指向内联函数时，它必须有一个实例。编译器可以自由地内联代码，但必须在静态(固定)位置有一个实例来满足指针。|1741304|我的建议是内联简单，少于5行代码的方法，而不使用分析器。请记住，内联通常是将代码放在头文件中。当更改方法的代码时，必须重新构建依赖于头文件的所有转换单元。在大型系统中，这可能是代价高昂的。一般来说，大段代码只应该在之后内联它们是经过验证的，并且只是为了按照分析器的指示提高效率。|BOLD|1741305|entityMap^0|G|6|0|0|0|33|S|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|S|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|T|8|@$9|U|A|V|B|L]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|N|$]]

Virtual functions (methods) can be inlined. Remember that the <code>inline</code> keyword is a suggestion to the compiler, not a requirement.

Inlining code is much like pasting the function, as-is, where needed in the executable. A standalone function is not created. 

When there are pointers to an inline function (internally by the compiler or externally by the programmer), the inlining may not be used. There must be one instance of an inlined function when there are pointers to it. The compiler is free to inline the code, but there must be one instance at a static (fixed) location to satisfy the pointers.

My suggestion is to inline simple, less than 5 lines of code, methods without using a profiler. Remember that inlining is usually placing code in a header file. When the method's code is changed, all translation units depending on the header file must be rebuilt. This could be costly in big systems. Generally, big chunks of code should only be inlined after they are validated and only to improve efficiency as dictated by the profiler.

It is said that virtual functions cannot be inlined. Is it always true that if a function is declared virtual, it cannot be inlined anywhere in the code, or is it applicable only under certain situations? (eg., calling method from a base pointer vs. calling method on a reference, etc.)

Is it always true that virtual function cannot be inlined in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

据说虚函数不能内联。如果一个函数被声明为虚拟的，那么它在代码中的任何地方都不能内联，还是只有在某些情况下才适用？(例如，从基指针调用方法与在引用上调用方法，等等)

问虚函数不能在C++中内联是真的吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问虚函数不能在C++中内联是真的吗？EN