C++中 “=”重载的问题

[我在关山口开摇摇车]

有class A；
对象 b
如何重载
A a1 = b中的“=”

[蠓虫带着秤砣飞]

operator+= (const classA & b)

[我在关山口开摇摇车]

引用 1 楼 zjq9931 的回复:

operator+= (const classA & b)

我还是不太清楚，首先这个我感觉是重载了 “+=”； 然后我按照你这个写了

MyArry& MyArry::operator+=(const MyArry& arry2) {
	if (this==&arry2)
	{
		return *this;
	}
	if (this->space!=NULL)
	{
		delete[] this->space;
		this->space = NULL;
	}
	delete[] this->space;
	this->space = new  int[arry2.len];
	this->len = arry2.len;
	memcpy(this->space, arry2.space, arry2.len);
	return *this;
}

还是不行呀

[abcd7038]

引用 2 楼 我在关山口开摇摇车 的回复:

[quote=引用 1 楼 zjq9931 的回复:] operator+= (const classA & b)

我还是不太清楚，首先这个我感觉是重载了 “+=”； 然后我按照你这个写了

MyArry& MyArry::operator+=(const MyArry& arry2) {
	if (this==&arry2)
	{
		return *this;
	}
	if (this->space!=NULL)
	{
		delete[] this->space;
		this->space = NULL;
	}
	delete[] this->space;
	this->space = new  int[arry2.len];
	this->len = arry2.len;
	memcpy(this->space, arry2.space, arry2.len);
	return *this;
}

还是不行呀 [/quote] 他这个弄错了，应该是

 Myarry& Myarry::operator=(const Myarry&);

[我在关山口开摇摇车]

引用 3 楼 abcd7038 的回复:

[quote=引用 2 楼 我在关山口开摇摇车 的回复:] [quote=引用 1 楼 zjq9931 的回复:] operator+= (const classA & b)

我还是不太清楚，首先这个我感觉是重载了 “+=”； 然后我按照你这个写了

MyArry& MyArry::operator+=(const MyArry& arry2) {
	if (this==&arry2)
	{
		return *this;
	}
	if (this->space!=NULL)
	{
		delete[] this->space;
		this->space = NULL;
	}
	delete[] this->space;
	this->space = new  int[arry2.len];
	this->len = arry2.len;
	memcpy(this->space, arry2.space, arry2.len);
	return *this;
}

还是不行呀 [/quote] 他这个弄错了，应该是

 Myarry& Myarry::operator=(const Myarry&);

[/quote] 你这个是对

	MyArry arry5;
	arry5 = arry4;

用的。 MyArry arry4 = *arry1;还是调用的拷贝构造方法。不是重载的“=”

[蠓虫带着秤砣飞]

引用 2 楼 我在关山口开摇摇车 的回复:

我还是不太清楚，首先这个我感觉是重载了 “+=”；
然后我按照你这个写了
还是不行呀

确实是我搞错了。
看后面的回复已经解决了，挺好的。

[千梦一生]

A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

[我在关山口开摇摇车]

引用 6 楼 千梦一生的回复:

A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

受教了，原来如此。

[我在关山口开摇摇车]

引用 6 楼 千梦一生的回复:

A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

受教了，原来如此。

[千梦一生]

引用 6 楼 千梦一生 的回复:

A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

刚刚因为好奇一个事情去写了一下这个代码。
结果是A a1 = b这种，当拷贝构造函数被delete后，将报错。
因为当时想到了一个情况：
A* p = null;
p->function();
这样的时候，虽然p神马也不是，但仍然可以调用function。
所以同类推测，理说a1也可以调用=重载function啊。
------------------------
不过在打这几行字的时候，或许又想到了解释的理由：虽然这p看上去神马也不是，但p是实实在在已经被定义好的一个变量，这里与a1=b中的a1是不相同的

[我在关山口开摇摇车]

引用 9 楼 千梦一生 的回复:

[quote=引用 6 楼 千梦一生 的回复:] A b;//默认构造 A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】 ----------------------------------------------------------------------------------------------------- 如果是： A b;//默认构造 A a1;//默认构造 a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

刚刚因为好奇一个事情去写了一下这个代码。 结果是A a1 = b这种，当拷贝构造函数被delete后，将报错。 因为当时想到了一个情况： A* p = null; p->function(); 这样的时候，虽然p神马也不是，但仍然可以调用function。 所以同类推测，理说a1也可以调用=重载function啊。 ------------------------ 不过在打这几行字的时候，或许又想到了解释的理由：虽然这p看上去神马也不是，但p是实实在在已经被定义好的一个变量，这里与a1=b中的a1是不相同的[/quote] 按照你的思路，我觉得是这样的。：

MyArry& MyArry::operator=(const MyArry& arry2)

有两个参数，都是MyArry类型对象。 A a1 = b;中，在执行的时候，a1什么也不是，它还不是一个A类型的对象，所以不符合operator=。delete a1时调用了析构函数，那是因为执行完 A a1 = b；后， a1 是一个 A类型对象；而 A* p = NULL；p本身是存在的，所以可以调用funcion，如果不出意外的话 *p.function()应该会出错。

[千梦一生]

非常的复杂。不过确实不行是的了。报的错也看不懂

[千梦一生]

引用 10 楼 我在关山口开摇摇车 的回复:

[quote=引用 9 楼 千梦一生 的回复:]
[quote=引用 6 楼 千梦一生 的回复:]
A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

刚刚因为好奇一个事情去写了一下这个代码。
结果是A a1 = b这种，当拷贝构造函数被delete后，将报错。
因为当时想到了一个情况：
A* p = null;
p->function();
这样的时候，虽然p神马也不是，但仍然可以调用function。
所以同类推测，理说a1也可以调用=重载function啊。
------------------------
不过在打这几行字的时候，或许又想到了解释的理由：虽然这p看上去神马也不是，但p是实实在在已经被定义好的一个变量，这里与a1=b中的a1是不相同的[/quote]

按照你的思路，我觉得是这样的。：

MyArry& MyArry::operator=(const MyArry& arry2)

有两个参数，都是MyArry类型对象。 A a1 = b;中，在执行的时候，a1什么也不是，它还不是一个A类型的对象，所以不符合operator=。delete a1时调用了析构函数，那是因为执行完 A a1 = b；后， a1 是一个 A类型对象；而 A* p = NULL；p本身是存在的，所以可以调用funcion，如果不出意外的话 *p.function()应该会出错。[/quote]
*p.function()会出错的原因是因为对null进行了非法访问。
但是当p指针在一个其它区域，是可以*p.function()调用的
DOUBLE* d = NULL;
d = (DOUBLE*)0x34567;
(*d).function();

[千梦一生]

引用 12 楼 千梦一生 的回复:

[quote=引用 10 楼 我在关山口开摇摇车 的回复:]
[quote=引用 9 楼 千梦一生 的回复:]
[quote=引用 6 楼 千梦一生 的回复:]
A b;//默认构造
A a1 = b;//是隐式调用符合参数的构造函数。因为此a1仅被声明而未定义。则后面接的等号，会尝试找到符合对应类型的单参数构造函数【至于如果找不到会不会报错就不得而知了，可能会吧，也可能找不到就去找=重载，没测试，楼主可以测试一会看看结果】
-----------------------------------------------------------------------------------------------------
如果是：
A b;//默认构造
A a1;//默认构造
a1 = b;//此时a1已经被成功构造过了，所以，这里调用=重载

刚刚因为好奇一个事情去写了一下这个代码。
结果是A a1 = b这种，当拷贝构造函数被delete后，将报错。
因为当时想到了一个情况：
A* p = null;
p->function();
这样的时候，虽然p神马也不是，但仍然可以调用function。
所以同类推测，理说a1也可以调用=重载function啊。
------------------------
不过在打这几行字的时候，或许又想到了解释的理由：虽然这p看上去神马也不是，但p是实实在在已经被定义好的一个变量，这里与a1=b中的a1是不相同的[/quote]

按照你的思路，我觉得是这样的。：

MyArry& MyArry::operator=(const MyArry& arry2)

有两个参数，都是MyArry类型对象。 A a1 = b;中，在执行的时候，a1什么也不是，它还不是一个A类型的对象，所以不符合operator=。delete a1时调用了析构函数，那是因为执行完 A a1 = b；后， a1 是一个 A类型对象；而 A* p = NULL；p本身是存在的，所以可以调用funcion，如果不出意外的话 *p.function()应该会出错。[/quote]
*p.function()会出错的原因是因为对null进行了非法访问。
但是当p指针在一个其它区域，是可以*p.function()调用的
DOUBLE* d = NULL;
d = (DOUBLE*)0x34567;
(*d).function();[/quote]
更正一下：*p.function()只要不读写0~255区域数据即不会报错。
所以直接：
DOUBLE* d = NULL;
（*d）.function();
是没问题的