2

作为介绍，请注意我是一名 Java 程序员，仍然习惯于 C++ 中的内存管理问题。

我们有一个基类，用于将对象编码为一串 ASCII 字符。本质上，该类使用stringstream类成员将不同的数据类型转换为一个长字符串，然后将 a 返回char*给包含编码对象数据的调用者。

在测试内存泄漏时，我看到我们使用的实现似乎很容易造成内存泄漏，因为用户必须始终记住删除方法的返回值。以下是代码相关部分的摘录：

    char* Msg::encode() 
    {
        // clear any data from the stringstream
        clear();
        if (!onEncode()) {
            return 0;
        }

        // need to convert stringstream to char*
        string encoded = data.str();
                    // need to copy the stringstream to a new char* because 
                    // stringstream.str() goes out of scope when method ends
        char* encoded_copy = copy(encoded);
        return encoded_copy;
    }

    bool Msg::onEncode(void)
    {
        encodeNameValue(TAG(MsgTags::TAG_USERID), companyName);
        encodeNameValue(TAG(MsgTags::TAG_DATE), date);
        return true;
    }

    bool EZXMsg::encodeNameValue(string& name, int value)
    {
        if(empty(value))
        {
            return true;
        }
                    // data is stringstream object
        data << name << TAG_VALUE_SEPARATOR << value << TAG_VALUE_PAIRS_DELIMITER;
        return true;
    }


    char* copy(string& source) {
        char *a=new char[source.length() +1];
        a[source.length()]=0;
        memcpy(a,source.c_str(),source.length());
        return a;
    }

更新

好吧 - 我应该更准确地了解结果的encode()消耗方式。它被传递给 boost:async_write，并且程序正在崩溃，因为我相信字符串在 async_write 完成之前就超出了范围。似乎我需要将返回的字符串复制到一个类成员，该成员在发送消息（？）的类的生命周期内都是活动的。

这是该encode()方法的实际使用方式（在我将返回值更改为 to 之后string）：

void iserver_client::send(ezx::iserver::EZXMsg& msg) {
       string encoded = msg.encode();   
       size_t bytes = encoded.length();
       boost::asio::async_write(socket_, boost::asio::buffer(encoded, bytes), boost::bind(&iserver_client::handle_write, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));    
}

看起来这样做的正确方法是维护要异步写入的字符串的队列/列表/向量。如此处所述（以及在 boost chat_client 示例中）。（但这是一个单独的问题。）

4

4 回答 4

2

对于这个问题：在你的复制函数中，你返回一个指向堆内存的指针！所以用户可能会造成内存泄漏，我认为你不能使用这个复制函数，你可以在你的编码函数中这样做：

return data.str();

如果你想得到一个char*，你可以使用string的成员函数：c_str()，就像这样：

string ss("hello world");
const char *p = ss.c_str();

如果您使用堆栈字符串对象，则不会造成内存泄漏，

于 2013-07-14T03:06:41.067 回答
1

实现“自动”删除的唯一方法是堆栈变量（在某种程度上）超出范围。事实上，这通常是保证删除的唯一方法，即使在发生异常的情况下也是如此。

正如其他人提到的那样std::string工作得很好，因为char *由 stack-allocated 拥有string，这将删除char *.

这通常不起作用，例如非char *类型。

RAII (Resource Acquisition is Initialization) 是处理诸如内存管理、锁获取/释放等问题的有用习语。

一个好的解决方案是使用 Boost scoped_array，如下所示：

{
  Msg msg;
  msg.userID = 1234;
  scoped_array<char> encoded(msg.encode());
  send(encoded.get());
  // delete[] automatically called on char *
}

scoped_ptr对于非数组类型也同样适用。

仅供参考：你应该习惯于delete[] encoded匹配new char[source.length() +1]

于 2013-07-14T13:43:40.487 回答
1

你可以只返回一个std::string. 反正你有一个：

string Msg::encode() 
{
    // clear any data from the stringstream
    clear();
    if (!onEncode()) {
        return string{};
    }

    return data.str();
}

然后调用者看起来像：

Msg msg;
msg.userID = 1234;
send(msg.encode().c_str());
于 2013-07-14T02:56:12.927 回答
1

虽然使用 astd::string足以解决您的特定问题，但一般的解决方案是返回 astd::unique_ptr而不是原始指针。

std::unique_ptr<char[]> Msg::encode() {
    :
    return std::unique_ptr<char[]>(encoded_copy);
}

unique_ptr然后，用户在调用它时会得到一个新的：

auto encoded = msg.encode();
send(encoded.get());

encoded当超出范围并被销毁时，内存将自动释放。

于 2013-07-14T23:02:28.720 回答