C++复制控制的问题

对象复制问题，以前学的时候总是听什么深复制，浅复制的，各种晕，今天试了一下，顺便写个智能指针试试，如果只是简单的=号复制，那在类中若有指针成员，复制后，对原本进行修改，并不会改变副本的指针值，直接=号那么调用的则是属于直接初始化，直接调用与实参匹配的构造函数。自然当原本发生改变时，副本就不会发生变化。

所以假如我们希望将整个对象复制到正在创建的对象，那么就需要使用复制构造函数。

复制初始化首先使用构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。

但是如果简单使用复制构造函数，又会造成指针悬浮，指针悬浮出项的可能是，当复制完成后，delete掉原指针，但是副本继续使用该指针，所以我们需要对指针进行计数，当计数器为0时，删除指针。当右操作数复制给做操作数，也就意味着左操作数这个创建的对象的计数被减1，因为他将被替代，所谓替代就是删除原先的样本，然后赋予新的值，所以计数器减1，当右操作数复制给左操作数时，就在执行复制行为，那么计数器就加1。撤销原有对象减1，复制新对象加1.这是重载时候需要做的。这个重载操作数函数，其实我还不是很懂，所以就不说了。

这个指针复制还涉及是否是值类型的复制，假如是值类型的复制，复制的就不是指针，而是指针的值，当然也就不会发生改变啦。

这个算术值等等，是独立的，所以不管是哪种复制，都不会改变。

这个对象，同理。其实对象是不用deletede,
原理和这个差不多。

贴个源码  ，有兴趣的人看看吧。

class A{

public:
 int a;
 int * pa;
 void setA(int d){
 pa=new int(d);
 }
 int getA(){
 return *pa;
 }
 

};
class B{
public:
 B(int  & pb,int i):ptr(new int(pb)),b(i){
 
 }
 B(B & org):ptr(new int(*org.ptr)),b(org.b){}
 ~B(){
 delete ptr;
 }
 B & operator=(B& rhs){
  *ptr=*rhs.ptr;
  b=rhs.b;
  return *this;
 }
 int * ptr;
 int b;
};
class UC{
friend class C;
int * ptr;
size_t use;
UC(int * p):ptr(p),use(1){}
~UC(){delete ptr;}

};
class C{

public:
 UC * pc;
 int c;
 A a;
 C(int *p,int i,A aa):pc(new UC(p)),c(i),a(aa){}
 C(C & org):pc(org.pc),c(org.c),a(org.a){
  ++pc->use;
 
 }
 ~C(){
  if(--pc->use==0){
  delete pc;
  }
 }
 C & operator=(C & rhs){
  ++rhs.pc->use;
  if(--pc->use==0){delete pc;}
  pc=rhs.pc;
  c=rhs.c;
  a=rhs.a;
  return *this;
 }
 int getP(){
  return *pc->ptr;
 }
 void setP(int a){
  pc->ptr=new int(a);
 }
 

};
#include<iostream>
#include"test.h"
using namespace std;
void main(){

A a1;
A a2;
a1.a=1;
a1.setA(2);
a2=a1;
a1.setA(5);
cout<<a2.getA()<<endl;
int d=1;
B b1(d,2);
B b2(b1);
b1.b=3;
b1.ptr=new int(4);
cout<<b2.b<<endl;
C c1(new int(1),2,a1);
C c2(c1);
c1.setP(3);
a1.setA(10);
cout<<c2.a.getA()<<endl;
}