在这个线程中还没有提到:从c++ 11开始，成员初始化器列表可以使用list-initialization(又名list-initialization)。“统一初始化”，“带括号初始化”):

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

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

什么是冒号语法(:)在类构造函数和什么传递一个整数std::vector<>构造函数做?

我想解释下面这个重复问题的例子:

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);
    }

冒号(:)表示“初始化列表”或“初始化列表”的开始，它将每个变量初始化为括号中的值。这就好像你在为每个变量调用一个构造函数，将括号中的值传递给该变量的构造函数。

因此，:root(sz)用一个int值sz初始化根变量，这就像执行vector<int> root(sz);。但是，这样做可以将sz传递给UnionFind类构造函数。

用这样的大小初始化一个向量是构造函数#3 (https://en.cppreference.com/w/cpp/container/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>的向量。int()看起来像一个函数调用，但实际上是一个值为0(0)的整数默认构造函数。它被称为“值初始化”。把它想象成调用“整数构造函数”，如果整数是对象并且有构造函数的话。在这里也可以看到我的问题:在c++中调用char()作为函数是什么?

所以，让我们回顾一下::root(sz)在构造函数中就像构造vector<int> root(sz);，它在根向量中创建了sz个元素，每个元素的初始值都是int()，这是将int值初始化为0的语法。

还要注意，上面显示的传递给构造函数#3的count参数实际上应该是一个size_type，可以写成std::vector::size_type，通常是size_t(请参阅这里的“成员类型”部分)。因此，将int sz改为size_t sz会更好。因此，将构造函数line: UnionFind(int sz): root(sz){改为:UnionFind(size_t sz): root(sz){。

还有一个“好处”

如果成员变量类型不支持空初始化，或者它是一个引用(不能被空初始化)，那么你别无选择，只能提供一个初始化列表

Foo(int num): bar(num)    

这个构造在c++中称为成员初始化器列表。

简单地说，它将你的成员栏初始化为值num。

---

构造函数中的初始化和赋值有什么区别?

成员初始化:

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

成员的任务:

Foo(int num)
{
   bar = num;
}

使用成员初始化列表初始化成员与在构造函数体中为其赋值之间存在显著差异。

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

如果使用赋值，则字段将首先用默认构造函数初始化，然后用实际值重新赋值(通过赋值操作符)。

正如你所看到的，后者有一个额外的创建和赋值开销，这对于用户定义的类来说可能是相当大的。

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没有默认构造函数，因此需要使用成员初始化列表来初始化它的成员。

---

在使用成员初始化列表时需要注意的要点:

类成员变量总是按照它们在类中声明的顺序进行初始化。

它们没有按照在成员初始化列表中指定的顺序进行初始化。 简而言之，成员初始化列表并不决定初始化的顺序。

综上所述，保持与类定义中声明成员的顺序相同的成员初始化顺序始终是一种良好的实践。这是因为编译器不会在两个顺序不同时发出警告，但相对较新的用户可能会将成员Initializer列表误认为初始化顺序，并据此编写一些代码。

在这个线程中还没有提到:从c++ 11开始，成员初始化器列表可以使用list-initialization(又名list-initialization)。“统一初始化”，“带括号初始化”):

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

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

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

考虑以下两个例子:

// 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

这都是效率问题。