31.
32. return 0;
33.}
这段代码对前面的类，加入了一个静态成员，目的是进行计数。
在主函数中，首先创建对象rect1，输出此时的对象个数，然后使用rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运行时，输出的都是1，反应出只有1个对象。
此外，在销毁对象时，由于会调用销毁两个对象，类的析构函数会调用两次，此时的计数器将变为负数。
说白了，就是拷贝构造函数没有处理静态数据成员。
出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：
[c-sharp]viewplaincopyprint?
1.class Rect
2.{
3.public:
4. Rect（） // 构造函数，计数器加1
5. {
6. count++;
7. }
8. Rect（const Rect& r） // 拷贝构造函数
9. {
10. width = r.width;
11. height = r.height;
12. count++; // 计数器加1
13. }
14. ~Rect（） // 析构函数，计数器减1
15. {
16. count--;
17. }
18. static int getCount（） // 返回计数器的值
19. {
20. return count;
21. }
22.private:
23. int width;
24. int height;
25. static int count; // 一静态成员做为计数器
26.};
2.浅拷贝
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。
大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：
[c-sharp]viewplaincopyprint?
1.class Rect
2.{
3.public:
4. Rect（） // 构造函数，p指向堆中分配的一空间
5. {
6. p = new int（100）;
7. }
8. ~Rect（） // 析构函数，释放动态分配的空间
9. {
10. if（p !
= NULL）
11. {
12. delete p;
13. }
14. }
15.private:
16. int width;
17. int height;
18. int *p; // 一指针成员
19.};
20.
21.int main（）
22.{
23. Rect rect1;
24. Rect rect2（rect1）; // 复制对象
25. return 0;
26.}
在这段代码运行结束之前，会出现一个运行错误。
原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。
我们来分析一下：
在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：
在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时rect1.p=rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：
当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。
我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。
3.深拷贝
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：
[c-sharp]viewplaincopyprint?
1.class Rect
2.{
3.public:
4. Rect（） // 构造函数，p指向堆中分配的一空间
5. {
6. p = new int（100）;
7. }
8. Rect（const Rect& r）
9. {
10. width = r.width;
11. height = r.height;
12. p = new int; // 为新对象重新动态分配空间
13. *p = *（r.p）;
14. }
15. ~Rect（） // 析构函数，释放动态分配的空间
16. {
17. if（p !
= NULL）
18. {
19. delete p;
20. }
21. }
22.private:
23. int width;
24. int height;
25. int *p; // 一指针成员
26.};
此时，在完成对象的复制后，内存的一个大致情况如下：
此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
3.防止默认拷贝发生
通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。
甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。
[c-sharp]viewplaincopyprint?
1.// 防止按值传递
2.class CExample
3.{
4.private:
5. int a;
6.
7.public:
8. //构造函数
9. CExample（int b）
10. {
11. a = b;
12. cout<<"creat:
"<13. }
14.
15.private:
16. //拷贝构造，只是声明
17. CExample（const CExample& C）;
18.
19.public:
20. ~CExample（）
21. {
22. cout<< "delete:
"<23. }
24.
25. void Show （）
26. {
27. cout<28. }
29.};
30.
31.//全局函数
32.void g_Fun（CExample C）
33.{
34. cout<<"test"<35.}
36.
37.int main（）
38.{
39. CExample test
（1）;
40. //g_Fun（test）; 按值传递将出错
41.
42. return 0;
43.}
四.拷贝构造函数的几个细节
1.拷贝构造函数里能调用private成员变量吗?
解答：
这个问题是在网上见的，当时一下子有点晕。
其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。
2.以下函数哪个是拷贝构造函数,为什么?
[c-sharp]viewplaincopyprint?
1.X:
:
X（const X&）;
2.X:
:
X（X）;
3.X:
:
X（X&, int a=1）;
4.X:
:
X（X&, int a=1, int b=2）;
解答：
对于一个类X,如果一个构造函数的第一个参数是下列之一:
a）X&
b）constX&
c）volatileX&
d）constvolatileX&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.
[c-sharp]viewplaincopyprint?
1.X:
:
X（const X&）; //是拷贝构造函数
2.X:
:
X（X&, int=1）; //是拷贝构造函数
3.X:
:
X（X&, int a=1, int b=2）; //当然也是拷贝构造函数
3.一个类中可以存在多于一个的拷贝构造函数吗?
解答：
类中可以存在超过一个拷贝构造函数。
[c-sharp]viewplaincopyprint?
1.class X {
2.public:
3. X（const X&）; // const 的拷贝构造
4. X（X&）; // 非const的拷贝构造
5.};
注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用constX或volatileX的对象实行拷贝初始化.
[c-sharp]viewplaincopyprint?
1.class X {
2.public:
3. X（）;
4. X（X&）;
5.};
6.
7.const X cx;
8.X x = cx; // error
如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
这个默认的参数可能为X:
:
X（constX&）或X:
:
X（X&）,由编译器根据上下文决定选择哪一个。
升级会员 