C++ C++；初始化列表

下面是我不完全理解的初始化列表上的代码。特别是它是页面中的最后一块（

红色（“红色”）和蓝色（“蓝色”）

）

Bow是

.h

文件中包含的另一个类，其构造函数的形式为

Bow（stringacolor）

初始化语法是

ClassName(argumentlist): datamember1(value1), dataMember2(value2){}

我不理解这个初始化是如何工作的。我理解在类

ArcheryCompetition

中创建类

Bow

的对象，这几乎就像在另一个构造函数的初始化列表中调用另一个类的构造函数一样。这都来自我正在阅读的一本入门书

如果需要更多的澄清，请让我知道

class ArcheryCompetition
{
//member variables

private:
    //variables
    int rounds;
    float redScore;
    Bow red;

    float blueScore;
    Bow blue;

public:
    //constructor
    ArcheryCompetition( int lrounds);
    //destructor
    ~ArcheryCompetition();

    //methods
    int compete(void);

};

ArcheryCompetition::ArcheryCompetition(int lrounds):
rounds(lrounds), red(Bow("red")), blue(Bow("blue")), redScore(0), blueScore(0)**
{
}

比如说

Bow("red")

正在调用

Bow

构造函数

---

您还应该将初始值设定项的顺序与声明的顺序相同。

例如

Bow("red")

正在调用

Bow

构造函数

---

此外，您还应该将初始值设定项按与声明相同的顺序排列。

代码

 ArcheryCompetition::ArcheryCompetition(int lrounds)
    : rounds(lrounds), red(Bow("red")), blue(Bow("blue")), 
      redScore(0), blueScore(0)
 {
 }

正在为

ArcheryCompetition

定义构造函数，该构造函数将成员变量

舍入
到
lround
，使用
调用
Bow
构造函数，并将
red
成员变量设置为副本（因此使用副本构造函数），等等

你的术语有点让人困惑：C++11标准给了你完全不同的…代码

 ArcheryCompetition::ArcheryCompetition(int lrounds)
    : rounds(lrounds), red(Bow("red")), blue(Bow("blue")), 
      redScore(0), blueScore(0)
 {
 }

正在为
ArcheryCompetition
定义构造函数，该构造函数将成员变量
舍入
到
lround
，使用
调用
Bow
构造函数，并将
red
成员变量设置为副本（因此使用副本构造函数），等等

你的术语有点让人困惑：C++11标准给了你完全不同的…
初始值设定项

red(Bow("red"))

使用参数“red”调用
Bow
构造函数，然后使用新的（匿名）
Bow
初始化器初始化
red

red(Bow("red"))

用参数“red”调用
Bow
构造函数，然后用新的（匿名）
Bow
初始化
red
，
Bow（“red”）
将为您提供类
Bow
的实例

red（Bow（“red”）
表示用
Bow（“red”）
初始化日期成员
red
Bow（“red”）
将为您提供类
Bow
的实例

red（Bow（“red”）
表示用
red（“red”）
初始化日期成员
red
，red和blue都是类Bow的实例，因此调用red（“red”）和blue（“blue”）就足够了。它将使用所选参数调用类Bow的构造函数：

ArcheryCompetition::ArcheryCompetition(int lrounds):
rounds(lrounds), red("red"), blue("blue"), redScore(0), blueScore(0)
{
}

red（Bow（“red”）实际上是对类Bow的复制构造函数的调用

它创建Bow的临时实例，用“red”参数调用它的构造函数，并将这个临时对象逐字节复制到为red成员保留的内存中。我知道这可能有点混乱，我不知道为什么这样的构造放在书中，而不解释复制构造函数是什么

在这里你可以找到一些很好的解释：
由于成员红色和蓝色都是类Bow的实例，因此调用红色（“红色”）和蓝色（“蓝色”）就足够了。它将使用所选参数调用类Bow的构造函数：

ArcheryCompetition::ArcheryCompetition(int lrounds):
rounds(lrounds), red("red"), blue("blue"), redScore(0), blueScore(0)
{
}

red（Bow（“red”）实际上是对类Bow的复制构造函数的调用

它创建Bow的临时实例，用“red”参数调用它的构造函数，并将这个临时对象逐字节复制到为red成员保留的内存中。我知道这可能有点混乱，我不知道为什么这样的构造放在书中，而不解释复制构造函数是什么

在这里你可以找到一些很好的解释：
仔细检查以下操作

Bow("red");

Bow red("red");

Bow red = Bow("red");

Bow redbow("red"); Bow red(redbow);

如果你得到了这些，但仍在挣扎

red(Bow("red"))

那么这将是一个学习不要给成员变量起模棱两可的名字的好时机，因为这些名字不能将它们与局部变量区分开来，例如

class ArcheryCompetition
{
...
    int m_rounds;
    Bow m_red;
    Bow m_blue;
...

    ArcheryCompetition(int rounds_) // distinguish parameters from local variables too
        : m_rounds(rounds_)
        , m_red(Bow("red"))
        , m_blue(Bow("blue"))
        ...
    {}
...
};

在构造函数声明之后，“：”语法表示一个“初始值设定项列表”，您可以在其中初始化类的成员，其中初始化意味着构造。这基本上是一种表示“当我被构造时，我的成员应该这样构造”的方式-因此，调用其他类的构造函数是完全正确的；它们在您的类成员上被适当地调用，以符合您的规范。因此，“m_blue（Bow（“blue”）”告诉编译器使用参数“blue”调用Bow构造函数，以在调用此构造函数期间初始化m_blue成员

除了在本例中，通过添加类名，您实际上所做的是

Bow redbow("red");
m_red(redbow);

它创建一个临时Bow对象，并用值“red”初始化，然后使用Bow的复制构造函数将数据复制到m_red中

实际上，您可以将构造函数简化（改进）为

    ArcheryCompetition(int rounds_) // distinguish parameters from local variables too
        : m_rounds(rounds_)
        , m_red("red")
        , m_blue("blue")
        ...
    {}

编辑：

当你看到

class MyClass {
    int i;
     YourClass m_yourClass1, m_yourClass2;

public:
    MyClass()
      : m_i(10)
      , m_yourClass1( YourClass(1) )
      , m_yourClass2( 2 )
    {}
};

void foo() {
     MyClass myClass;
     ...
}

然后，大致上，第一行“foo”会导致类似的事情发生：

MyClass* myClassPtr = make_room_on_stack_for(sizeof(MyClass));

// : m_i(10)
myClassPtr->m_i = 10;

// , m_yourClass1( YourClass(1) )
YourClass* temporary = make_room_on_stack_for(sizeof(YourClass));
temporary->YourClass(1);
if(YourClass has a copy constructor (YourClass::YourClass(const YourClass&))
    myClassPtr->m_yourClass1->YourClass(temporary); // copy constructor
else
    myClassPtr->m_yourClass1->operator=(temporary); // assignment operator
delete temporary;

// , m_yourClass2( 2 )
myClassPtr->m_yourClass2->YourClass(2);

走一遍下面的步骤

Bow("red");

Bow red("red");

Bow red = Bow("red");

Bow redbow("red"); Bow red(redbow);

如果你得到了这些，但仍在挣扎

red(Bow("red"))

那么这将是一个学习不要给成员变量起模棱两可的名字的好时机，因为这些名字不能将它们与局部变量区分开来，例如

class ArcheryCompetition
{
...
    int m_rounds;
    Bow m_red;
    Bow m_blue;
...

    ArcheryCompetition(int rounds_) // distinguish parameters from local variables too
        : m_rounds(rounds_)
        , m_red(Bow("red"))
        , m_blue(Bow("blue"))
        ...
    {}
...
};

在构造函数声明之后，“：”语法表示一个“初始值设定项列表”，在这里初始化类的成员-其中初始化意味着构造。这基本上是一种说“当我被构造时，这就是我的成员应该被构造的方式”-所以你完全正确地认为其他c