与类的成员复制混淆 研究C++中的成员复制和赋值运算符后，P> 并查看“”以解释无法生成默认赋值运算符的条件。我对这些概念不是很清楚，因为我尝试的以下示例实际上适用于g++4.5 #include<iostream> using namespace std; class Y{ int& x; const int cx; public: Y(int v1,int v2) :x(v1),cx(v2) {} int getx(){return x;} int getcx(){return cx;} }; int main() { int a = 10; Y y1(a,a); Y y2 = y1;//assignment cout<<y1.getx()<<" "<<y1.getcx(); return 0; } #包括 使用名称空间std； Y类{ int&x； 常数int cx； 公众： Y（整数v1，整数v2） ：x（v1），cx（v2） {} int getx（）{return x；} int getcx（）{return cx；} }; int main（） { INTA=10； yy1（a，a）； Y y2=y1；//赋值 cout

yy2=y1；

不是赋值。它是一个复制构造函数调用。如果在同一行上声明并初始化一个变量，则会调用一个单参数构造函数，其参数为等号的右侧。

Y

中没有任何内容会阻止实例化默认的复制构造函数（并打电话）

请尝试以下操作：

Y y1(10, 10);
Y y2(11, 11);
y2 = y1;

---

这应该会失败，尽管我现在无法测试它。

yy2=y1；

不是赋值。它是一个复制构造函数调用。如果在同一行上声明并初始化一个变量，则会调用一个单参数构造函数，并将等号的右侧作为参数。

Y

中没有任何东西可以阻止它从实例化（和调用）开始的默认副本构造函数

class Y{
  int& x;

  public:
  Y(int v1,int v2)
    :x(v1),cx(v2)
  {} // v1 ceases to exist from this point
};

请尝试以下操作：

Y y1(10, 10);
Y y2(11, 11);
y2 = y1;

这应该会失败，尽管我现在不能测试它

class Y{
  int& x;

  public:
  Y(int v1,int v2)
    :x(v1),cx(v2)
  {} // v1 ceases to exist from this point
};

x

是int的一个参考变量。现在您将它初始化为

v1

，这意味着

x

是

v1

本身的别名。

v1

的范围仅在构造函数中。因此-

 Y y2 = y1;//assignment => Not assignment. It is initialization.

相当于

 Y y2(y1);  // compiler is looking for the overloaded constructor ( ie. copy constructor in this case ).

 class Y{
      public:
       Y ( const Y & other ); // copy constructor
       // ...
 };

x

是int的一个参考变量。现在您将它初始化为

v1

，这意味着

x

是

v1

本身的别名。

v1

的范围仅在构造函数中。因此-

 Y y2 = y1;//assignment => Not assignment. It is initialization.

相当于

 Y y2(y1);  // compiler is looking for the overloaded constructor ( ie. copy constructor in this case ).

 class Y{
      public:
       Y ( const Y & other ); // copy constructor
       // ...
 };

---

您的类包含无法默认构造或分配的成员，即：

• 参考资料

• 常数

因此，您的类不能隐含任何默认构造函数或赋值运算符。例如，您必须编写自己的构造函数：

class Foo
{
  const int a;
  int     & b;
public:
  Foo(int val, int & modify_me) :
    a(val) ,      // initialize the constant
    b(modify_me)  // bind the reference
  { }
};

很明显，您不能默认构造

Foo

（即

Foo x；

）。也很明显，您不能重新分配类

Foo

（即

x=y；

）的对象，因为您不能重新分配引用或常量

通过给类提供一个引用或常量成员，实际上可以给类本身提供引用或常量语义（如果愿意的话），因此这应该是一个相当直接的逻辑结果。例如，重新分配在语义上可能根本没有意义，因为类应该包含常量概念

但是，请注意，可以复制类：这是因为您可以“复制”引用（即furhter别名）和常量的副本。因此，复制构造函数是隐式可用的，只需逐个成员应用复制构造成员。因此，您可以说：

---

这将导致另外两个对象

y

和

z

，它们的

y.a==15

和

z.a==15

，以及

y.b

和

z.b

都是对

n

的引用（不要在末尾使用两个可选语法；它们都调用复制构造函数）

您的类包含无法默认构造或分配的成员，即：

• 参考资料

• 常数

因此，您的类不能隐含任何默认构造函数或赋值运算符。例如，您必须编写自己的构造函数：

class Foo
{
  const int a;
  int     & b;
public:
  Foo(int val, int & modify_me) :
    a(val) ,      // initialize the constant
    b(modify_me)  // bind the reference
  { }
};

很明显，您不能默认构造

Foo

（即

Foo x；

）。也很明显，您不能重新分配类

Foo

（即

x=y；

）的对象，因为您不能重新分配引用或常量

通过给类提供一个引用或常量成员，实际上可以给类本身提供引用或常量语义（如果愿意的话），因此这应该是一个相当直接的逻辑结果。例如，重新分配在语义上可能根本没有意义，因为类应该包含常量概念

但是，请注意，可以复制类：这是因为您可以“复制”引用（即furhter别名）和常量的副本。因此，复制构造函数是隐式可用的，只需逐个成员应用复制构造成员。因此，您可以说：

这将导致另外两个对象

y

和

z

，它们的

y.a==15

和

z.a==15

，以及

y.b

和

z.b

都是对

n

的引用（不要在末尾使用两个可选语法；它们都调用复制构造函数）。

\
使用名称空间std；
Y类{
int&x；
常数int cx；
公众：
Y（整数v1，整数v2）
：x（v1），cx（v2）
{}
int getx（）{return x；}
int getcx（）{return cx；}
};
int main（）
{
INTA=10；
yy1（a，a）；
Y y2=y1；//未赋值。对象尚未构造，因此调用复制c'tor
y2=y1；//调用赋值运算符
不能包含
使用名称空间std；
Y类{
int&x；
常数int cx；
公众：
Y（整数v1，整数v2）
：x（v1），cx（v2）
{}
int getx（）{return x；}
int getcx（）{return cx；}
};
int main（）
{
INTA=10；
yy1（a，a）；
Y y2=y1；//未赋值。对象尚未构造，因此调用复制c'tor
y2=y1；//调用赋值运算符
请注意，
yy2=y1；
不是赋值，而是复制构造。请注意，
yy2=y1；
不是赋值，而是复制构造。谢谢…声明yy2（a，b）；y2=y1；给出了我想看到的错误消息。谢谢…声明y2（a，b）；y2=y1；