Question

我有以下问题：

char * cs = legacy_function();

我会把它重构为

string s = legacy_function();

但我猜这个程序＆＃34;泄漏＆＃34; cs。我应该写下以下内容吗？

char * cs = legacy_function();
string s = cs; 
delete[] cs;

或者std :: string是否有一个不会复制cs的替代构造函数？

Answer 1

但我猜这个程序“泄漏”了cs。我应该写下以下内容吗？

不要猜。阅读文档。或者如果缺少，请阅读实施。

如果legacy_function使用new[]动态分配字符串，那么是，当您不再需要它时，必须调用delete[]，否则内存会泄漏。

或者std :: string是否有另一个不复制cs的构造函数？

不，它没有。

Answer 2

但我猜这个程序＆＃34;泄漏＆＃34; CS。我应该写的那么呢？

如果您不知道遗留功能是否正在返回动态分配的内存，则无法告诉您。

Answer 3

最好在namespace下创建一个函数层，并在代码的其余部分使用namespace中的函数。

namespace lagacy_wrapper
{
   std::string legacy_function()
   {
      char * cs = ::legacy_function();
      std::string s = cs; 
      delete[] cs; // You'll need to use free(cs) if memory for cs
                   // was allocated using malloc family of functions.
      return s;
   }
}

并使用：

std::string s = lagacy_wrapper::legacy_function();

Answer 4

或者std :: string是否有一个不会复制cs的替代构造函数？

不，它没有。如果legacy_function执行动态分配（当然应该检查这个），则必须将其new[]与实际delete[]匹配，或者让智能指针像这样处理它：

std::string modern_wrapper () {
    std::unique_ptr<char[]> ptr{legacy_function()};
    return std::string(ptr.get());
}

Answer 5

如果您确定由new[]分配的返回指针，并且您一旦调用legacy_function()，则必须使用显式delete[]编写它。您也可以使用std::unique_ptr：

std::unique_ptr<char[]> cs( legacy_function() );
std::string s = cs.get();

但是如果你必须多次调用legacy_function()，我会放一个返回std::string的包装器

Answer 6

#include <string>
#include <iostream>
#include <map>
#include <memory>

char* legacy_function()
{
    char* a = new char[100];
    memcpy(a, "Hello", 6);
    return a;
}

typedef std::unique_ptr<char[]> legacy_string_convert;

using namespace std;
int main()
{
    string s = legacy_string_convert(legacy_function()).get();
    cout << s << endl; 

}

如何在遗留代码中安全地从char *转换为字符串？

6 个答案: