使用引用而不是指针，解决C ++中的内存泄漏？ [英] Does using references instead of pointers, resolve memory leaks in C++?

问题描述

当对象的指针返回并且程序员忘记删除它时，会出现大部分内存泄漏。

例如：

  class my_class 
 {
 ... 
}; 
 
 my_class * func1（）
 {
 my_class * c = new my_class; 
 return c; 
} 
 
 int main（）
 {
 my_class * var1 = func1（）; 
 ... 
 //程序员忘记删除var1：delete var1; 
 //  -  or  -  
 //不知道'delete [] var1;'是正确的还是'delete var1;'。 
} 
  

当一个指向创建的对象的指针和程序员忘记时，会出现一些内存泄漏删除它。

例如：

  class my_class 
 {
 ... 
}; 
 
 void func2（my_class * p）
 {
 ... 
} 
 
 int main（）
 {
 my_class * var3 = new my_class; 
 
 func2（var3）; 
 
 // func2是否删除了var3？程序员不知道。 
 //  -  or  -  
 //程序员忘记删除var3。 
} 
  

我使用一种方法来解决内存泄漏，但我不确定

我的方法是：不要使用任何指针（除了一个地方），只需使用引用而不是指针。 / p>

例如：

  class my_class 
 {
 ... 
}; 
 
 my_class& func1（）
 {
 my_class * c = new my_class; //除了一个地方。 
 return * c; 
} 
 
 void func2（my_class& p）
 {
 ... 
} 
 
 int main b $ b {
 my_class& var1 = func1（）; 
 my_class var2 = func1（）; 
 
 my_class var3; 
 func2（var3）; 
 
 //没有什么可忘记的。 
} 
  

使用引用而不是指针来解决内存泄漏吗？

这是解决内存泄漏的好方法还是有更好的方法？

---

修改：

此问题的某些答案不同意以下代码没有内存泄漏。

因为它是一个新问题，我单独问。

  class my_class 
 {
 ... 
}; 
 
 my_class& func（）
 {
 my_class * c = new my_class; 
 return * c; 
} 
 
 int main（）
 {
 my_class& var1 = func（）; 
 
 //我认为没有内存泄漏。 
} 
  

我在这里问：
这个代码有泄漏记忆吗？

解决方案

您尚未解决任何内存泄漏。如果你是新的，那么你必须删除。所有你做的是取消引用指针，它仍然需要删除。您可以通过创建本地对象并按值返回或使用智能指针来解决内存泄漏。

现在，像许多初学者一样，通过价值返回大对象的想法可能会吓跑你的以perf为中心的思维。请阅读此以消除您的恐惧。 / p>

Most of memory leaks appear when a pointer of an object returned and programmer forgot to delete it.

for example:

class my_class
{
  ...
};

my_class* func1()
{
  my_class* c = new my_class;
  return c;
}

int main()
{
  my_class* var1 = func1();
  ...
  // Programmer forgot delete the var1: delete var1;
  // -- or --
  // Doesn't know 'delete[] var1;' is correct or 'delete var1;'.
}

Some of memory leaks appear when a pointer to an object created and programmer forgot to delete it.

for example:

class my_class
{
  ...
};

void func2(my_class* p)
{
  ...
}

int main()
{
  my_class* var3 = new my_class;

  func2(var3);

  // Does func2 deletes var3? Programmer doesn't know.
  // -- or --
  // Programmer forgot delete the var3.
}

I use a method to resolve memory leaks but I don't sure about it in complex situations.

My method is: Don't use any pointers (except one place), Just use references instead of pointers.

for example:

class my_class
{
  ...
};

my_class& func1()
{
  my_class* c = new my_class; // except one place.
  return *c;
}

void func2(my_class& p)
{
  ...
}

int main()
{
  my_class& var1 = func1();
  my_class  var2 = func1();

  my_class var3;
  func2(var3);

  // There is nothing to forget.
}

Does using references instead of pointers, resolve memory leaks?

Is it a good method for resolving memory leaks or there are better methods?

---

Edit:

Some answer of this question don't agree the below code don't have memory leak.

because it is a new question, I ask it seperately.

class my_class
{
  ...
};

my_class& func()
{
  my_class* c = new my_class;
  return *c;
}

int main()
{
  my_class& var1 = func();

  // I think there is no memory leak.
}

I ask it here: Does this code has leak memory?

解决方案

You haven't resolved any memory leaks. If you new, then you must delete. All you did was dereference the pointer, it still needs to be deleted. You can resolve memory leaks by creating local objects and returning by value, or using smart pointers. 99 times out of 100, I prefer the return by value option.

Now, like many beginners, the idea of returning large objects by value probably scares your perf-centric mind. Read this to allay your fears.

这篇关于使用引用而不是指针，解决C ++中的内存泄漏？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！