你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

C++——拷贝构造函数的浅copy和深copy

[复制链接]
gaosmile 发布时间:2020-8-31 23:43

一、深拷贝和浅拷贝构造函数总结:

1、两个特殊的构造函数:

(1)无参构造函数:

没有参数的构造函数

Class Test
9 j$ b& l: M7 a- ]5 ?( V{( \: Z6 j; F. [0 ?0 `- A
public:% P. K2 ^" M. V4 ~8 g9 R/ R
     Test()
& _* j3 s) H! Y2 R7 H! N     {7 H7 l) e" c  \/ k
       //这是一个无参构造函数7 r  j: A9 R/ f, @: g$ G1 d! l! }1 P
     }
/ Q5 \& d; |  G) s* {# f# }, N0 g};4 B  T3 e, c" A5 q  U7 _

当类中没有定义构造函数时,编译器默认提供一个无参构造函数,并且其函数体为空;换句话来说,就是我们在类中,不用我们程序猿自己写,编译就自动提供了无参构造函数(只是我们肉眼看不到!)

#include <iostream>- k& b9 j2 O1 L- M( w$ x2 M
#include <string>
* U" |; \5 w0 c
( S2 u6 b3 {5 v8 W/ b0 ]" p& wclass Test{
0 `2 l7 Q% d8 e
2 e  Q' B+ l7 q; X( O//编译器默认给我们提供了一个无参构造函数,只是我们肉眼看不到
- q5 y& W6 L6 x" |7 Q2 [: Z' a/ Y% P4 j( n1 u, y! k$ h) r8 a
};+ \3 }. }% m( q7 ]7 @' a/ `
+ t. ]  `( j% U& ~% Y  g8 R

. q3 `4 `% s: I2 ~- L" B
6 p# [+ X: U6 j* T& Yint main()0 l# {* {, M7 t4 `7 P9 B" |* f
{
) |2 b' U& {4 ]  `+ l* p   Test t;3 R# t- w4 d# I2 n+ g% F
& S4 J9 z/ M- H5 c- U
  return 0;
# ^5 G, k& O' d+ |! Q* {}
0 D0 p8 z) X. _1 E/ u1 m3 F7 e) Q) o2 \2 @/ z

结果输出(编译时能够通过的):

root@txp-virtual-machine:/home/txp# g++ test.cpp
5 \  L% `6 X# S4 I8 D% A# Vroot@txp-virtual-machine:/home/txp#
% S  S2 N. `# W. o5 L0 }: u9 |& J" _
3 V* M6 X4 i- V& A9 W

(2)拷贝构造函数:

参数为const class_name&的构造函数

class Test{
: H+ b3 h8 J4 ipublic:
" w8 S. |  k' H* C   Test(const Test& p)
+ j& Y9 a( H& G/ a$ A8 }   {! _/ d  ~1 X7 G* D
      
$ C0 F7 H- \% H% y+ @" R* l   
+ I8 L$ w, ~2 i/ m0 w+ ]   }
; x' K8 U$ z! P# f4 H5 g2 K}
( Y# J6 h" L% t$ x2 D

当类中没有定义拷贝构造函数时,编译器默认提供了一个拷贝构造函数,简单的进行成员变量的值赋值

#include <iostream>
' B5 k- Q7 N% v. s  v. Y# I#include <string>/ z; k- c  U2 a7 K% |, P. \+ ?+ j
8 m3 g. k* f0 |
class Test{/ Z% ~$ s2 l. j- q! G) r

$ s; [$ S3 `4 k5 m# o0 n+ fprivate:
: W. |& B' S7 x7 ?- ^5 _. I3 I1 z   int i;
' G& I9 {" N4 s3 Q   int j;
- _; c  ^7 w1 g. I1 w' U2 Kpublic:
  ?3 Z: R" |# B. w /*  Test(const Test& p)编译器默认提供这样操作的
9 U! e& m& B; C3 d) @   {- q' V$ Q/ y: r
      i = p.i;* \$ M* k: @7 z* D
      j = p.j;
5 d0 e$ }9 Q: [; f; z2 u8 z7 X) J   }*/$ F8 |2 Z! {, L: m: W: K6 Z! c- D

) a5 p) o: N2 L$ \# @; [; Y3 w6 o; p8 @% R# ?& Z" |/ Z* ]! k
};8 t  @- @5 ~7 `+ c
" d9 @) {9 f  R; v( U
9 b: e0 ~7 D4 b. O9 S& e# m6 ^5 T
  U7 r) O% M" C8 W+ Z8 f  U
int main()
5 E- f+ I8 D% \{( R; p% j' a2 y. _: h5 Y
   Test t;: r5 `- U5 ]3 }" V. `
* N" D4 G; S* S( ^+ v, }
1 w: a( q9 f# m" r7 U
# g2 e, F4 g8 C0 f$ ]3 g& d) B
  return 0;0 a1 ?: R/ j  K
}
) M0 ]4 H; d6 n8 Y- Y0 {( I
$ S& _& ^6 e, g# W" Y

输出结果(编译可以通过):

root@txp-virtual-machine:/home/txp# g++ test.cpp7 u) e; t8 I* V3 H0 ?
root@txp-virtual-machine:/home/txp#
( B- R( x8 q% E+ x/ l7 W

(3)注意:

在写程序的时候,定义的类对象初始化时看属于哪种类型的:

Test t;//对应无参构造函数/ N% g) F  l( r( x* |( \2 ^

( d1 R/ o4 [/ u4 _Test t(1);//对应有参构造函数
2 F# `$ n, @# {- Z
% b2 f% e" P$ b' b  h! V6 hTest t1;* x# i. ]' L% a0 X/ L
Test t2=t1;//对应拷贝构造函数
9 g8 V& y9 v# w. l4 e

比如下面我定义的类对象属于无参构造函数(当然前提是你手写了其他构造函数,虽然说编译器会默认提供,但是既然要手写,那么三种构造函数就在定义类对象的时候按需求来写),如果只写了有参数构造函数,那么编译器就会报错:

#include <iostream>
8 u. {+ W6 p; Q7 Y  Y#include <string>+ p7 F7 {8 e/ G. `  r& a( |

0 P4 \6 ~' ^# a1 Z% k& g/ |6 qclass Test{# i# X0 Z% R- O' ^9 k

! ]! y$ C+ F8 u' j6 I: Z" j  e0 uprivate:
8 R9 n+ @9 G+ O  Q3 G   int i;9 C. d: J# t0 ]! E  }& y* p. I
   int j;
- }$ q0 W% @. H$ ~) p2 R9 Hpublic:
6 v3 i2 o2 }0 f9 R- o& ]3 g. n  Test(int a)
2 p7 f, q8 i. M. ]0 t  {2 x0 o; ]! T+ \3 n( `' P% V
     i = 9;' h# j& G  k4 r8 a" o4 Q) N4 g
     j=8;8 Y# h* N/ F$ p+ z9 r! _) ^
  }" |; F4 f: I8 {  f* H; a
  Test(const Test& p)9 U( c8 F* h" v( G. I0 r
   {0 B& d' B2 _0 r1 E3 q& e9 ]1 l
      i = p.i;7 H* N: Y2 ^" Y0 D
      j = p.j;" ]; X( m. B$ `5 v/ R) J4 g
   }& S0 U8 |1 Y* B" ]0 O

) N; r) Q* o+ o' O) M0 E" v
7 t. d% O7 F9 \! K};
% l, a. P7 r5 r7 y  f5 ~8 t9 [) Nint main()& m- Y) _( w" ^& L7 s9 n
{5 x. G, j. @. w1 w
   Test t;" O0 V7 ~5 n8 h  L- s  [# s
  return 0;0 n- R; @+ E+ g- Q' o0 V
}
2 e! o2 n% ]0 A* C) ?1 v9 T
9 L' G' C2 Z9 S* o+ ]5 ]+ |* c0 y1 r$ M, J! V

输出结果:

root@txp-virtual-machine:/home/txp# g++ test.cpp9 [# C0 i% s" `. ~0 `. d& z7 [
test.cpp: In function ‘int main()’:
0 z# U0 x5 ~2 g: c1 i% u; _test.cpp:25:9: error: no matching function for call to ‘Test::Test()’0 q9 |5 Q4 K7 p7 C7 b5 P" {2 ^
    Test t;
2 h5 L6 a* |  ~         ^
- [0 q" u1 Y) ]0 E0 }+ X! Utest.cpp:25:9: note: candidates are:: J% _4 q! O8 }& p+ |3 r
test.cpp:15:3: note: Test::Test(const Test&)
2 Z: k( p8 }! h1 V* _& H   Test(const Test& p)% t' o5 x( U& q
   ^
$ K" k, I: m/ A% ?' ~test.cpp:15:3: note:   candidate expects 1 argument, 0 provided6 H6 @- i: ?/ Z
test.cpp:10:3: note: Test::Test(int)
8 y) X' S$ l. u8 Y; e9 F   Test(int a)9 }7 n5 w: Y$ \: J( V! n2 a% R
   ^
& k/ B+ z. J6 C7 z8 `5 E% X6 q- vtest.cpp:10:3: note:   candidate expects 1 argument, 0 provided
8 z# u9 s+ e* ^! L: w$ f
: O: f6 C. H# E% G3 @/ e$ l$ P

4、拷贝构造函数的意义:

(1)浅拷贝

拷贝后对象的物理状态相同

(2)深拷贝

拷贝后对象的逻辑状态相同

(3)编译器提供的拷贝构造函数只进行浅拷贝

代码版本一:

#include <stdio.h>
( D" k% j4 V: n& o. Z' e#include <string>
: E; e9 o6 W, z" k/ z2 {8 g; q. Q6 v7 T! V" D6 c
class Test{6 N, O6 h" M2 S& B- L$ Y
private:
# }2 R6 C4 u+ z+ B6 _5 W" u   int i;
  f: Q( z4 p5 Z6 X2 S   int j;. V) a( B- ?$ g# _$ T
   int *p;# \6 A. X1 o+ b; F7 ]: _
public:% a, Z/ r' L: k1 X' g& \& R) H
   int getI()
: s3 p  f; s) F/ V   {
) b& l" h: X. ~& d' T9 O      return i;
. X# Z. t4 S3 a: F* i8 H# A   }8 N2 g1 w5 O( ~4 b* b/ d
   int getJ()
3 J) M. P! ?* L5 a2 ]& n5 f4 u   {
) G4 i* H9 n8 r& M      return j;
1 b# r1 s/ i8 U/ U( ^# o; P- l   }4 N, r' I" s- q5 U& X/ @' \
   int *getP()* f9 }+ y, N" n% q7 @, w6 e$ d8 v' G
   {
( Z# c. C6 S, o, H, }1 o, S      return p;
! o0 q& f" g' E* e2 Z; {0 B   }" j) e. }+ N- z( ~
   Test(int a)- a. M  k+ {9 d# x/ m. c
   {
9 G* J% W' A/ d3 e% v! T2 J      i = 2;
9 V, s+ u5 M% P      j = 3;6 d5 `* I* J0 o# a) u  P/ ^
      p = new int;! l2 r/ Z" M5 F; W/ T# w1 d
      *p = a;
& b4 \) h8 E! @4 Q% k1 d, ]$ g  }2 U' R/ j+ k) N, z; |
  void free()
: }  R, ~- ]8 ~" W, p' O  {0 ?+ P/ }( |. a9 G4 c
; z2 L/ {+ y  s5 E8 W- v( |
    delete p;: g; c+ P5 h8 Q/ E# v6 \8 K
  }6 L: ]1 W: i5 G; @: i" f
};( {# f( Y6 u* P: e
int main()
2 s3 E' b& }. s7 W; A# b4 l{
  T; r5 }6 |7 X8 p9 X9 k$ a   Test t1(3);//Test t1 3;: Q7 |2 E' @, V( g6 t0 ^( }
   Test t2 = t1;: t# v6 f2 F$ z3 V
  \8 U$ \  B3 |/ F* Y2 K
  printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());( }, `; P3 g* w8 |" Y8 J3 C; l. R
  printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
0 W5 W, r% N# J/ K; P9 T
# Z4 a# G. c7 t7 x/ K+ ?   t1.free();/ C2 u2 h* J  X2 ]! U7 ?2 Q6 \0 ^+ s
   t2.free();
3 i' s6 `6 E1 O/ P% v   
; r! a3 Q$ T. U0 Z% e8 Q  \   return 0;
9 m+ x" d0 `% w. [; U' F3 G}
' v' C5 v9 x# T/ k+ j# V+ q  F2 r7 d8 t2 S2 i1 D$ t1 ]+ s2 [

输出结果:

root@txp-virtual-machine:/home/txp# g++ test.cpp" V9 ?* H$ Y3 U. t% z8 I
root@txp-virtual-machine:/home/txp# ./a.out
9 |# |8 W7 [1 S5 g! j& C4 I8 @t1.i = 2, t1.j = 3, t1.p = 0x1528010
3 |; O' X  Y# Z3 ct2.i = 2, t2.j = 3, t2.p = 0x1528010
  S1 ]2 z8 S5 l- v5 F6 Q* P' \# M*** Error in `./a.out': double free or corruption (fasttop): 0x0000000001528010 ***) F* K9 W: ], y# G4 N$ |
Aborted (core dumped); N5 Z' u0 Y$ i, p3 d! k

! C4 H6 w/ P" _( L5 B9 S1 K

注解:出现了段错误,仔细分析,我们发现这里释放了堆空间两次(因为我们这里没有调用拷贝构造函数,也就是自己去写拷贝构造函数;所以这种情况是浅拷贝,不能释放两次堆空间):

微信图片_20200831234255.png

代码版本二(加上拷贝构造函数):

#include <stdio.h>% {+ D0 Z* Y" r( T1 y) w
#include <string>* l# I$ y' w$ f6 L( g

, `" t' G! b/ h5 W( O; V- pclass Test{
" J9 W, g* ^' p# ?private:
) X6 T9 y- g- \0 S! w. k   int i;! c% U1 r) j1 w9 ~
   int j;
2 G) v* J8 U& p5 W0 ?1 z3 \   int *p;, l! N/ N" z+ p( F6 j$ K. N( @
public:2 `! P6 c- \1 O% J8 r' G
   int getI()- o; c6 H0 ^7 X4 r4 d+ M4 }
   {0 K* A9 O# u2 E. w0 h
      return i;9 ~% S' O. r- r
   }
( q0 |. D7 G  ?9 c7 C   int getJ(). X' E" t) _: ^/ U: a$ X2 K
   {
% m% a0 n6 q5 v+ c9 ~  B      return j;" ]; h/ j  H# F, C! N
   }
$ e5 b: w; x" @& Z( }" K% x   int *getP()8 I! I  e8 n! x) Z5 _& ~5 R
   {" }" q8 @4 w' O
      return p;; U. z* B, w" g: h
   }
5 z& Z7 m& ]! z   Test(int a)
! \$ g, k% S' R4 U   {
6 Y) I' `8 l, `- a      i = 2;  p3 p8 \9 R$ V, ~8 O3 o
      j = 3;
8 y- h* ?) E: \/ _& ^      p = new int;
4 R5 b# }% D% q4 i- Z      *p = a;
3 o4 e, D+ K4 L/ Z* }6 A) O  }
) j( b$ p' w0 A* _1 {0 S+ N. M  Test(const Test& t)
2 K0 D$ p2 F! }$ [+ P4 R9 }  {
+ S' W& v" {- a3 x& h' t* {    i = t.i;
) N5 W; m! L4 G( ?7 x+ z: q+ [/ h8 D    j = t.j;. T6 m) u: J) I  d4 W* `& Y/ [
    p = new int;# U! y( V7 J6 D9 X( }
% c/ W0 j" p, C& `8 L/ @/ {; F
    *p = *t.p;
% q  J$ z1 d4 x  }
+ a8 n; f; B, u, S" s  \
  g+ ], `; r% C* `, x( H+ N  void free()
' w* X0 V+ G" ]2 f$ U+ y  {
& ?8 p& S% W/ C, d3 V: ]* ?, S6 K" @$ c
    delete p;8 l: M+ h: t; q; W  ?
  }: ~/ c# \- X" E  b0 F
};
$ W0 U/ ?) |/ N! g1 @# Z- q% Fint main()/ o$ ~7 u& e; {# m/ j
{
" o" c3 R* c# x# k: [   Test t1(4);' q! Y) @% x% g1 s
   Test t2 = t1;
/ H- T3 ~4 y( v0 B: g
4 Z2 P: w' \# ~6 _  a$ |. w& J   printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
: X' a+ Z4 i. K2 ~/ C& l   printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());5 T  @6 r% Y, j5 ~
   t1.free();
1 t( d( p+ R* |$ R   t2.free();
, d/ G0 g1 _% h+ V& [0 C. S2 {
6 B- {/ [8 R( L   return 0;2 Y+ e4 d1 |5 P' F8 }
}
* j& _' \0 T3 J7 O% ]/ Y) Q/ o: p% g4 {9 `, U! T7 l

输出结果:

root@txp-virtual-machine:/home/txp# g++ test.cpp) c2 q1 q/ ~7 g9 N- k5 m! [
root@txp-virtual-machine:/home/txp# ./a.out$ \+ W. A# ?! ~. {+ o
t1.i = 2, t1.j = 3, t1.p = 0xb0a010
4 A7 w9 Q" i8 k7 d+ Lt2.i = 2, t2.j = 3, t2.p = 0xb0a0308 q- _. H* A! d# N
+ Y1 a" S. u7 l6 s1 J. o

注解:从打印的p地址空间来看,就知释放的两个对象的堆空间不同,不再是指向同一堆空间了;同时我们发现浅拷贝只是简单数值上的进行赋值而已;深拷贝不只是简单的值赋值,而是从内存的角度来看,是操作不同的内存。

5、什么时候需要进行深拷贝?

(1)对象中有成员指代了系统中的资源

  • 成员指向了动态内存空间

  • 成员打开了外存中的文件

  • 成员使用了系统中的网络端口

    2 H. a; t6 b" s# B, t( s, |

注意:一般来说,自定义拷贝构造函数(也就是我们自己手写的),必然需要实现深拷贝!

二、总结:

  • C++编译器会默认提供构造函数

  • 无参构造函数用于定义对象的默认初始化状态

  • 拷贝构造函数在创建对象时拷贝对象的状态

  • 对象的拷贝有浅拷贝和深拷贝两种方式。


    9 p  h/ z& y* ^% D: {$ {) y

好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。


3 k& C: u1 L* B
赞 收藏 评论0 发布时间:2020-8-31 23:43

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版