|
一、深拷贝和浅拷贝构造函数总结: 1、两个特殊的构造函数: (1)无参构造函数: 没有参数的构造函数 Class Test{( \: Z6 j; F. [0 ?0 `- A public:% P. K2 ^" M. V4 ~8 g9 R/ R Test() {7 H7 l) e" c \/ k //这是一个无参构造函数7 r j: A9 R/ f, @: g$ G1 d! l! }1 P } };4 B T3 e, c" A5 q U7 _ 当类中没有定义构造函数时,编译器默认提供一个无参构造函数,并且其函数体为空;换句话来说,就是我们在类中,不用我们程序猿自己写,编译就自动提供了无参构造函数(只是我们肉眼看不到!) #include <iostream>- k& b9 j2 O1 L- M( w$ x2 M#include <string> class Test{ //编译器默认给我们提供了一个无参构造函数,只是我们肉眼看不到 % P4 j( n1 u, y! k$ h) r8 a };+ \3 }. }% m( q7 ]7 @' a/ ` + t. ] `( j% U& ~% Y g8 R int main()0 l# {* {, M7 t4 `7 P9 B" |* f { Test t;3 R# t- w4 d# I2 n+ g% F & S4 J9 z/ M- H5 c- U return 0; } / u1 m3 F7 e) Q) o2 \2 @/ z 结果输出(编译时能够通过的): root@txp-virtual-machine:/home/txp# g++ test.cpproot@txp-virtual-machine:/home/txp# 5 L0 }: u9 |& J" _ 3 V* M6 X4 i- V& A9 W (2)拷贝构造函数: 参数为const class_name&的构造函数 class Test{public: Test(const Test& p) {! _/ d ~1 X7 G* D } } 当类中没有定义拷贝构造函数时,编译器默认提供了一个拷贝构造函数,简单的进行成员变量的值赋值 #include <iostream>#include <string>/ z; k- c U2 a7 K% |, P. \+ ?+ j 8 m3 g. k* f0 | class Test{/ Z% ~$ s2 l. j- q! G) r private: int i; int j; public: /* Test(const Test& p)编译器默认提供这样操作的 {- q' V$ Q/ y: r i = p.i;* \$ M* k: @7 z* D j = p.j; }*/$ F8 |2 Z! {, L: m: W: K6 Z! c- D ; [; 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() {( 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 } 输出结果(编译可以通过): root@txp-virtual-machine:/home/txp# g++ test.cpp7 u) e; t8 I* V3 H0 ?root@txp-virtual-machine:/home/txp# (3)注意: 在写程序的时候,定义的类对象初始化时看属于哪种类型的: Test t;//对应无参构造函数/ N% g) F l( r( x* |( \2 ^Test t(1);//对应有参构造函数 Test t1;* x# i. ]' L% a0 X/ L Test t2=t1;//对应拷贝构造函数 比如下面我定义的类对象属于无参构造函数(当然前提是你手写了其他构造函数,虽然说编译器会默认提供,但是既然要手写,那么三种构造函数就在定义类对象的时候按需求来写),如果只写了有参数构造函数,那么编译器就会报错: #include <iostream>#include <string>+ p7 F7 {8 e/ G. ` r& a( | class Test{# i# X0 Z% R- O' ^9 k private: int i;9 C. d: J# t0 ]! E }& y* p. I int j; public: Test(int a) {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 }; int 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 } + |* 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()’: 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; ^ test.cpp:25:9: note: candidates are:: J% _4 q! O8 }& p+ |3 r test.cpp:15:3: note: Test::Test(const Test&) Test(const Test& p)% t' o5 x( U& q ^ test.cpp:15:3: note: candidate expects 1 argument, 0 provided6 H6 @- i: ?/ Z test.cpp:10:3: note: Test::Test(int) Test(int a)9 }7 n5 w: Y$ \: J( V! n2 a% R ^ test.cpp:10:3: note: candidate expects 1 argument, 0 provided 4、拷贝构造函数的意义: (1)浅拷贝 拷贝后对象的物理状态相同 (2)深拷贝 拷贝后对象的逻辑状态相同 (3)编译器提供的拷贝构造函数只进行浅拷贝 代码版本一: #include <stdio.h>#include <string> 8 g; q. Q6 v7 T! V" D6 c class Test{6 N, O6 h" M2 S& B- L$ Y private: int i; 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() { return i; }8 N2 g1 w5 O( ~4 b* b/ d int getJ() { return j; }4 N, r' I" s- q5 U& X/ @' \ int *getP()* f9 }+ y, N" n% q7 @, w6 e$ d8 v' G { return p; }" j) e. }+ N- z( ~ Test(int a)- a. M k+ {9 d# x/ m. c { i = 2; j = 3;6 d5 `* I* J0 o# a) u P/ ^ p = new int;! l2 r/ Z" M5 F; W/ T# w1 d *p = a; }2 U' R/ j+ k) N, z; | void free() {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() { 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()); t1.free();/ C2 u2 h* J X2 ]! U7 ?2 Q6 \0 ^+ s t2.free(); return 0; } 7 d8 t2 S2 i1 D$ t1 ]+ s2 [ 输出结果: root@txp-virtual-machine:/home/txp# g++ test.cpp" V9 ?* H$ Y3 U. t% z8 Iroot@txp-virtual-machine:/home/txp# ./a.out t1.i = 2, t1.j = 3, t1.p = 0x1528010 t2.i = 2, t2.j = 3, t2.p = 0x1528010 *** 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 注解:出现了段错误,仔细分析,我们发现这里释放了堆空间两次(因为我们这里没有调用拷贝构造函数,也就是自己去写拷贝构造函数;所以这种情况是浅拷贝,不能释放两次堆空间):
代码版本二(加上拷贝构造函数): #include <stdio.h>% {+ D0 Z* Y" r( T1 y) w#include <string>* l# I$ y' w$ f6 L( g class Test{ private: int i;! c% U1 r) j1 w9 ~ int j; 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 } int getJ(). X' E" t) _: ^/ U: a$ X2 K { return j;" ]; h/ j H# F, C! N } int *getP()8 I! I e8 n! x) Z5 _& ~5 R {" }" q8 @4 w' O return p;; U. z* B, w" g: h } Test(int a) { i = 2; p3 p8 \9 R$ V, ~8 O3 o j = 3; p = new int; *p = a; } Test(const Test& t) { i = t.i; 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; } void free() { , d3 V: ]* ?, S6 K" @$ c delete p;8 l: M+ h: t; q; W ? }: ~/ c# \- X" E b0 F }; int main()/ o$ ~7 u& e; {# m/ j { Test t1(4);' q! Y) @% x% g1 s Test t2 = t1; printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP()); 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(); t2.free(); return 0;2 Y+ e4 d1 |5 P' F8 } } ) 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 t2.i = 2, t2.j = 3, t2.p = 0xb0a0308 q- _. H* A! d# N + Y1 a" S. u7 l6 s1 J. o 注解:从打印的p地址空间来看,就知释放的两个对象的堆空间不同,不再是指向同一堆空间了;同时我们发现浅拷贝只是简单数值上的进行赋值而已;深拷贝不只是简单的值赋值,而是从内存的角度来看,是操作不同的内存。 5、什么时候需要进行深拷贝? (1)对象中有成员指代了系统中的资源
注意:一般来说,自定义拷贝构造函数(也就是我们自己手写的),必然需要实现深拷贝! 二、总结:
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。 |
微信公众号
手机版