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

认为我有以下功能：

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

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

---

谢谢大家，现在有意义了

是，这将导致内存泄漏。您使用

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;
 }

---

更好的方法是返回一个智能指针，但它不在这个问题的范围内。

是的，这会造成内存泄漏。您使用

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;
 }

---

更好的方法是返回一个智能指针，但它不在这个问题的范围内。

是的，这会造成内存泄漏。您使用

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;
 }

---

更好的方法是返回一个智能指针，但它不在这个问题的范围内。

是的，这会造成内存泄漏。您使用

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;
 }

更好的方法是返回一个智能指针，但它不在这个问题的范围之内

这会导致内存泄漏吗

是的，会的。您正在使用

new

语句分配动态内存，但没有相应的

delete

来释放它，因此：您有内存泄漏

---

有没有办法删除它

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

int create(){
    return 5;
}

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

如果您确实需要动态内存，您可以这样使用：

#include <memory>

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

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

#包括
自动创建_ptr（）{
返回标准：：使_共享（5）；
}
int main（int，char*[]）{
std:：shared_ptr y=create_ptr（）；
}

这会导致内存泄漏吗

是的，会的。您正在使用

new

语句分配动态内存，但没有相应的

delete

来释放它，因此：您有内存泄漏

---

有没有办法删除它

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

int create(){
    return 5;
}

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

如果您确实需要动态内存，您可以这样使用：

#include <memory>

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

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

#包括
自动创建_ptr（）{
返回标准：：使_共享（5）；
}
int main（int，char*[]）{
std:：shared_ptr y=create_ptr（）；
}

这会导致内存泄漏吗

是的，会的。您正在使用

new

语句分配动态内存，但没有相应的

delete

来释放它，因此：您有内存泄漏

---

有没有办法删除它

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

int create(){
    return 5;
}

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

如果您确实需要动态内存，您可以这样使用：

#include <memory>

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

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

#包括
自动创建_ptr（）{
返回标准：：使_共享（5）；
}
int main（int，char*[]）{
std:：shared_ptr y=create_ptr（）；
}

这会导致内存泄漏吗

是的，会的。您正在使用

new

语句分配动态内存，但没有相应的

delete

来释放它，因此：您有内存泄漏

---

有没有办法删除它

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

int create(){
    return 5;
}

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

如果您确实需要动态内存，您可以这样使用：

#include <memory>

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

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

#包括
自动创建_ptr（）{
返回标准：：使_共享（5）；
}
int main（int，char*[]）{
std:：shared_ptr y=create_ptr（）；
}

因为您在堆int*x=new int；上创建了内存；，您需要显式删除它

若要避免跟踪所有堆内存并显式删除它，可以使用共享指针

---

共享指针跟踪对内存的所有引用。当上次引用超出范围时，指向的内存将被删除。

因为您在堆int*x=new int；上创建了内存；，您需要显式删除它

若要避免跟踪所有堆内存并显式删除它，可以使用共享指针

---

共享指针跟踪对内存的所有引用。当上次引用超出范围时，指向的内存将被删除。

因为您在堆int*x=new int；上创建了内存；，您需要显式删除它

若要避免跟踪所有堆内存并显式删除它，可以使用共享指针

---

共享指针跟踪对内存的所有引用。当上次引用超出范围时，指向的内存将被删除。

因为您在堆int*x=new int；上创建了内存；，您需要显式删除它

若要避免跟踪所有堆内存并显式删除它，可以使用共享指针

---

共享指针跟踪上次引用超出范围时所有内存的引用，删除内存指向。

< P>满足您的好奇心，是的，您可以<代码>删除<代码>安全，但只有当您通过引用返回它（指针或C++引用（<代码>和代码>））。通过引用，以保留

新对象的原始地址。你需要那个地址才能正确地找到一个地址