构造函数中的这个怪异的结肠成员（“：”）语法是什么？

Question

最近，我看到了以下示例：

#include <iostream>

class Foo {
public:
  int bar;
  Foo(int num): bar(num) {};
};

int main(void) {
  std::cout << Foo(42).bar << std::endl;
  return 0;
}

这个奇怪的：bar（num）是什么意思？它似乎以某种方式初始化了数据成员，但是我以前从未见过此语法。它看起来像函数/构造函数调用，但对于int。这对我没有意义。

还有其他像这样的深奥语言功能，您在普通的C ++书中永远不会找到吗？

Answer 1

Foo(int num): bar(num)    

该构造在C ++中称为成员初始化器列表。

简而言之，它初始化您的成员bar to value num。

---

构造函数内的初始化和分配有什么区别？

成员初始化：

Foo(int num): bar(num) {};

成员分配：

Foo(int num)
{
   bar = num;
}

使用成员初始化器列表初始化成员和在构造体主体内部分配值之间存在显着差异。

当您 初始化 通过成员初始化器列表列表将调用一次构造函数，并且将在一个操作中构造和初始化对象。

如果您使用 分配 ，则将首先使用默认构造函数初始化字段，然后用实际值重新分配（通过分配运算符）。

如您所见，还有一个额外的创作开销＆amp;后者的作业，对于用户定义的类可能很大。

Cost of Member Initialization = Object Construction 
Cost of Member Assignment = Object Construction + Assignment

后者实际上等同于：

Foo(int num) : bar() {bar = num;}

虽然前者相当于：

Foo(int num): bar(num){}

对于内置的（您的代码示例）或POD类成员，但没有实际的开销。

---

您什么时候必须使用成员初始化列表？

您将有（而不是强制）使用成员初始化器列表，如果

• 您的类有参考成员
• ，您的类具有非静态const成员，或
• 您的类成员没有默认构造函数或
• 用于初始化基类成员或
• 构造函数的参数名称与数据成员相同时（这不是一个必须的）

---

代码示例：

class MyClass {
public:
  // Reference member, has to be Initialized in Member Initializer List
  int &i;
  int b;
  // Non static const member, must be Initialized in Member Initializer List
  const int k;

  // Constructor’s parameter name b is same as class data member
  // Other way is to use this->b to refer to data member
  MyClass(int a, int b, int c) : i(a), b(b), k(c) {
    // Without Member Initializer
    // this->b = b;
  }
};

class MyClass2 : public MyClass {
public:
  int p;
  int q;
  MyClass2(int x, int y, int z, int l, int m) : MyClass(x, y, z), p(l), q(m) {}
};

int main() {
  int x = 10;
  int y = 20;
  int z = 30;
  MyClass obj(x, y, z);

  int l = 40;
  int m = 50;
  MyClass2 obj2(x, y, z, l, m);

  return 0;
}

• myClass2没有默认构造函数，因此必须通过成员初始初始化来初始化它列表。
• 基类myClass没有默认的构造函数，因此要初始化其成员，需要使用成员初始化器列表。

---

使用成员初始化器列表时要注意的要点：

类成员变量始终以班级声明的顺序初始化。

它们是 note 在它们在成员初始化列表中指定的。
简而言之，成员初始化列表不能确定初始化的顺序。

鉴于以上始终是一个好习惯，即保持成员初始化的成员初始化的顺序与班级定义中声明的顺序相同。这是因为编译器不会警告两个订单是否不同，但是相对较新的用户可能会将成员初始化器列表作为初始化的顺序混淆，并编写一些与此有关的代码。

Answer 2

它是成员初始化列表。您应该在任何好C ++书籍中找到有关它的信息。

在大多数情况下，您应该在成员初始化列表中初始化所有成员对象（（但是，请注意，在常见问题解答条目末尾列出的例外）。

常见问题解答条目的要点是，

所有其他内容均等，如果您使用初始化列表而不是分配，则您的代码将更快地运行。

Answer 3

那是构造函数初始化。这是在类构造函数中初始化成员的正确方法，因为它可以防止调用默认的构造函数。

考虑以下两个示例：

// Example 1
Foo(Bar b)
{
   bar = b;
}

// Example 2
Foo(Bar b)
   : bar(b)
{
}

在示例1中：

Bar bar;  // default constructor
bar = b;  // assignment

在示例2中：

Bar bar(b) // copy constructor

这全都与效率有关。

Answer 4

这称为初始化列表。这是一种初始化班级成员的方式。使用它是有好处的，而不是简单地为构造函数的主体中的成员分配新值，但是如果您的类成员是 startants 或参考>必须初始化。

Answer 5

这并不晦涩，是 c ++初始化列表styntax

基本上，在您的情况下，在您的情况下，在您的情况下，x将用_x，y _y，z with 代码> _z。

Answer 6

另一个已经向您解释说，您观察到的语法称为“构造函数初始化器列表”。该语法使您可以自定义类的基础子对象和类的成员子对象（而不是允许它们默认initialize或保持非初始化）。

我只想注意到，正如您所说，“看起来像构造函数调用”的语法不一定是构造函数调用。在C ++语言中，（）语法只是初始化语法的一种标准形式。对于不同类型的解释方式有所不同。对于具有用户定义的构造函数的类类型，这意味着一件事（确实是构造函数调用），对于没有用户定义的构造函数的类类型，这意味着另一件事（so so称为 value初始化 ）formeet （））和对于非类型类型，这再次意味着不同的东西（因为非类型没有构造函数）。

在您的情况下，数据成员具有类型int。 int不是类型，因此它没有构造函数。对于类型int，本语法简单地表示“初始化bar具有num的值”，仅此而已。它是这样的，直接直接涉及构造函数，因为int再次不是类型的类型，因此它不能具有任何构造函数。

Answer 7

我不知道你怎么会错过这个，这是很基本的。这是初始化成员变量或基类构造函数的语法。它适用于普通的旧数据类型以及类对象。

Answer 8

这是一个初始化列表。它将在运行构造函数之前初始化成员。
在第一个示例中考虑

class Foo {
 public:
   string str;
   Foo(string &p)
   {
      str = p;
   };
 };

VS

class Foo {
public:
  string str;
  Foo(string &p): str(p) {};
};

将通过其无折磨构造函数初始化STR

string();

，在Foo构造函数的主体之前， 。在foo构造函数内部，

string& operator=( const string& s );

将在“ str” = p时被称为“ str”。

在第二个示例中，str将直接通过
将其构造

string( const string& s );

函数称为“ P”。

Answer 9

您是正确的，这确实是初始化成员变量的一种方式。除了清楚地表明这是一个初始化之外，我不确定这是否有很多好处。在代码中具有“ bar = num”，可以更轻松地移动，删除或误解。

Answer 10

还有另一个“好处”

如果成员变量类型不支持null初始化或它的参考（不能null初始化），那么您别无选择，只能提供初始化列表，

Answer 11

这是构造函数的初始化列表。而不是默认构造x，y和z，然后分配它们在参数中收到的值，而是将这些成员用这些值初始化放下蝙蝠。对于float s来说，这似乎并不是很有用，但是它的定制类构造昂贵，这可能是一个延时的时间。

Answer 12

该线程尚未提及：由于C ++ 11，成员初始化器列表可以使用列表限制（又称“统一初始化”，“ Brad Initialition”）：

Foo(int num): bar{num} {}

它具有与其他上下文中列表initialization相同的语义。

Answer 13

尽管这是一个古老的讨论，但我找不到有关委托构造师，使用以下方式使用怪异的“：”符号。

class Foo 
{
public: 
    Foo(char x, int y) 
    {}
    Foo(int y) : Foo('a', y) 
    {}
};

它的作用只是简单地将foo（y）授予foo（'a'，y）。因此，

Foo foo(15); //=> foo('a', 15)

在定义委派构造函数时，除了目标构造函数以外，您在初始化器列表中不能有任何成员。

Answer 14

类构造函数中的结肠语法（：）是什么？将整数传递到std :: vector＆lt;＆gt; constructor do的是什么？

我想从

class UnionFind {
    public:
        UnionFind(int sz) : root(sz) {
            for (int i = 0; i < sz; i++) {
                root[i] = i;
            }
        }
    private:
        vector<int> root;
    };
    
    
    int main() {
        
       
        UnionFind uf(10);
    }

。表示“初始化列表”的开始，或“ noreferrer”>“ initializer list” ，，，，，将每个变量初始化为括号中的值。好像您正在调用每个变量的构造函数，而该值将传递给该变量的构造函数。

因此，：root（sz）用root变量以int sz初始化，就像做vector＆lt; int＆gt; root（sz）;。但是，这样做允许sz可以传递到unionfind类构造函数。

在此处初始化具有类似大小的向量的构造函数＃3（ https：// https：/// en.cppreference.com/w/cpp/container/vector/Vector/Vector ）：

// Constructor (3) as shown at
// https://en.cppreference.com/w/cpp/container/vector/vector
explicit vector( size_type count,
                 const T& value = T(),
                 const Allocator& alloc = Allocator());

它构造count（SZ在上面的示例中）向量，每个都带有值t（），在这种情况下为int（） /代码>。 int（）看起来像一个函数调用，但基本上是一个整数默认构造函数值零（0）。它称为“值初始化” 。如果整数是对象并且具有构造函数，则可以将其视为称为“整数构造函数”。另请参阅我的问题： to char> char（）是C ++中的函数？

因此，让我们回顾一下：：构造函数中的root（sz）就像构造vector＆lt; int＆gt; root（sz）;，它创建sz root vector中的元素数，每个元素都具有初始值int（int> int（），这是零。

还要注意，count传递给构造函数＃3的参数确实应该是size_type，可以写为std :: vector :: size_type ，通常为size_t（请参阅“成员类型”部分在这里）。因此，最好将int sz更改为size_t sz。因此，将此构造函数线更改：unionFind（int sz）：root（sz）{ this：unionfind（size_t sz）：root（sz）{。