可选函数参数:使用默认参数(NULL)还是重载函数?

我有一个处理给定vector的函数,但是如果没有给出,也可以创build这样一个vector。

在这种情况下,我看到两个devise选项,其中函数参数是可选的:

使它成为一个指针,并使其默认为NULL

 void foo(int i, std::vector<int>* optional = NULL) { if(optional == NULL){ optional = new std::vector<int>(); // fill vector with data } // process vector } 

或者有两个重载名称的函数,其中一个忽略了参数:

 void foo(int i) { std::vector<int> vec; // fill vec with data foo(i, vec); } void foo(int i, const std::vector<int>& optional) { // process vector } 

有理由相对于另一个更喜欢一个解决scheme吗?

我稍微喜欢第二个,因为我可以使向量为const引用,因为它提供时只能读,而不能写。 此外,界面看起来更清洁(不是NULL只是一个黑客?)。 由间接函数调用产生的性能差异可能被优化掉了。

然而,我经常在代码中看到第一个解决scheme。 除了程序员的懒惰之外,是否有令人信服的理由去select呢?

我肯定会赞成重载方法的第二种方法。

第一种方法( 可选参数 )模糊了方法的定义,因为它不再有一个明确定义的目的。 这反过来增加了代码的复杂性 ,使不熟悉它的人更难理解它。

用第二种方法( 重载方法 ),每种方法都有明确的目的。 每种方法都是结构合理和有凝聚力的 。 一些附加说明:

  • 如果需要将代码复制到两个方法中,则可以将这些代码抽取到单独的方法中,并且每个重载的方法都可以调用此外部方法。
  • 我会更进一步,以不同的方式命名每种方法,以指示方法之间的差异。 这将使代码更加自我logging。

我不会使用任何一种方法。

在这种情况下,foo()的目的似乎是处理一个向量。 也就是说,foo()的工作就是处理vector。

但在foo()的第二个版本中,隐含地给了第二个工作:创buildvector。 foo()版本1和foo()版本2之间的语义不一样。

而不是这样做,我会考虑只有一个foo()函数来处理一个向量,另一个函数创build向量,如果你需要这样的事情。

例如:

 void foo(int i, const std::vector<int>& optional) { // process vector } std::vector<int>* makeVector() { return new std::vector<int>; } 

显然,这些函数是微不足道的,如果所有makeVector()需要完成它的工作完全是刚刚调用new,那么makeVector()函数可能没有意义。 但是我相信,在你的实际情况下,这些函数比这里所显示的要多得多,上面的代码说明了一个基本的语义devise方法: 给一个函数做一个工作

上面的foo()函数的devise也说明了另外一个基本的方法,我个人在代码中使用它来devise接口 – 包括函数签名,类等。这就是:我相信一个好的接口1)使用方便直观,2)使用不当或不可能使用不当 。 在foo()函数的情况下,我们隐含地说,在我的devise中,vector需要已经存在并且“准备就绪”。 通过devisefoo()来获取引用而不是指针,调用者必须已经拥有一个向量,并且他们将很难通过一些不是一个随时可用的向量。

虽然我理解许多人对默认参数和过载的抱怨,但似乎对这些function提供的好处缺乏了解。

默认参数值:
首先我要指出的是,一个项目的初步devise,如果devise得当,应该没有什么用处。 但是,在违约最大的资产发挥作用的地方是现有的项目和成熟的API。 我工作的项目包含了数百万条现有的代码,并没有奢侈的重新编码所有。 所以当你想添加一个需要额外参数的新function时, 新参数需要缺省值。 否则,你会打破使用你的项目的每个人。 这对我个人来说可以,但是我怀疑你的公司或你的产品/ API的用户会喜欢在每次更新时重新编写他们的项目。 简而言之,默认值对于向后兼容性来说非常好! 这通常是您将在大API或现有项目中看到默认值的原因。

函数覆盖:函数覆盖的好处是它允许共享一个function概念,但是具有不同的选项/参数。 然而,很多时候,我看到函数replace懒惰地提供了截然不同的function,只是参数略有不同。 在这种情况下,它们应该分别具有独立命名的function,与它们的具体function有关(就像OP的例子一样)。

这些,C / C + +的特点是好的,使用得当的时候工作得很好。 可以说大部分的编程function都可以说。 这是他们滥用/滥用,他们造成问题。

免责声明:
我知道这个问题已经有几年了,但是由于这些答案出现在我今天(2012年)的search结果中,所以我觉得这需要未来的读者进一步解决。

我同意,我会使用两个function。 基本上,你有两个不同的用例,所以有两个不同的实现是有意义的。

我发现我编写的C ++代码越多,我拥有的参数默认值越less – 如果该function已被弃用,我也不会stream下任何眼泪,尽pipe我不得不重新编写旧代码的stream式加载。

在C ++中引用不能为NULL,真正好的解决scheme是使用Nullable模板。 这会让你做的事情是ref.isNull()

在这里你可以使用这个:

 template<class T> class Nullable { public: Nullable() { m_set = false; } explicit Nullable(T value) { m_value = value; m_set = true; } Nullable(const Nullable &src) { m_set = src.m_set; if(m_set) m_value = src.m_value; } Nullable & operator =(const Nullable &RHS) { m_set = RHS.m_set; if(m_set) m_value = RHS.m_value; return *this; } bool operator ==(const Nullable &RHS) const { if(!m_set && !RHS.m_set) return true; if(m_set != RHS.m_set) return false; return m_value == RHS.m_value; } bool operator !=(const Nullable &RHS) const { return !operator==(RHS); } bool GetSet() const { return m_set; } const T &GetValue() const { return m_value; } T GetValueDefault(const T &defaultValue) const { if(m_set) return m_value; return defaultValue; } void SetValue(const T &value) { m_value = value; m_set = true; } void Clear() { m_set = false; } private: T m_value; bool m_set; }; 

现在你可以拥有了

 void foo(int i, Nullable<AnyClass> &optional = Nullable<AnyClass>()) { //you can do if(optional.isNull()) { } } 

我通常避免第一种情况。 请注意,这两个function在它们的function上是不同的。 其中一个用一些数据填充vector。 另一个不(只接受来自调用者的数据)。 我倾向于命名不同的function,实际上做不同的事情。 事实上,即使你写这些,也是两个function:

  • foo_default (或者只是foo
  • foo_with_values

至less我觉得这个区别是很长的,对于偶尔的图书馆/function用户来说,这个区别更清洁。

我也喜欢第二个。 虽然两者之间没有太大的区别,但基本上在foo(int i)过载中主要使用主要方法的function,主要的重载将完美地工作,而不关心另一个缺less存在的存在,所以还有更多在超载版本中分离问题。

在C ++中,您应该尽可能避免允许有效的NULL参数。 原因是它大大减less了现场文件。 我知道这听起来很极端,但我使用了10-20个参数的API,其中一半可以有效地为NULL。 由此产生的代码几乎是不可读的

 SomeFunction(NULL, pName, NULL, pDestination); 

如果你把它切换到强制const引用,代码只是被迫更可读。

 SomeFunction( Location::Hidden(), pName, SomeOtherValue::Empty(), pDestination); 

我正处于“超载”阵营。 其他人已经添加了关于您的实际代码示例的细节,但是我想添加我认为在一般情况下使用重载与默认值的好处。

  • 任何参数都可以“默认”
  • 如果重写函数的默认值使用不同的值,则不会有问题。
  • 没有必要为现有types添加“hacky”构造函数,以便让它们具有默认值。
  • 输出参数可以是默认的,而不需要使用指针或hacky全局对象。

给每个代码添加一些例子:

任何参数都可以默认:

 class A {}; class B {}; class C {}; void foo (A const &, B const &, C const &); inline void foo (A const & a, C const & c) { foo (a, B (), c); // 'B' defaulted } 

没有重写函数具有不同的默认值的危险:

 class A { public: virtual void foo (int i = 0); }; class B : public A { public: virtual void foo (int i = 100); }; void bar (A & a) { a.foo (); // Always uses '0', no matter of dynamic type of 'a' } 

没有必要为现有的types添加“hacky”构造函数,以允许它们被默认:

 struct POD { int i; int j; }; void foo (POD p); // Adding default (other than {0, 0}) // would require constructor to be added inline void foo () { POD p = { 1, 2 }; foo (p); } 

输出参数可以是默认的,不需要使用指针或hacky全局对象:

 void foo (int i, int & j); // Default requires global "dummy" // or 'j' should be pointer. inline void foo (int i) { int j; foo (i, j); } 

规则重载与默认值的唯一例外是构造函数,目前构造函数不可能转发给另一个构造函数。 (我相信C ++ 0x将解决这个问题)。

我赞成第三种select:分成两个function,但不要超载。

过载本质上不太可用。 他们要求用户了解两个选项,弄清楚它们之间的区别是什么,如果他们如此倾向,还要检查文档或代码,以确保哪个是哪个。

我会有一个函数接受参数,一个叫做“createVectorAndFoo”或类似的东西(显然命名变得更容易真正的问题)。

虽然这违反了“职能的两个职责”规则(并给它一个长名字),但我相信当你的函数确实做了两件事(创buildvector和foo)时,这是可取的。

一般来说,我同意他人使用双function方法的build议。 但是,如果在使用单参数表单时创build的vector总是相同,则可以通过改为静态并使用默认的const&参数来简化它:

 // Either at global scope, or (better) inside a class static vector<int> default_vector = populate_default_vector(); void foo(int i, std::vector<int> const& optional = default_vector) { ... } 

第一种方法比较差,因为你不能分辨是否意外地通过了NULL,或者是否是故意的,如果这是一个意外,那么你可能会造成一个错误。

随着第二个你可以testing(assert,无论)为NULL,并适当地处理它。