Mr-Luer
2018-06-06 15:03
采纳率: 48.6%
浏览 3.8k

类中的成员函数new出来的内存在调用结束时会被释放吗

class A
{
public:
char* fun()
{
return new char[10] ;
}
} ;

int main()
{
A * a = new A() ;
char * p = a.fun() ;
return 0 ;
}

如果fun()是一个普通函数而不是类的成员函数,那么new出来的内存在函数执行完以后肯定是被释放的。但这里是类的成员变量,当主函数执行完 char * p= a.fun() 以后,p是否指向了fun()申请的内存?

  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

15条回答 默认 最新

  • threenewbee 2018-06-06 15:39
    已采纳

    什么时候会释放?放在堆栈上,静态定义的局部变量可以释放
    图片说明

    打赏 评论
  • threenewbee 2018-06-06 15:06

    恭喜你选择了不会释放的C++,就是这么惊喜。

    3 打赏 评论
  • threenewbee 2018-06-06 15:27

    如果fun()是一个普通函数而不是类的成员函数,那么new出来的内存在函数执行完以后肯定是被释放的。
    这个你首先就说错了。

    2 打赏 评论
  • threenewbee 2018-06-06 15:35

    图片说明

    打赏 评论
  • threenewbee 2018-06-06 15:45

    所以C++ 11还是14才有“智能指针”这么一个概念,其实大家都知道,一天到晚说“智能”的,一定是智障。
    趁早退出C++,退出C++保平安。

    打赏 评论
  • chimenghuanzhe 2018-06-06 16:15

    不会释放。会直接的指向那段内存。如下图:
    图片说明
    图片说明
    图片说明

    最后他们的地址一样。
    同时,
    #include
    using namespace std;
    class A
    {
    public:
    char* fun()
    {char *x=new char[10];
    printf("add x =%d\n",x);
    return x;
    }
    } ;

    int main()
    {
    A a ;
    char * p = a.fun() ;
    printf("add p =%d\n",p);

    p[6]=2;
    p[7]=3;

    return 0 ;
    }
    加上这两句,发现可以对p[6]赋值,说明这段内存是可以用的,而非是野指针,因此可以确定此时这段内存并没有释放掉,并且p指向了它。

    打赏 评论
  • 邪恶八进制 2018-06-07 01:19

    C语言不会自动施法内存,自动施法内存Java可以办到...

    打赏 评论
  • 八千里山河 2018-06-07 01:36

    在析构函数里面Delete就好了

    打赏 评论
  • xielinghua 2018-06-07 01:58

    不会释放,new是在堆栈上申请内存的,所以,你需要显示的释放掉,可以在析构函数中判断,并释放。

    打赏 评论
  • chimenghuanzhe 2018-06-07 02:33

    回复caozhy: 哦哦,确实。我又设计了一下,用如下代码测试:
    #include
    using namespace std;
    class A
    {
    public:
    char* fun()
    {char *x=new char[10];
    printf("add x =%d\n",x);
    for(int i=0;i<10;i++)
    { x[i] = i; }
    return x;
    }
    } ;
    char * ff()
    { char *y = new char [10];
    printf("address y =%d\n",y);
    for(int i=0;i<10;i++)
    { y[i] = i; }
    return y;
    }
    int main()
    {
    A a;
    char *qq = NULL;
    // qq = ff();
    qq = a.fun();
    printf("address qq =%d\n",qq);
    printf("qq[1] = %d\n",qq[6]);
    delete[]qq;
    printf("address qq =%d\n",qq);
    printf("qq[1] = %d\n",qq[6]);
    printf("qq[1] = %d\n",qq[7]);
    printf("qq[1] = %d\n",qq[8]);
    return 0 ;
    }
    可以发现内容被改变了。虽然说依然不够严谨,比如有些时候哪怕内存被释放了,但是里面的内容却没改变。但是后来我有进行一次释放,delete[]qq;,如果之前确实被释放了,那么再次释放就会引起二次释放错误。因此可以判断之前没有释放。
    图片说明

    打赏 评论
  • lyt18380129078 2018-06-07 02:45

    new申请的内存空间之后需要用delete释放,没问题吧

    打赏 评论
  • RogeVon 2018-06-07 03:02

    咋一看我以为是java,我就想JAVA有GC呀平常使用不存在释放问题。结果细看是C++,那得自己释放。

    打赏 评论
  • VIVIAN_WO 2018-06-07 03:30

    会的,JDK会自动释放

    打赏 评论
  • displayMessage 2018-06-07 12:40

    要知道,编译器为你的类缺省生成的析构函数,只能析构在栈帧中的对象资源。
    无论什么时候使用new,申请到的内存空间,一定是堆区的。析构函数是没有办法为你自动的释放的,只能通过delete来释放。
    我建议,如果在构造函数中有使用new的,都用 一个成员变量去保存new的返回值,然后在析构函数中使用delete释放它。

    打赏 评论
  • qq_41999358 2018-06-07 14:19

    不会,还是会在内存的堆栈里面。要在析构函数里面delete才会释放,p还是指向堆栈顶端

    打赏 评论

相关推荐 更多相似问题