none
对类对象进行赋值操作的时候,如何避免对象内的指针类型内存泄露 RRS feed

  • 问题

  • 比方我定义了一个类A:
    class A{
    public:

    B* b;
    };

    当我执行如下操作:

    A a1, a2;
    .....

    a1 = a2;

    执行了对象赋值,此时如果a1对象中的b指针已经指向一块已分配内存,那么是否就造成了内存泄露?

    如果有内存泄露,那么如何避免?

    2012年4月6日 2:54

答案

  • 抱歉是智能指针。这个和在什么系统下开发没有关系。只是一个类里面对指针进行了引用计数的封装。很多类库都有智能指针。你可以找一下智能指针或者RAII可以找到很多的相关材料。

    麻烦把正确答案设为解答。

    • 已标记为答案 Helen Zhao 2012年4月13日 3:29
    2012年4月6日 5:57
    版主
  • 浅拷贝和深拷贝

      在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。

      深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之,没有重新分配资源,就是浅拷贝。下面举个深拷贝的例子。

    #include <iostream>
    using namespace std;
    class CA
    {
     public:
      CA(int b,char* cstr)
      {
       a=b;
       str=new char[b];
       strcpy(str,cstr);
      }
      CA(const CA& C)
      {
       a=C.a;
       str=new char[a]; //深拷贝
       if(str!=0)
        strcpy(str,C.str);
      }
      void Show()
      {
       cout<<str<<endl;
      }
      ~CA()
      {
       delete str;
      }
     private:
      int a;
      char *str;
    };

    int main()
    {
     CA A(10,"Hello!");
     CA B=A;
     B.Show();
     return 0;
    }

    深拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程的时候,这个过程就可以叫做深拷贝,反之对象存在资源,但复制过程并未复制资源的情况视为浅拷贝。

    浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。


    Visual C++ enthusiast, like network programming and driver development. At present is being engaged in the WinCE/Windows Mobile platform embedded development.

    • 已标记为答案 Helen Zhao 2012年4月13日 3:29
    2012年4月9日 0:51
    版主

全部回复

  • 你可以找一下关于职能指针的材料。你的这个例子可以使用Share_Ptr

    麻烦把正确答案设为解答。

    2012年4月6日 3:10
    版主
  • 我是基于wince开发,没看到有这个类。

    2012年4月6日 3:27
  • 抱歉是智能指针。这个和在什么系统下开发没有关系。只是一个类里面对指针进行了引用计数的封装。很多类库都有智能指针。你可以找一下智能指针或者RAII可以找到很多的相关材料。

    麻烦把正确答案设为解答。

    • 已标记为答案 Helen Zhao 2012年4月13日 3:29
    2012年4月6日 5:57
    版主
  • 浅拷贝和深拷贝

      在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。

      深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之,没有重新分配资源,就是浅拷贝。下面举个深拷贝的例子。

    #include <iostream>
    using namespace std;
    class CA
    {
     public:
      CA(int b,char* cstr)
      {
       a=b;
       str=new char[b];
       strcpy(str,cstr);
      }
      CA(const CA& C)
      {
       a=C.a;
       str=new char[a]; //深拷贝
       if(str!=0)
        strcpy(str,C.str);
      }
      void Show()
      {
       cout<<str<<endl;
      }
      ~CA()
      {
       delete str;
      }
     private:
      int a;
      char *str;
    };

    int main()
    {
     CA A(10,"Hello!");
     CA B=A;
     B.Show();
     return 0;
    }

    深拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程的时候,这个过程就可以叫做深拷贝,反之对象存在资源,但复制过程并未复制资源的情况视为浅拷贝。

    浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。


    Visual C++ enthusiast, like network programming and driver development. At present is being engaged in the WinCE/Windows Mobile platform embedded development.

    • 已标记为答案 Helen Zhao 2012年4月13日 3:29
    2012年4月9日 0:51
    版主