主页 / 问题 / 935814
Accepted
Kaznachei
Asked:2020-01-24 02:05:03 +0000 UTC2020-01-24 02:05:03 +0000 UTC

避免在类构造函数中重复代码。C++

  • 772
class Boo
{
public:
    Boo()
    {
        Сделать X
    }
    Boo(int value)
    {
        Сделать Х
        СделатЬ У
    }
};

例如，我需要在构造函数中做一些事情。并且在这两个构造函数中有重复的代码。据我所知，有两种方法可以避免这种情况。

// 1 вариант
class Boo
{
public:
    Boo()
    {
        Сделать X
    }
    Boo(int value):Boo()
    {
        СделатЬ У
    }
};

// 2 Вариант

class Boo
{
public:
    Boo()
    {
        doX();
    }
    Boo(int value)
    {
        doX();
        Сделать У;
    }

    void doX()
    {
        Делает X;
    }
};

哪一个更好？为什么 ？或者也许有更好的东西？

c++

2 个回答

  1. 如果您正在谈论的“动作”应该完全在构造函数的主体（之间{}）中执行，那么这些方法之间没有根本区别。第二个选项只启动一个额外的实体 - 一个额外的类方法。如果你对此视而不见，那么如何去做就无所谓了。

    但这里需要注意的是，在构造函数中，首先我们感兴趣的是消除初始化列表中的重复，即 专门为

    class Boo
{
public:
    Boo(x, y) : 
        хитро_инициализировать_A(x, y), 
        хитро_инициализировать_B(x, y)
      {}
    Boo() : 
        хитро_инициализировать_A(3, 42),  
        хитро_инициализировать_B(3, 42)
      {}
};

    我们曾经不得不通过

    class Boo
{
public:
    Boo(x, y) :
      // "Ложная" инициализация, возможно неявная
      инициализировать_A_какой-то-хренью, 
      инициализировать_B_какой-то-хренью
    { 
      do(x, y);
    }

    Boo() : 
      // "Ложная" инициализация, возможно неявная
      инициализировать_A_какой-то-хренью, 
      инициализировать_B_какой-то-хренью
    {
      do(3, 42);
    }

    void do(x, y)
    { // Вторая, "настоящая" инициализация 
      хитро_переинициализировать_A_по-новому(x, y);
      хитро_переинициализировать_B_по-новому(x, y);
    }
};

    那些。在这个变体A和B一般情况下，它们将首先进行一些“默认”初始化，然后通过函数中已经存在的额外“预初始化”（或“重新初始化”）。这是不合理的。这种恼人的现象被称为双重初始化问题。此外，这种方法根本不能应用于不允许默认初始化或重新初始化的字段（引用字段、常量字段等）

    这是我们来救援的地方

         ...
     Boo() : Boo(3, 42)
      {}
     ...

    为了解决上述双重初始化的问题，这个变体首先被引入到“相对最近”的语言中。构造器委托方法没有这个缺点。它是执行的初始化，并且只执行一次。

    • 7
  2. Best Answer

    更好是一个相对术语。当一切都符合您的意愿以及用户的意愿和便利时，效果会更好。如果用户可能需要一个方法 void doX()，那么第二个选项更好，因为第一个没有这个方法，如果没有，那么第一个选项更好，因为第一个函数调用更少。当然，一般来说，这样的选项更有用：

      class Boo
{
public:   
    Boo(int value = 0)
    {
        Сделать X
        if (value )
           СделатЬ У
    }
};

    因为没有额外的调用（在性能方面更好）和更少的代码（更好的可读性和可能的​​编译）。这里的差异是如此微不足道，原则上只能谈论可读性......即。使用尽可能少的代码，您需要达到预期的结果。

    更新：

    我再说一遍，这完全取决于你的意图，因为不可能像应该的那样毫不含糊地说话。例如，如果我有这样简单的定义：

    void B()
{
    std::cout << "I am Boo\n";
}
void foo(int n)
{
    std::cout << "i created with  " << --n << '\n';
}

class Boo
{
public:
    Boo(int value)
    {
       B();
       foo(value);
    }
    Boo()
    {
        B();
    }
};
class His_variant {
public:
    His_variant(int value)
    {  
       B();  
       foo(value);
    }
    //разве это то, что я хотел выразить?...
    His_variant() : His_variant(0) {}       
};
class My_version {
public:
    My_version(int value = 0)
    {
        B();
        if (value)
            foo(value);
    }
};

    所以如果我们写一个程序：

    // первый вариант
Boo b, bb(22);
std::cout <<"\n----------------" << std::endl;

// вариант с другого ответа
His_variant h, hh(22);
std::cout <<"\n----------------" << std::endl;

// вариант, о котором говорил я
My_version m, mm(22);

    第一个和第三个选项将给出相同的结果，但我提到的不同之处在于，第二个选项（如另一个答案中提到的）当然会给出完全不同的结果。

    • 3

相关问题