关于CArray传值方式发生运行时错误

[pois]

项目很复杂，我简化了下代码

class A
{
	int *m_a;
public:
	A()//不带参数构造函数，只是为了通过编译
	{
		int fenge = 4;
	};
	A(int n)//我需要用的构造函数
	{
		m_a = new int;
		m_a[0] = n;
	}
	A(A& _a)//深度拷贝构造函数
	{
		m_a = new int;
	}
	~A()//析构，清理成员指针
	{
		delete m_a;
	}
};

	CArray <A,A> arr;//先不考虑用引用及指针
	A a(1);    //构造对象0x0012ff2c
	arr.Add(a);// 看下面解释，一共生成了3个对象，一个加入到array中
	int fenge = 10;//断点分割
	arr.RemoveAt(0);//析构加入到array的那个对象，调用析构，delete野指针出错
	fenge = 9;

Add时生成三个对象
深度拷贝构造函数 0x0012fe2c
深度拷贝构造函数 0x0012fd10
不带参数构造函数 0x00369ee8

之后两次调用析构函数 删除 0x0012fd10,0x0012fe2c，也就是说，两个有效对象被carray删掉了，一个垃圾对象进了array，然后RemoveAt时delete野指针出错

[pois]

解决了，再重载操作符=作深度拷贝

[pois]

class A
{
	int *m_a;
public:
	A()
	{
		int fenge = 4;
	};
	A(int n)
	{
		m_a = new int;
		m_a[0] = n;
	}
	A(A& _a)
	{
		*this = _a;
	}
	~A()
	{
		delete m_a;
	}
	A &operator=(A &_a)
	{
		m_a = new int;
		return *this;
	}
};

构造第三个对象0x00369ee8（也就是进队列的对象）后，调用=操作符 顺便测试了下以引用方式定义array CArray <A,A &> arr; A a(1); // 构造对象 0x0012ff2c arr.Add(a); // 直接调用无参数构造函数，调用=操作符，跳过中间两个临时对象 int fenge = 10; arr.RemoveAt(0); fenge = 9;

[信阳毛尖]

[lm_whales]

你这个类A写的很可怕,给你改一下：

class A{
    int *m_a;
public:
    A():m_a(NULL){};
    A(int n):m_a(NULL){  create(n); };
    A(const A& a):m_a(NULL){  init(a.m_a);  };
    A& operator =(const A& a){
      if(&a==this)return *this; //防止自赋值
      init(a.m_a);  
      return *this;
    };       
    ~A(){ delete m_a; };
private：
    void create(int n){
        try { m_a = new int;}
        catch(...){}  
        if(m_a) *m_a= n; 
    };
    void destory(){delete m_a;
         m_a=NULL;
    };
    void init(const int *a){ 
         if(a)  create(*a);
         else destory();
    };    
};

然后你在试验一下；

[yaozhiyong110]

引用 4 楼 lm_whales 的回复:

你这个类A写的很可怕,给你改一下：

class A{
    int *m_a;
public:
    A():m_a(NULL){};
    A(int n):m_a(NULL){  create(n); };
    A(const A& a):m_a(NULL){  init(a.m_a);  };
    A& operator =(const A& a){
      if(&a==this)return *this; //防止自赋值
      init(a.m_a);  
      return *this;
    };       
    ~A(){ if(m_a)delete m_a; };
private：
    void create(int n){
        try { m_a = new int;}
        catch(...){}  
        if(m_a) *m_a= n; 
    };
    void destory(){delete m_a;
         m_a=NULL;
    };
    void init(const int *a){ 
         if(a)  create(*a);
         else destory();
    };    
};

然后你在试验一下；

析构为什么不加保护？

[yaozhiyong110]

引用 4 楼 lm_whales 的回复:

你这个类A写的很可怕,给你改一下：

class A{
    int *m_a;
public:
    A():m_a(NULL){};
    A(int n):m_a(NULL){  create(n); };
    A(const A& a):m_a(NULL){  init(a.m_a);  };
    A& operator =(const A& a){
      if(&a==this)return *this; //防止自赋值
      init(a.m_a);  
      return *this;
    };       
    ~A(){ delete m_a; };
private：
    void create(int n){
        try { m_a = new int;}
        catch(...){}  
        if(m_a) *m_a= n; 
    };
    void destory(){delete m_a;
         m_a=NULL;
    };
    void init(const int *a){ 
         if(a)  create(*a);
         else destory();
    };    
};

然后你在试验一下；

init只是拷贝构造才调用 A a; A b(a) debug下 destory里的m_a也不为NULL delete前不舍得加保护 就要保证指针一定是有效的...

[yaozhiyong110]

引用 6 楼 yaozhiyong110 的回复:

[quote=引用 4 楼 lm_whales 的回复:] 你这个类A写的很可怕,给你改一下：

class A{
    int *m_a;
public:
    A():m_a(NULL){};
    A(int n):m_a(NULL){  create(n); };
    A(const A& a):m_a(NULL){  init(a.m_a);  };
    A& operator =(const A& a){
      if(&a==this)return *this; //防止自赋值
      init(a.m_a);  
      return *this;
    };       
    ~A(){ delete m_a; };
private：
    void create(int n){
        try { m_a = new int;}
        catch(...){}  
        if(m_a) *m_a= n; 
    };
    void destory(){delete m_a;
         m_a=NULL;
    };
    void init(const int *a){ 
         if(a)  create(*a);
         else destory();
    };    
};

然后你在试验一下；

init只是拷贝构造才调用 A a; A b(a) debug下 destory里的m_a也不为NULL delete前不舍得加保护 就要保证指针一定是有效的...[/quote] 应该是release下不为NULL debug下应该是NULL

[lm_whales]

因为这个类太简单， delete 一个正常分配的内存，或者空指针不会出错；不需要保护。 构造函数加保护，是因为， 构造函数抛出异常，没有办法处理。 并且不能保证new，不会抛出异常；注意抛出异常后，不能保证 m_a =NULL； 所以，构造函数中，一律先初始化为NULL； 虽然那种情况，非常极端，只有内存耗尽才会出现。

[yaozhiyong110]

release下 A a; A b(a) b的拷贝构造调用 init里的destory m_n是NULL还是有效指针？

[pois]

引用 4 楼 lm_whales 的回复:

你这个类A写的很可怕,给你改一下：

class A{
    int *m_a;
public:
    A():m_a(NULL){};
    A(int n):m_a(NULL){  create(n); };
    A(const A& a):m_a(NULL){  init(a.m_a);  };
    A& operator =(const A& a){
      if(&a==this)return *this; //防止自赋值
      init(a.m_a);  
      return *this;
    };       
    ~A(){ delete m_a; };
private：
    void create(int n){
        try { m_a = new int;}
        catch(...){}  
        if(m_a) *m_a= n; 
    };
    void destory(){delete m_a;
         m_a=NULL;
    };
    void init(const int *a){ 
         if(a)  create(*a);
         else destory();
    };    
};

然后你在试验一下；

对的，感谢～

[lm_whales]

delete 一个正常分配的内存，或者空指针不会出错；不需要保护。 如果为了保险，加保护也未尝不可，------防止其他操作破坏了内存管理系统，或者内存硬件错误，产生的异常，------不过这么做是否，有点过于，杞人忧天了。呵呵！