Question

考虑我有这个功能：

int &create_ptr(){
    int *x = new int;
    *x =5;
    return *x;
}
int main(){
    int y = create_ptr();
}

这会导致内存泄漏还是以某种方式删除它？对不起，如果这是一个基本问题，这一直困扰着我，我找不到答案。

谢谢大家，现在有道理！

Answer 1

为了满足您的好奇心，是的，您可以delete安全地使用它，但前提是您通过引用返回它（指针或C ++引用（&））。通过引用以保留new ed对象的原始地址。您需要该地址才能正确，安全delete您的对象。

int& create_ref(){
    int *x = new int;
    *x =5;
    return *x;
}

int* create_ptr(){
    int *x = new int;
    *x =5;
    return x;
}

int create_sane_version() {
    return 5;
}

int main(){
    int& x = create_ref();
    delete &x;   // OK. Get address of x; same as deleting through a pointer pointing to its address
                 // x here refers to the newed object inside create_ref() (*x)
                 // Still begs the question of why you're painstakingly doing this

    int* y = create_ptr();
    delete y;    // OK, but not optimal (the above isn't either)
                 //    * not optimal == a bad way to do this

    int leak = create_ref();
    delete &leak;    // DEFINITELY NOT OK. leak isn't the same as the newed object
                     //    i.e. &leak != &create_ref();
                     // You're actually *copying* the object referred to by the returned
                     //    reference. The returned reference gets lost.

    int best_way_to_do_this = create_sane_version();
}

Answer 2

这会导致内存泄漏吗？

是的，它会的。您正在使用new语句分配动态内存而没有相应的delete来释放它，因为您有内存泄漏。

有什么方法可以删除吗？

当然有：不要用裸指针进行动态内存分配。在你的情况下，为什么你甚至需要一个参考？

int create(){
    return 5;
}

int main(int, char*[]){
    int y = create();
}

如果你真的需要动态记忆，你可以像这样使用std::shared_ptr和std::make_shared：

#include <memory>

auto create_ptr() {
    return std::make_shared<int>(5);
}

int main(int, char*[]) {
    std::shared_ptr<int> y = create_ptr();
}

Answer 3

是的，这会造成内存泄漏。您使用new分配空间，但永远不会使用delete释放空间。

如果要在免费商店中创建对象（或基本类型），可以返回指针，并使函数调用者删除指向的对象。

// Caller is responsible for deleting pointed-to int.
int* create_ptr()
{ 
   // Hope that operator new does not throw std::bad_alloc
   int* x = new int;
   *x = 5;
   return x;
 }

更好的方法是返回一个智能指针，但它超出了这个问题的范围。

Answer 4

由于您在堆上创建内存int * x = new int;，您需要显式删除它。

如果要避免跟踪所有堆内存并明确删除它，可以使用共享指针。

当最后一个引用超出范围时，共享指针会跟踪对内存的所有引用，删除内存指示。

删除对本地创建的指针的引用

4 个答案: