拷贝对象就是将对象复制一份,浅拷贝从字面上理解就是浅显的拷贝,可能会存在问题,
深拷贝就是经过深思熟虑对对象进行拷贝。

浅拷贝;对于比较简单的数据进行赋值操作；
弊端:如果进行拷贝的在指针或者是字符串,浅拷贝只会机械的将字符串或者地址给到新的对象;
然后会出现多个对象里面的数据仅仅是因为将指针指向了堆区里面的同一数据;
输出时不会有问题,但析构时会对堆区的同一地址里面的内容释放两次;然后出错;

#include<iostream>
using namespace std;
class test {
private:
  int a;
  int b;
public:
  test(int a=0, int b=0) {
    this->a = a;
    this->b = b;
    cout << "这里是构造函数,并且被调用了" << endl;
  }
    test(test& a) {
    this->a = a.a;
    this->b = a.b;
    cout << a.geta()<<endl;
    cout << "我是拷贝构造函数我被调用了" << endl;
  }
  ~test() {
    cout << "这里是析构函数并且被调用了" << endl;
  }
  void setAB(int a,int b) {
    this->a = a;
    this->b = b;
  }
  int geta() {
    return a;
  }
  int getb() {
    return b;
  }
};
void print(test &a) {
  cout << a.geta()<<endl;
  cout << a.getb() << endl;
}
test& abadd(test a1, test a2) {//如果函数参数是类的对象,则会调用拷贝构造函数
  //如果参数是对象的引用则不会调用构造函数;
  test a3(a1.geta() + a2.geta(), a1.getb() + a2.getb());//函数中产生的对象生命周期伴随函数生命周期
  return a3;//返回一个匿名对象,
}
int main() {
  test a1(1, 2),a2(3,4);
  test a3 = abadd(a1,a2);
  test a4 = a1;
//  print(a1);
//  print(a3);
//  print(a4);
  return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class pp {
private:
  int len;
  char *p;
public:
  pp(char q[]) {//构造函数
    len = strlen(q) + 1;
    p = new char[len];
    strcpy(p, q);
  }
  pp(pp& q) {//深拷贝实现方法
    if (this->p != NULL) {
      delete[]this->p;
      len = 0;
    }
    len = strlen(q.p)+1;
    this->p = new char[len];
    strcpy(this->p, q.p);
  }
  ~pp() {
    if (p != NULL) {
      delete[]p;
    }
    cout << "析构函数" << endl;
  }
  void print() {
    cout <<p<< endl;
  }
};
int main() {
  char aa[] = "I am big boy";
  char dd[] = "66666";
  pp a1(aa),a2(dd);
  a1.print();
  a2.print();
  pp a3(a2);
  a3.print();
  return 0;
}