Question

我看到了这段代码

fun(std::array<int, 4ul> const&, std::array<int, 4ul> const&):
  mov ecx, DWORD PTR [rdi]
  cmp DWORD PTR [rsi], ecx
  lea rdx, [rsi+16]
  lea rax, [rdi+16]
  jg .L32
  jl .L31
.L25:
  add rdi, 4
  add rsi, 4
  cmp rax, rdi
  je .L36
  mov ecx, DWORD PTR [rsi]
  cmp DWORD PTR [rdi], ecx
  jl .L32
  jle .L25
.L31:
  xor eax, eax
  ret
.L32:
  mov eax, 1
  ret
.L36:
  cmp rdx, rsi
  setne al
  ret

fun(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
  mov edx, DWORD PTR [rsi+12]
  cmp DWORD PTR [rdi+12], edx
  mov eax, 1
  jl .L11
  mov eax, 0
  jg .L11
  mov ecx, DWORD PTR [rsi+8]
  cmp DWORD PTR [rdi+8], ecx
  mov eax, 1
  jl .L11
  mov eax, 0
  jg .L11
  mov ecx, DWORD PTR [rsi+4]
  cmp DWORD PTR [rdi+4], ecx
  mov eax, 1
  jl .L11
  mov eax, 0
  jg .L11
  mov eax, DWORD PTR [rsi]
  cmp DWORD PTR [rdi], eax
  setl al
.L11:
  rep ret

我猜测class Foo { public: int x; double y; float z; Foo(int x, double y, float z) // XXX: What are the following doing? : x(x), y(y), z(z) {} }从参数中为成员（:，x，y）分配值后所写的内容。< / p>

问题1：为什么这样而不是以下？

问题2：在原始样式中，编译器如何将成员Foo(int x, double y, float z) { this->x = x; this->y = y; this->z = z; }与参数x区分开来？（在我修改的代码片段中，限定符x用于此目的）

例如，如果我写这个：

this

Answer 1

你猜错了。这些是成员初始化列表。这比在构造函数中直接赋值更受欢迎的原因是因为const类成员，没有默认构造函数的类和引用变量是必需的。例如：

class A
{
    int b;
public:
    A(int c) : b(c) {}; // No default constructor
};

class Test
{
    A a;         // A class with no default constructor
    const int x; // A constant
    int& r;      // A reference
public:
    Test(int d) : a(5), x(2), r(d) {};
};

int main()
{
    Test test;
}

在此示例中，类a的成员x和Test都无法分配，因为第一个没有默认构造函数，而后者是常量，这意味着赋值给它创建一个错误。最后，由于无法分配引用变量，因此需要初始化列表。

最后，主要区别在于初始化列表初始化变量（谁知道？），而构造函数中的赋值是在这些成员变量之后完成的。已被称为构造函数。

关于你的第二个问题，你can see for yourself在初始化期间在成员变量之前选择了参数。

C ++中的构造函数和成员init语法

1 个答案: