blocks|key|950224|text|这是一个你可以通过测试很好地弄清楚的问题(也就是，它是语言中一个足够主流的部分，大多数编译器几乎肯定能做到这一点，除非你看到编译器之间的差异，否则他们的输出可以被认为是非常权威的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|950225|#include+<iostream>

struct+base+{+
++++virtual+void+x(int+a=0)+{+std::cout+<<+a;+}
++++virtual+~base()+{}
};

struct+derived1+:+base+{+
++++void+x(int+a)+{+std::+cout+<<+a;+}
};

struct+derived2+:+base+{+
++++void+x(int+a+=+1)+{+std::cout+<<+a;+}
};

int+main()+{+
++++base+*b[3];
++++b[0]+=+new+base;
++++b[1]+=+new+derived1;
++++b[2]+=+new+derived2;

++++for+(int+i=0;+i<3;+i%2B%2B)+{
++++++++b[i]->x();
++++++++delete+b[i];
++++}

++++derived1+d;
++++//+d.x();+++++++//+won't+compile.
++++derived2+d2;
++++d2.x();
++++return+0;
}|code-block|syntax|javascript|950226|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is one that you can probably figure out reasonably well by testing (i.e., it's a sufficiently mainstream part of the language that most compilers almost certainly get it right and unless you see differences between compilers, their output can be considered pretty well authoritative).

<pre><code>#include &lt;iostream&gt;

struct base { 
 virtual void x(int a=0) { std::cout &lt;&lt; a; }
 virtual ~base() {}
};

struct derived1 : base { 
 void x(int a) { std:: cout &lt;&lt; a; }
};

struct derived2 : base { 
 void x(int a = 1) { std::cout &lt;&lt; a; }
};

int main() { 
 base *b[3];
 b[0] = new base;
 b[1] = new derived1;
 b[2] = new derived2;

 for (int i=0; i&lt;3; i++) {
 b[i]-&gt;x();
 delete b[i];
 }

 derived1 d;
 // d.x(); // won't compile.
 derived2 d2;
 d2.x();
 return 0;
}
</code></pre>

blocks|key|950275|text|这是Herb+Sutter早期Guru+of+the+Week帖子中的一个主题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|950276|他在这个问题上说的第一件事就是不要那样做。|950277|更详细地说，是的，您可以指定不同的默认参数。它们的工作方式与虚拟函数不同。在对象的动态类型上调用虚函数，而默认参数值基于静态类型。|950278|给定的|950279|class+A+{
++++virtual+void+foo(int+i+=+1)+{+cout+<<+"A::foo"+<<+i+<<+endl;+}
};
class+B:+public+A+{
++++virtual+void+foo(int+i+=+2)+{+cout+<<+"B::foo"+<<+i+<<+endl;+}
};
void+test()+{
A+a;
B+b;
A*+ap+=+&b;
a.foo();
b.foo();
ap->foo();
}|code-block|syntax|javascript|950280|你应该得到A::foo1+B::foo2+B::foo1|950281|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gotw.ca/gotw/005.htm^0|F|G|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

This was the topic of one of Herb Sutter's early <a href="http://www.gotw.ca/gotw/005.htm" rel="noreferrer">Guru of the Week</a> posts.

The first thing he says on the subject is DON'T DO THAT.

In more detail, yes, you can specify different default parameters. They won't work the same way as the virtual functions. A virtual function is called on the dynamic type of the object, while the default parameter values are based on the static type.

Given

<pre><code>class A {
 virtual void foo(int i = 1) { cout &lt;&lt; "A::foo" &lt;&lt; i &lt;&lt; endl; }
};
class B: public A {
 virtual void foo(int i = 2) { cout &lt;&lt; "B::foo" &lt;&lt; i &lt;&lt; endl; }
};
void test() {
A a;
B b;
A* ap = &amp;b;
a.foo();
b.foo();
ap-&gt;foo();
}
</code></pre>

you should get
 A::foo1
 B::foo2
 B::foo1

blocks|key|950343|text|正如您从其他答案中看到的，这是一个复杂的主题。而不是试图这样做或了解它做了什么(如果你现在必须问，维护者将不得不在一年后询问或查找它)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|950344|相反，应使用默认参数在基类中创建一个公共非虚函数。然后，它调用一个私有或受保护的虚函数，该函数没有默认参数，并根据需要在子类中被覆盖。然后你就不必担心它如何工作的细节了，代码是非常明显的。|950345|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|$]]

As you can see from the other answers this is a complicated subject. Instead of trying to do this or understand what it does (if you have to ask now, the maintainer will have to ask or look it up a year from now).

Instead, create a public non-virtual function in the base class with default parameters. Then it calls a private or protected virtual function that has no default parameters and is overridden in child classes as needed. Then you don't have to worry about the particulars of how it would work and the code is very obvious.

blocks|key|1164491|text|正如其他答案所详细描述的那样，这是个坏主意。然而，由于没有人提到简单而有效的解决方案，这里是:将参数转换为struct，然后您就可以拥有struct成员的默认值！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1164492|所以不是，|1164493|//bad+idea
virtual+method1(int+x+=+0,+int+y+=+0,+int+z+=+0)|code-block|syntax|javascript|1164494|这样做，|1164495|//good+idea
struct+Param1+{
++int+x+=+0,+y+=+0,+z+=+0;
};
virtual+method1(const+Param1&+p)|1164496|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As other answers have detailed, its bad idea. However since no one mentions simple and effective solution, here it is: Convert your parameters to struct and then you can have default values to struct members!

So instead of,

<pre><code>//bad idea
virtual method1(int x = 0, int y = 0, int z = 0)
</code></pre>

do this,

<pre><code>//good idea
struct Param1 {
 int x = 0, y = 0, z = 0;
};
virtual method1(const Param1&amp; p)
</code></pre>

If I declare a base class (or interface class) and specify a default value for one or more of its parameters, do the derived classes have to specify the same defaults and if not, which defaults will manifest in the derived classes?

Addendum: I'm also interested in how this may be handled across different compilers and any input on "recommended" practice in this scenario.

Can virtual functions have default parameters?

编译器

如果我声明一个基类(或接口类)并为它的一个或多个参数指定默认值，派生类是否必须指定相同的默认值，如果没有，哪些默认值将在派生类中显示？附录:我也感兴趣的是如何在不同的编译器之间处理这个问题，以及在这个场景中关于“推荐”实践的任何输入。

问虚函数可以有默认参数吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问虚函数可以有默认参数吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问虚函数可以有默认参数吗？
EN