blocks|key|341855|text|要记住的重要规则是，一旦一个函数被声明为虚拟的，在派生类中具有匹配签名的函数始终是虚拟的。因此，它被A的孩子和B的孩子覆盖，这两个孩子的行为是相同的(除了你不能直接实例化BaseA)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341856|然而，在C中，函数不会被覆盖，而是会被重载。在这种情况下，只有静态类型才重要:它将根据指向的指针(静态类型)来调用它，而不是根据对象实际是什么(动态类型)来调用它。|341857|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 important rule to remember is once a function is declared virtual, functions with matching signatures in the derived classes are always virtual. So, it is overridden for Child of A and Child of B, which would behave identically (with the exception of you can't directly instantiate BaseA).

With C, however, the function isn't overridden, but overloaded. In that situation, only the static type matters: it will call it on what it is a pointer to (the static type) instead of what the object really is (the dynamic type)

blocks|key|3319470|text|在派生类中，如果方法在基类中定义为虚拟的，则该方法是虚拟的，即使在派生类的方法中未使用关键字virtual。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3319471|对于带有BaseA的|offset|length|style|CODE|3319472|，它将按预期进行编译和执行，其中foo()是虚拟的，并在带有BaseB的类Child.|unordered-list-item|3319473|With中执行；它也将按预期进行编译和执行，其中foo()是虚拟的()，并在类Child.|3319474|+BaseC中执行。但是，它将进行编译和执行，但如果您从BaseC的上下文调用它，它将执行BaseC版本；如果您使用Child.|3319475|With的上下文调用它，它将执行<BaseC>版本|3319476|3319477|entityMap^0|0|4|5|0|G|5|U|5|11|5|0|O|5|13|5|0|1|5|S|5|19|5|1M|5|0|H|5|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|K|3|L|5|J|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|S|$]]

In the derived class a method is virtual if it is defined virtual in the base class, even if the keyword virtual is not used in the derived class's method.

<ul>
<li>With <code>BaseA</code>, it will compile and execute as intended, with <code>foo()</code> being virtual and executing in class <code>Child</code>.</li>
<li>Same with <code>BaseB</code>, it will also compile and execute as intended, with <code>foo()</code> being virtual() and executing in class <code>Child</code>.</li>
<li>With <code>BaseC</code> however, it will compile and execute, but it will execute the <code>BaseC</code> version if you call it from the context of <code>BaseC</code>, and the <code>Child</code> version if you call with the context of <code>Child</code>.</li>
</ul>

blocks|key|339394|text|类Child将编译如果派生自A，则不能实例化该类型的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339395|如果你打算从Base中重写一些函数，然后再次派生，这可能是有价值的。|339396|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|$]]

Class Child will compile if derived from A, you just can't instantiate objects of that type. 

This might be valuable if you were going to override some functions from Base, and then derive again.

blocks|key|337048|text|使用BaseA时为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|337049|，则子类不编译，未定义纯虚函数|blockquote|337050|337051|337052|只有当您尝试创建BaseA的对象时，才会出现这种情况。如果您创建了Child对象，然后可以使用BaseA*或Child*调用foo()|337053|如果使用BaseB，则在BaseB*或|337054|+*上调用foo时，将调用子对象中的函数。|337055|337056|337057|取决于对象的类型，因为对象可以是BaseB或子项。如果对象为BaseB，则调用BaseB::foo。|337058|使用BaseC，在|337059|+*上调用foo时，会调用子类中的函数，但不会在BaseB*上调用(调用父类中的函数)。|337060|337061|337062|是的，但你永远不会想这么做的。|337063|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|16|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1B|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

<blockquote>
 With BaseA, the child class doesn't
 compile, the pure virtual function
 isn't defined
</blockquote>

This is true only if you try to create an object of BaseA. If you create a object of Child and then you can call foo() using either BaseA* or Child*

<blockquote>
 With BaseB, the function in the child
 is called when calling foo on a BaseB*
 or Child*.
</blockquote>

Depends upon the type of the object as the object can be either BaseB or Child. If the object is BaseB then BaseB::foo is called. 

<blockquote>
 With BaseC, thefunction in the child
 is called when calling foo on Child*
 but not on BaseB* (the function in
 parent class is called).
</blockquote>

Yes, but you never want to do this.

blocks|key|3106737|text|从多态的角度来看，首选A，这样您就知道每个孩子都有自己的虚拟函数实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3106738|选择B主要是如果你有一个有效的默认实现，但是你必须确保所有的子类都有自己需要的实现。C不是多态的，所以要谨慎使用。|3106739|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|$]]

From a polymorphism point of view, prefer A, so you know each child has his own implementation of the virtual function. 
Choose B mainly if you have a valid default implementation, but then you have to make sure that all child-classes have their own implementation as needed.
C is not polymorphism, so use judiciously.

blocks|key|3319632|text|这很大程度上取决于你怎么称呼它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3319633|如果你这样做了：|3319634|class+Child+:+public+BaseA
{
public:
++++int+foo()+{+return+42;+}
};|code-block|syntax|javascript|3319635|并做到了|3319636|BaseA+baseA+=+new+Child();
baseA->foo();|3319637|它将调用Child的foo函数。|3319638|但是，如果您这样做了：|3319639|BaseA+baseA+=+new+BaseA();|3319640|它会产生编译时错误。|3319641|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

It mostly depends on how you called it.

if you did:

<pre><code>class Child : public BaseA
{
public:
 int foo() { return 42; }
};
</code></pre>

and did

<pre><code>BaseA baseA = new Child();
baseA-&gt;foo();
</code></pre>

It would call Child's foo function.

However, if you did this:

<pre><code>BaseA baseA = new BaseA();
</code></pre>

It would produce a compile time error.

I have three different base classes:

<pre><code>class BaseA
{
public:
 virtual int foo() = 0;
};

class BaseB
{
public:
 virtual int foo() { return 42; }
};

class BaseC
{
public:
 int foo() { return 42; }
};
</code></pre>

I then derive from the base like this (substitute X for A, B or C):

<pre><code>class Child : public BaseX
{
public:
 int foo() { return 42; }
};
</code></pre>

How is the function overridden in the three different base classes? Are my three following assumptions correct? Are there any other caveats?

<ul>
<li>With BaseA, the child class doesn't compile, the pure virtual function isn't defined.</li>
<li>With BaseB, the function in the child is called when calling foo on a BaseB* or Child*.</li>
<li>With BaseC, the function in the child is called when calling foo on Child* but not on BaseB* (the function in parent class is called).</li>
</ul>

C++ function overriding

我有三个不同的基类：class BaseA{public:    virtual int foo() = 0;};class BaseB{public:    virtual int foo() { return 42; }};class BaseC{public:    int foo() { return 42; ...

问C++函数重写
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++函数重写EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++函数重写
EN