C++ 默认参数与类内成员初始化与委托构造函数

我想决定主要使用哪种方法来构造具有多个构造函数的复杂对象

那么，默认参数的优缺点是什么，类内成员初始化和委托构造函数相互作用？

默认参数

class DefaultParams
{
public:
  DefaultParams(int a = 42,
                const std::string &b = "42")
                :
                m_a(a),
                m_b(b)
  {
    // DO THINGS
  };

  DefaultParams(const std::string &b)
    :
    m_a(42),
    m_b(b)
  {
    // DO THINGS
  };

private:
  int m_a;
  std::string m_b;
};

class DelegatingCTor
{
public:
  DelegatingCTor()
    :
    DelegatingCTor(42, "42")
  {
  };

  DelegatingCTor(int a)
    :
    DelegatingCTor(a, "42")
  {
  };

  DelegatingCTor(const std::string &b)
    :
    DelegatingCTor(42, b)
  {
  };

  DelegatingCTor(int a, const std::string &b)
    :
    m_a(a),
    m_b(b)
  {
    // DO THINGS
  };

private:
  int m_a;
  std::string m_b;
};

优点：施工人员少； 缺点：重复代码或需要Init（）方法

类内初始化

class InClass
{
public:
  InClass()
  {
    // DO THINGS
  };

  InClass(int a)
    : 
    m_a(a)
  {
    // DO THINGS
  };

  InClass(const std::string &b)
    :
    m_b(b)
  {
    // DO THINGS
  };

  InClass(int a,
          const std::string &b)
    :
    m_a(a),
    m_b(b)
  {
    // DO THINGS
  };

private:
  int m_a = 42;
  std::string m_b = "42";
};

赞成者：？ 缺点：更多构造函数、重复代码或需要Init（）方法

委托施工人员

class DefaultParams
{
public:
  DefaultParams(int a = 42,
                const std::string &b = "42")
                :
                m_a(a),
                m_b(b)
  {
    // DO THINGS
  };

  DefaultParams(const std::string &b)
    :
    m_a(42),
    m_b(b)
  {
    // DO THINGS
  };

private:
  int m_a;
  std::string m_b;
};

class DelegatingCTor
{
public:
  DelegatingCTor()
    :
    DelegatingCTor(42, "42")
  {
  };

  DelegatingCTor(int a)
    :
    DelegatingCTor(a, "42")
  {
  };

  DelegatingCTor(const std::string &b)
    :
    DelegatingCTor(42, b)
  {
  };

  DelegatingCTor(int a, const std::string &b)
    :
    m_a(a),
    m_b(b)
  {
    // DO THINGS
  };

private:
  int m_a;
  std::string m_b;
};

优点：不要重复代码； 缺点：更多的构造函数

---

当然，还有很多。谢谢你的帮助。

你也需要考虑析构函数。一旦构造函数被执行，对象被认为是构造的，析构函数将运行（更好的异常安全性）。默认参数和类内初始化是两个正交的概念。函数（构造函数或非构造函数）参数不必匹配任何成员变量。我更喜欢委托构造函数。在我看来，代码重复次数越少越好。@JoachimPileborg：我不这么认为。因为默认参数可以用来代替类内初始化，如我的问题所示。现在在实践中，我不知道最好避免使用ctor中的默认参数。如果不小心的话，默认值可能会导致隐式强制转换和临时性