在C++存在拷贝构造函数，拷贝构造函数与不同构造函数形成重载（这一点很重要），这就意味着（要么class入口为普通构造函数，要么为拷贝构造函数，不可能2个都会执行的）。好了 ， 下面可是今天的Studying
一 ， 实际上C++类中有一个默认的拷贝构造，它的作用是将此类中非static成员逐一copy。现在先不管默认的Copy构造，我先先重载一下Copy构造：
#include <iostream>
using namespace std;
class copyC
{
public:
int a;
copyC()
{
this->a = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
this->a = b.a;
}
};
int main()
{
return 0;
}拷贝函数 ： copyC( const copyC &b ) , 里面的语句：this->a = b.a;实现的效果其实是和默认拷贝构造是一样的。
话锋先转一下，谈下拷贝函数的触发机制（在什么条件下会调用）
①：用一个对象为另一个对象初始化
1->
#include <iostream>
using namespace std;
class copyC
{
public:
int a;
copyC()
{
this->a = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
};
int main()
{
copyC str;
copyC new1(str);
cout << new1.a << endl;
return 0;
}结果：
关键：
copyC str;
copyC new1(str);
2->
copyC str; copyC new1 = str;
3->
copyC str; copyC new1 = copyC(str);
4->
#include <iostream>
using namespace std;
class copyC
{
public:
int a;
copyC()
{
this->a = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
};
int main()
{
copyC str;
copyC *new1 = new copyC(str);
cout << new1->a << endl;
delete new1;
return 0;
}结果一样：
小结 ：
上面的1，2，3，4中情况都会调用拷贝构造。
②：当对象生成对象副本时
1->传递对象
#include <iostream>
using namespace std;
class copyC
{
public:
int a;
copyC()
{
this->a = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
static void copyFun( copyC b )
{
}
};
int main()
{
copyC str;
copyC::copyFun(str);
return 0;
}结果：
2->返回对象
#include <iostream>
using namespace std;
class copyC
{
public:
int a;
copyC()
{
this->a = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
static void copyFun( copyC b )
{
}
copyC copyFun()
{
copyC a;
return a;
}
};
int main()
{
copyC str;
copyC new1 = str.copyFun();
new1.a = 4;
cout << str.a << endl;
cout << new1.a << endl;
return 0;
}结果有点诡异 ， 但是理论是正确的：
new1确实拷贝成功 ， 但是“执行了构造函数”好像没打印出来，这和IDE有关吗 ？ 各位读者
好了 ， 现在正式讲讲拷贝构造的作用：
默认拷贝为浅拷贝，浅拷贝在有*（指针）成员的时候会报错：
#include <iostream>
using namespace std;
class copyC
{
public:
int *a;
copyC()
{
this->a = new int[2];
*(a) = 1;
*(a+1) = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
~copyC()
{
delete[] a;
}
};
int main()
{
{
copyC str;
cout << str.a[0] << " " << str.a[1] << endl;
copyC new1 = str;
cout << new1.a[0] << " " << new1.a[1] << endl;
}
return 0;
}出现结果：
正确的结果出来了 ， 但是bug也出来了 。
对于bug的解释：
无论是str还是new1对象，他们的成员指针a都是1个对象（不是2个相同的对象），在内存中的一个对象，那么一个指针是不能释放2次的。
一，如下：
#include <iostream>
using namespace std;
class copyC
{
public:
int *a;
copyC()
{
this->a = new int[2];
*(a) = 1;
*(a+1) = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
this->a = b.a;
}
~copyC()
{
if( a != NULL )
delete[] a;
}
};
int main()
{
{
copyC str;
cout << str.a[0] << " " << str.a[1] << endl;
copyC new1 = str;
cout << new1.a[0] << " " << new1.a[1] << endl;
}
return 0;
}使用这种方案的时候一定要注意 ： a(指针)虽然在2个对象里面（一个是copy的对象)但是a确实是1个对象。
二，重载拷贝构造（这个可以将a（指针）在确实的拷贝一份，这就是深拷贝了）
#include <iostream>
using namespace std;
class copyC
{
public:
int *a;
copyC()
{
this->a = new int[2];
*(a) = 1;
*(a+1) = 2;
}
//拷贝构造函数
copyC( const copyC &b )
{
//执行拷贝构造函数
cout << "执行了构造函数" << endl;
//this->a = b.a;//这是浅拷贝方案
this->a = new int[2];
memcpy(this->a , b.a , 2*sizeof(int));
}
~copyC()
{
delete[] a;
}
};
int main()
{
system("color 2B");
{
copyC str;
copyC new1 = str;
cout << new1.a[0] << " " << new1.a[1] << endl;
new1.a[0] = 3;
new1.a[1] = 4;
cout << "--------------------------------------------" << endl;
cout << new1.a[0] << " " << new1.a[1] << endl;
cout << str.a[0] << " " << str.a[1] << endl;
}
return 0;
}运行结果：
str 中的成员a 和 new1中的成员a ，确实是2个对象哈。。。。。。
好了 ， 本篇结束。。。。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
