C++析构问题

[jia_china_1989]

class A
{
public:
A();
~A（）;
};

class B
{
public:
B();
~B(){delete p1;}
A* p1;
A* Fun()
{
p1 = new A();
return p1;
}
}

void main()
{
B* b1 = new B();
b1->Fun();
b1->Fun();
delete b1;
}

类似这样子用C++，就会出现析构不完全，造成内存泄露的问题。我想问的是，C++有没有什么办法可以不用程序员自己每次调用一次b1->Fun（）;就自己释放一次内存的办法。主要是为了使程序能够更好的维护。

[baichi4141]

在B里面添加一个A*列表，每次调用Fun都把指针备份到列表里
在B析构函数中将列表内指针所指内存全部释放

[baichi4141]

或者放弃C++，改投Java
垃圾回收机制让你万事无忧

[baichi4141]

或者在Fun函数中New之前先删除当前的p1所指内存
等等等等
方法很多，自己取舍

如果你觉得取舍也耽误你维护程序的话，那还是换java吧，万事无忧

[jia_china_1989]

java对这个是比C++方便点，但是正因为C++麻烦，不容易学，学好了才显得厉害。我正在慢慢的学java，但还是喜欢C++。我就想知道大侠们是怎么处理这个问题的。有没有什么高招。

[kingdom_0]

class A
{
public:
  A();
  ~A（）;
};

class B
{
public:
  B();
  ~B(){delete p1;}
  A* p1;
  A* Fun()
  {
if(p1!=NULL)
  delete p1;
  p1 = new A();
  return p1;
  }
}

void main()
{
  B* b1 = new B();
  b1->Fun();
  b1->Fun();
  delete b1;
}

[tixisong]

[Quote=引用 5 楼 的回复:]

C/C++ code
class A
{
public:
A();
~A（）;
};

class B
{
public:
B();
~B(){delete p1;}
A* p1;
A* Fun()
{
if(p1!=NULL)
delete p1;
p1 = new A();
return p1;
}
}

void main()
{
B* b……
[/Quote]


++

[jia_china_1989]

自己顶下。。期待大神搭救。。

[zql1982000]

正确的做法是 在a 和b 的类的析构函数前面 加virtual 关键字就不内存泄漏了

[jianjun21st]

避免使用裸露形指针，尽量用引用计数形指针,如：
class B
{
public:
B();
~B(){}
std::tr1::shared_ptr<A> Fun()
{
return std::tr1::shared_ptr<A>(new A);
}

private:
std::tr1::shared_ptr<A> p1;
}

[aquanull]

[Quote=引用 2 楼 的回复:]

或者放弃C++，改投Java
垃圾回收机制让你万事无忧
[/Quote]
更深刻的问题在于过程的副作用：

#include <cstdio>
void run_once()
{
    static const char *lines[] = {"This sentence should be", "printed for only once!"};
    static const char **p = lines;
    std::printf("%s\n", *p);
    ++p;
    std::printf("%s\n", *p);
}

int main()
{
    run_once();
    run_once(); // 访问越界
    return 0;
}

不解决这种问题，迁移到java只是治标不治本。

[mstlq]

class A
{
public:
  A();
  ~A（）;
};

class B
{
public:
  B():p1(NULL){};
  ~B(){delete p1;//delete空指针是没有问题的，放心，即使Fun从没调用也无所谓}
  A* p1;
  A* Fun()
  {
     delete p1;
     p1 = new A();
     return p1;
  }
}

void main()
{
  B* b1 = new B();
  b1->Fun();
  b1->Fun();
  delete b1;
}

[x13610036461]

C++有一个叫智能指针的做法，建议LZ把C++primer看完

[寂寞vs爱神]

虚函数，解决你的烦恼。

[jia_china_1989]

9楼的作法和java的回收机制可行，和java的处理有点像，就是用指针计数器的方式，删除指针。这个方法很好，想到过这个方案，可没写成你这样的方式，受教了。。
11楼的作法不错，可是有一个漏洞是，类B成员函数开辟空间的生存周期和类B的生存周期不一样，这样如果我在类B的生存周期内相对上一次开辟的类A空间处理就会出错。但11楼这个做法对我这个问题是很好的很有效的，小弟受教了。。。