在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个对象哈。
好了 , 本篇结束。
本文永久更新链接地址:http://www.linuxidc.com/Linux/2017-05/143734.htm