使用智能指针

Question

我正在使用具有以下功能的旧版C ++应用程序，

char* CreateNewString (const char* node)
{
   int len = (int) strlen(node) + 1;
   char * ptr = new char [len];
   strcpy_s(ptr, len, node);
   return ptr;
}

该函数从应用程序的许多类中调用，这是一个用例示例。

char * nodeID = obj.CreateNewString(process->GetNodeID());

该应用程序调用一个不同的进程，并获得一个节点ID作为char指针，然后将其传递给CreateNewString函数，以动态地为新字符串分配内存。

在上述调用之后，应用程序中无处删除内存。 据我观察，这里确实存在内存泄漏。

我认为解决此问题的方法很少。 但是我想先尝试在C ++ 11中使用智能指针，然后再尝试其他方法。

我试过的

所以我想出了以下功能：

  char* CreateNewString (const char* node) 
  {
       int len = (int) strlen(node) + 1;
       shared_ptr<char> ptr (new char [len](), [](char* p) {delete [] p;});
       strcpy_s(ptr.get(), len, node);
       return ptr.get();
    }

目的是使函数签名保持不变，即它返回一个char指针，这样我就不必在所有调用位置进行更改。

由于在函数的范围内声明了ptr ，因此上述方法不起作用。

我的目标是：

1. 使用C ++ 11智能指针可以在对现有应用程序进行最少代码更改的情况下实现此目的。

我知道的另一种方法是在调用场所本身中动态初始化数组，然后在该作用域结束之前将其删除。 但是我想在回到传统的C ++方式之前探索新的C ++功能。 顺便说一句，我对此时的std::string不感兴趣。

Answer 1

你可以：

• 返回shared_ptr
• 返回一个std::string
• 保留一切

这些是您的选择。

Answer 2

我没有找到一种方法可以让函数返回char指针并仍然使用智能指针。 完成这项工作可能有潜在的技巧，但是所有这些都有开销，更重要的是，不必要的代码。 我的建议是对您编写的新函数进行简单更改，然后在所有调用位置进行另一个更简单的更改。

所以功能看起来像这样

 shared_ptr<char> CreateNewString (const char* node) 
  {
       int len = (int) strlen(node) + 1;
       shared_ptr<char> ptr (new char [len](), [](char* p) {delete [] p;});
       strcpy_s(ptr.get(), len, node);
       return ptr;
  }

然后调用它的任何地方，只需添加.get（）

char * nodeID = obj.CreateNewString(process->GetNodeID()).get();

Answer 3

这是一种破解，但它可以正常工作，并且不会造成内存泄漏。 您可以做的是添加一个智能指针的静态向量，然后在调用该函数时将指针存储在该向量中，以使它不会在函数末尾超出范围。 看起来像

char* CreateNewString (const char* node) 
{
    std::size_t len = strlen(node) + 1;
    static std::vector<std::unique_ptr<char[]>> data_pool; // static pool, destroyed at end of program
    data_pool.push_back(std::unique_ptr<char[]>(new char [len]{})); // add pointer to pool
    strcpy_s(data_pool.back().get(), len, node); // copy the string
    return data_pool.back().get(); // return pointer to the managed data
}

使用std::unique_ptr ，它可以正确删除数组，因此我们不需要自定义删除器

请注意，使用此解决方案不会造成内存泄漏，但是所有分配的内存将一直持续到程序结束。 您没有获得任何好处，但是至少可以确保在程序终止之前将内存释放。