拷贝构造器
由己存在的对象，创建新对象。也就是说新对象，不由构造器来构造，而是由拷贝构造器来完成。拷贝构造器的格式是固定的。
class 类名
{
类名(const 类名 & another)
拷贝构造体
}
class A
{
A(const A & another)
{}
}规则：
1 系统提供默认的拷贝构造器。一经实现，不复存在。
2 系统提供的时等位拷贝，也就是所谓的浅浅的拷贝。
3 要实现深拷贝，必须要自定义。
4 浅拷贝，会导致内存重析构。linux下浅拷贝会挂机。double free,在有些情况下(含有堆空间的时候)，要实现自拷贝构造
#include <iostream>
#include "mystring.h"
using namespace std;
int main()
{
string s = "assassin";
string ss(s);
cout<<"++++++++++++++++"<<endl;
cout<<ss<<endl;
cout<<"++++++++++++++++"<<endl;
mystring s1 = "intelwisd";
mystring ss1(s1);//浅复制，两个对象指向同一个地址空间，释放对象的时候释放了两次对象所指向的地址空间。
cout<<"++++++++++++++++"<<endl;
cout<<ss1.c_str()<<endl;
cout<<"++++++++++++++++"<<endl;
string sss = s;
mystring sss1 = s1;//也可以实现，本质也是拷贝，用已有一个对象完成一个对象，从无到有的创建过程。
string ssss;
ssss = s;
mystring ssss1;
ssss1 = s1;//默认的也可以，本质是赋值运算符重载---> this指针。
return 0;
}#ifndef MYSTRING_H
#define MYSTRING_H
class mystring
{
public:
//mystring();
mystring(const char *s = NULL);//无参的形式包含在里面
char * c_str();
mystring(const mystring & another);
~mystring();
private:
char * _str;
};
#endif // MYSTRING_H#include<iostream>
#include "mystring.h"
#include "string.h"
using namespace std;
mystring::mystring(const char *s)
{
if(s == NULL)
{
_str = new char[1];
*_str = ‘\0‘;
}else{
int len = strlen(s);
_str = new char[len+1];
strcpy(_str,s);
}
}
char * mystring::c_str()
{
return _str;
}
mystring::mystring(const mystring & another)
{
//_str = another._str;//同类之间没有隐私，这样的浅复制会造成内存重析构。
int len = strlen(another._str);
_str = new char[len+1];
strcpy(_str,another._str);
}
mystring::~mystring()
{
delete []_str;
}this 指针
系统在创建对象时，默认生成的指向当前对象的指针。这样作的目的，就是为了带来方便。
作用
1，避免构造器的入参与成员名相同。
2，基于 this 指针的自身引用还被广泛地应用于那些支持多重串联调用的函数中。
class Stu
{
public:
Stu(string name,int age)
{
this->name = name;
this->age = age;
}
void display()
{
cout<<name<<"+++"<<age<<endl;
}
Stu & growUp()
{
this->age++;
return *this;
}
private:
string name;
int age;
}
int main()
{
Stu s("assassin",23);
dout<<"&s:"<<&s<<endl;
s.display();
s.growUp().growUp().growUp().growUp().display();//年龄增加
return 0;
}赋值运算符重载(Operator=)
用一个己有对象，给另外一个己有对象赋值。两个对象均己创建结束后，发生的赋值行为。
格式：
类名
{
类名& operator=(const 类名& 源对象)
拷贝体
}
class A
{
A& operator=(const A& another)
{
//函数体
return *this;
}
};规则:
1 系统提供默认的赋值运算符重载，一经实现，不复存在。
2 系统提供的也是等位拷贝，也就浅拷贝，会造成内存泄漏，重析构。
3 要实现深深的赋值，必须自定义。
4 自定义面临的问题有三个：1，自赋值
2，内存泄漏
3，重析构。
5 返回引用，且不能用 const 修饰。a = b = c => (a+b) = c
mystring & mystring::operator=(const mystring & another)
{
if(this == &another)//复制自己的情况
return *this;
delete []this->_str;//先把自己的释放掉
int len = strlen(another._str);
this->_str = new char [len+1];
strcpy(this->_str,another._str);
return *this;
}完整代码：
#include<iostream>
#include "mystring.h"
#include "string.h"
using namespace std;
mystring::mystring(const char *s)
{
if(s == NULL)
{
_str = new char[1];
*_str = ‘\0‘;
}else{
int len = strlen(s);
_str = new char[len+1];
strcpy(_str,s);
}
}
char * mystring::c_str()
{
return _str;
}
mystring::mystring(const mystring & another)
{
//_str = another._str;//同类之间没有隐私，这样的浅复制会造成内存重析构。
int len = strlen(another._str);
_str = new char[len+1];
strcpy(_str,another._str);
}
mystring::~mystring()
{
delete []_str;
}
mystring& mystring:: operator=(const mystring & another)
{
if(this == &another)//复制自己的情况
return *this;
delete []this->_str;//先把自己的释放掉
int len = strlen(another._str);
this->_str = new char [len+1];
strcpy(this->_str,another._str);
return *this;
}#ifndef MYSTRING_H
#define MYSTRING_H
class mystring
{
public:
//mystring();
mystring(const char *s = NULL);//无参的形式包含在里面
char * c_str();
mystring(const mystring & another);
mystring& operator=(const mystring & another);
~mystring();
private:
char * _str;
};
#endif // MYSTRING_H#include <iostream>
#include "mystring.h"
using namespace std;
int main()
{
string s = "assassin";
string ss(s);
cout<<"++++++++++++++++"<<endl;
cout<<ss<<endl;
cout<<"++++++++++++++++"<<endl;
mystring s1 = "intelwisd";
mystring ss1(s1);//浅复制，两个对象指向同一个地址空间，释放对象的时候释放了两次对象所指向的地址空间。
cout<<"++++++++++++++++"<<endl;
cout<<ss1.c_str()<<endl;
cout<<"++++++++++++++++"<<endl;
string sss;
sss = s;
mystring sss1;//
sss1 = s1;
return 0;
}