析构 构造 赋值

拷贝构造(Copy contructor)
由己存在的对象，创建新对象。也就是说新对象，不由构造器来构造，而是由拷贝构
造器来完成。拷贝构造器的格式是固定的。
class 类名
{
类名(const 类名 & another)
拷贝构造体
}
class A
{
A(const A & another)
{}

}

1 系统提供默认的拷贝构造器。一经实现，不复存在。
2 系统提供的时等位拷贝，也就是所谓的浅浅的拷贝。
3 要实现深拷贝，必须要自定义。

 深拷贝与浅拷贝
系统提供默认的拷贝构造器，一经定义不再提供。但系统提供的默认拷贝构造器是等
位拷贝，也就是通常意义上的浅拷贝。如果类中包含的数据元素全部在栈上，浅拷贝也可
以满足需求的。但如果堆上的数据，则会发生多次析构行为。

 this 
系统在创建对象时，默认生成的指向当前对象的指针。这样作的目的，就是为了带来
方便。
1，避免构造器的入参与成员名相同。
2，基于 this 指针的自身引用还被广泛地应用于那些支持多重串联调用的函数中。
比如连续赋值。
3.this 指针是 const 类型的

赋值运算符重载(Operator=)
class A
{
A& operator=(const A& another)
{
//函数体
return *this;
}
};
返回栈对象的引用，多用于产生串联应用。比如连等式。 栈对象是不可以返回引用的。
除非，函数的调用者返回自身对象。
class A
{
public:
A(){}
A(const A &a)
{
cout<<"cp contructor"<<endl;
}
};
1 系统提供默认的赋值运算符重载，一经实现，不复存在。
2 系统提供的也是等位拷贝，也就浅拷贝，一个内存泄漏，重析构。
3 要实再深深的赋值，必须自定义。
4 自定义面临的问题有三个：
1，自赋值
2，内存泄漏
3，重析构。
5 返回引用，且不能用 const 修饰。其目的是实现连等式。

MyString & MyString::operator=(const MyString & another)
{
if(this == &another)
return *this;
else
{
delete []this->_str;
int len = strlen(another._str);
this->_str = new char[len+1];
strcpy(this->_str,another._str);
return *this;
}
}
 返回栈上引用与对象
返回栈对象
class A
{
public:
A(){}
A(const A &a)
{
cout<<"cp contructor"<<endl;
}
};
a 传值：发生拷贝
void foo(A a)
{}
int main()
{
A a;
foo(a);
return 0;
}
b 传引用 没有发生拷贝
void foo(A& a)
{}
int main()
{
A a;
foo(a);
return 0;
}
c 返回对象
A foo(A& a)
{
return a;
}
int main()
{
A a;
foo(a);
return 0;
}

返回栈对象引用
返回栈对象的引用，多用于产生串联应用。比如连等式。 栈对象是不可以返回引用的。
除非，函数的调用者返回自身对象。
MyString & MyString::operator=(const MyString & another)
{
if(this == &another)
return *this;
else
{
delete []this->_str;
int len = strlen(another._str);
this->_str = new char[len+1];
strcpy(this->_str,another._str);
return *this;
}
}