C++ 在这种情况下如何释放内存？

我有一个A类和一个函数

func

，如下所示

class A
{
   int m_memA;
 public:
   A(int x):m_memA(x){}   
   std::string GetString(); 
};

A* CreateA()
{
    return new A(5);
}

bool func(std::string* stringOut)
{
   A* obj_A = CreateA();                //memory allocated in heap
   *stringOut = obj_A->GetString(); 
   if(stringOut->empty())
       {return true;}
   return false;      
} 

int main()
{
    std::string str;
    if(func(&str))        //How to free memory here?    
    {
        //do something
    }
    return 0;
}

---

调用

func

时如何释放内存？

我看不出任何动态分配的理由，但您需要

删除
func
中的
A
：

bool func(std::string* stringOut)
{
   A* obj_A = CreateA();                //memory allocated in heap
   *stringOut = obj_A->GetString();
   delete obj_A;                      // delete dynamically allocated object
   return stringOut->empty();    
}

编辑由于无法更改
CreateA
，您至少可以使用智能指针（如
std:：unique_ptr
或
boost:：scoped_ptr
）来确保此异常安全。例如：

bool func(std::string* stringOut)
{
   std::unique_ptr<A> obj_A(CreateA());
   *stringOut = obj_A->GetString();
   return stringOut->empty();    
}

bool func（标准：：字符串*stringOut）
{
std:：unique_ptr obj_A（CreateA（））；
*stringOut=obj_A->GetString（）；
返回stringOut->empty（）；
}
我完全看不出所有动态分配的理由，但您需要
删除
func
中的
A
：

bool func(std::string* stringOut)
{
   A* obj_A = CreateA();                //memory allocated in heap
   *stringOut = obj_A->GetString();
   delete obj_A;                      // delete dynamically allocated object
   return stringOut->empty();    
}

编辑由于无法更改
CreateA
，您至少可以使用智能指针（如
std:：unique_ptr
或
boost:：scoped_ptr
）来确保此异常安全。例如：

bool func(std::string* stringOut)
{
   std::unique_ptr<A> obj_A(CreateA());
   *stringOut = obj_A->GetString();
   return stringOut->empty();    
}

bool func（标准：：字符串*stringOut）
{
std:：unique_ptr obj_A（CreateA（））；
*stringOut=obj_A->GetString（）；
返回stringOut->empty（）；
}
我建议对对象使用设计模式。它将避免这些类型的内存泄漏。它甚至会处理异常导致的返回

这里有一个更好的设计模式

A CreateA() { return A(5); }

// RAII designed heap allocation
std::unique_ptr<A> CreateHeapA() { return std::unique_ptr<A>(new A(5)); }


bool func(std::string* stringOut)
{
   *stringOut = CreateA().GetString();        // A allocated on the stack
   //*stringOut = CreateHeapA()->GetString(); // A allocated on the heap
   return stringOut->empty();
} 

A CreateA（）{返回A（5）；}
//RAII设计了堆分配
std:：unique_ptr CreateHeapA（）{return std:：unique_ptr（新的A（5））；}
布尔函数（std:：string*stringOut）
{
*stringOut=CreateA（）.GetString（）；//堆栈上分配的
//*stringOut=CreateHeapA（）->GetString（）；//在堆上分配的
返回stringOut->empty（）；
} 
我建议对对象使用设计模式。它将避免这些类型的内存泄漏。它甚至会处理异常导致的返回

这里有一个更好的设计模式

A CreateA() { return A(5); }

// RAII designed heap allocation
std::unique_ptr<A> CreateHeapA() { return std::unique_ptr<A>(new A(5)); }


bool func(std::string* stringOut)
{
   *stringOut = CreateA().GetString();        // A allocated on the stack
   //*stringOut = CreateHeapA()->GetString(); // A allocated on the heap
   return stringOut->empty();
} 

A CreateA（）{返回A（5）；}
//RAII设计了堆分配
std:：unique_ptr CreateHeapA（）{return std:：unique_ptr（新的A（5））；}
布尔函数（std:：string*stringOut）
{
*stringOut=CreateA（）.GetString（）；//堆栈上分配的
//*stringOut=CreateHeapA（）->GetString（）；//在堆上分配的
返回stringOut->empty（）；
} 
CreateA（），类A是预先存在的代码。对此无能为力。func在我的控制下。@onherocks正常。使用智能指针可能是更好的选择。参见我的编辑。因此在
*stringOut=obj_A->GetString（）期间
stringOut设置了返回字符串（因为它被取消引用？）。因此，在它之后删除obj_A不会导致无效指针。这两个指针是相同的吗<代码>返回字符串->空（）和
返回（*stringOut）.empty（）@ontherocks是的，它们是等效的。实际上，我会传递一个引用，并避免所有
*
和/或
->
.CreateA（），类a是预先存在的代码。对此无能为力。func在我的控制下。@onherocks正常。使用智能指针可能是更好的选择。参见我的编辑。因此在
*stringOut=obj_A->GetString（）期间
stringOut设置了返回字符串（因为它被取消引用？）。因此，在它之后删除obj_A不会导致无效指针。这两个指针是相同的吗<代码>返回字符串->空（）和
返回（*stringOut）.empty（）@ontherocks是的，它们是等效的。我实际上会传递一个引用，并避免所有的
*
和/或
->
。