Question

将一个C ++函数视为：

A* dum()
{
  A* a = new A()
  doSomethingOnA()
  return a;
}

现在dum()被称为

A* b;
b = dum();

我的问题是我们是否需要将内存分配给b？

编辑：如果我这样做会怎么样：

bool dum(A* a)
{
  // A* a = new A() -- Is this needed?
  doSomethingOnA()
  return 1;
}

和dum被称为

A* b = new A()
dum(b);

Answer 1

从RAII的角度来看，你不应该在dum内部分配并返回一个原始指针。

更好的选择是：

std :: unique_ptr dum（）;
std :: shared_ptr dum（）;
void dum（A＆amp;）;

前两个返回一个托管指针，而第三个则期望一个可能是堆栈或堆变量的引用。

另一个好的选择是按值返回（如果写得很好，那么应该给编译器优化代码）：

dum（）;

另见：

Answer 2

您不需要为b分配新的A（），因为通过调用b = dum（），您已经使b指向与a相同的内存位置。请记住，通过使用指针，您不会将内容分配给b，您只需指定一个内存位置地址。

实际上，如果你做b = new A（），然后执行b = dum（），你将首先丢失b指向的内存位置的引用，这将导致内存泄漏。 / p>

Answer 3

你的两个例子都是合法的。其他人已经提出了更好的方法，但原则上你的代码很好。我试图添加一些评论来解释会发生什么。希望澄清它。

并且“不 - 你不需要为b保留记忆”。编译器会为您处理它。

您的第一个例子

A* dum()
{
    A* a;               // The compiler reserves memory for holding
                        // the pointer a on the stack. 

    a = new A();        // On run time you reserve memory on the heap
                        // for holding an instance of class A.

    doSomethingOnA(a);  // Some function call where you pass the pointer

    return a;           // Return the pointer. This will also release
                        // the stack memory used for holding the pointer a.
}

在另一个功能中：

void func()
{
    A* b;               // The compiler reserves memory for holding
                        // the pointer b on the stack. 

    b = dum();          // The value of the pointer b is changed
                        // so it points to the instance of class A
                        // which is in the heap. The pointer b is
                        // still on the stack.

    // ... more code

    delete b;           // Delete b to free the heap memory 
                        // (and call the class A destructor).

    return;             // This will release
                        // the stack memory used for holding the pointer b.
}

您的第二个例子

原则是一样的。

并且“不 - 你不需要函数dum（..）中的新内容。事实上这将是一个错误。

bool dum(A* a)
{
  // As this function has no local variable, no stack
  // memory will be needed for holding variables.

  // A* a = new A() -- Is this needed?     NO - it would be a bug

  doSomethingOnA(a);

  return 1;
}


void func()
{
    A* b;               // The compiler reserves memory for holding
                        // the pointer b on the stack. 

    b = new A();        // On run time you reserve memory on the heap
                        // for holding an instance of class A.
                        // The value of the pointer b is changed
                        // so it points to the instance of class A
                        // which is in the heap. The pointer b is
                        // still on the stack.

    dum(b);             // Just a function call

    // ... more code

    delete b;           // Delete b to free the heap memory 
                        // (and call the class A destructor).

    return;             // This will release
                        // the stack memory used for holding the pointer b.
}

注意：编译器可以优化堆栈的使用，以便函数内的局部变量完全保存在寄存器中，因此根本不需要任何内存。

C ++中的内存分配困境

3 个答案: