限制 std::string 分配的数量

Question

我有一个函数，它从带有两个数字的const char* 构造一个std::string，作为参数传递，附加到它的末尾。

std::string makeName(const char* name, uint16_t num1, uint16_t num2) {

    std::string new_name(name);
    new_name.reserve(new_name.length()+5);

    new_name += ":";
    new_name += boost::lexical_cast<std::string>(num1);
    new_name += ":";
    new_name += boost::lexical_cast<std::string>(num2);

    return new_name;
}

这个函数被调用数千次，为分配在堆上的小对象创建唯一的名称。

Object* object1= new Object(makeName("Object", i, j)); // i and j are simply loop indices

我发现使用 valgrind 的 massif 工具调用 makeName 会分配大量内存，因为它被调用了很多次。

87.96% (1,628,746,377B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.

->29.61% (548,226,178B) 0xAE383B7: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19)

| ->26.39% (488,635,166B) 0xAE38F79: std::string::_Rep::_M_clone(std::allocator<char> const&, unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19)

| | ->26.39% (488,633,246B) 0xAE39012: std::string::reserve(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19)

| | | ->15.51% (287,292,096B) 0x119A80FD: makeName(char const*, unsigned short, unsigned short) (Object.cpp:110)

| | | | ->15.51% (287,292,096B) in 42 places, all below massif's threshold (01.00%)

我的问题是，如何最大限度地减少这些分配以帮助减少程序使用的总内存量？

编辑： 我还想指出，作为程序要求，我不能使用 c++11 功能。

Answer 1

在这种情况下，只有使用sprintf 的 DIY 自定义转换才有效。

所以我会使用 sprintf 和 MEASURE。

只有当这还不够好时，我才会实现自己的整数到字符串（从许多案例中知道它肯定会更快一些，但不足以证明从那开始是合理的）。

---

示例。而不是当前的高级代码

std::string makeName(const char* name, uint16_t num1, uint16_t num2) {

    std::string new_name(name);
    new_name.reserve(new_name.length()+5);

    new_name += ":";
    new_name += boost::lexical_cast<std::string>(num1);
    new_name += ":";
    new_name += boost::lexical_cast<std::string>(num2);

    return new_name;
}

只是做

auto makeName( const char* const name, const uint16_t num1, const uint16_t num2 )
    -> std::string
{
    std::string result( strlen( name ) + 25, '\0' );    // 25 is large enough.
    int const n = sprintf( &result[0], "%s:%d:%d", name, num1, num2 );
    result.resize( n );
    return result;
}

免责声明：编译器未触及代码。

Answer 2

“我的问题是，我怎样才能最小化这些分配”

我突然想到你有这些名字的原因。您可以在需要时计算它们，而不是总是在构造函数中生成名称吗？那将是最好的改进 - 除非需要，否则不要这样做。

如果你碰巧已经有一个虚拟基础，并且类类型决定了字符串，那就很容易了。否则，枚举类型可以替换字符串，并且您有一个查找表。

Object* object1= new Object(i, j));
std::string Object::getName(){ compute here }

如果这没有帮助，那么您实际上确实需要每个对象的字符串，并且您只能通过优化该函数来获得小幅加速。我注意到您以一种大小构造字符串，然后再将其增长。您也可以使用 char 缓冲区，然后将其分配给成员字符串（在构造函数中）。

Answer 3

是的，您的代码进行了大量分配。分析分配：

std::string new_name(name); // 1
new_name.reserve(new_name.length()+5); // 2

new_name += ":";
new_name += boost::lexical_cast<std::string>(num1); // possibly 4 (boost + operator+=)
new_name += ":"; // possibly 5
new_name += boost::lexical_cast<std::string>(num2); // possibly 7

'可能'，因为它取决于数字所需的字符（越高，越多）。

如果您真的关心内存分配，asprintf（虽然不是标准）或您的版本（基于 s(n)printf 的返回值）可能是最佳选择：

std::string makeName(const char* name, uint16_t num1, uint16_t num2)
{
     char *ptr = nullptr; 
     int size  = asprintf( &ptr, "%s:%u:%u", name, num1, num2);
  return std::string(ptr, size); // to avoid copying the chars
}  

注意：正如@Cheersandhth.-Alf 指出的那样，如果std::string 分配内存失败，ptr 将是 ptr 被泄露。解决此问题的最佳方法是使用 std::unique_ptr，但我会让您根据自己的需要来解决。

如果您不想使用asprintf，您可以使用std::snprintf 获得类似的行为

std::string makeName(const char* name, uint16_t num1, uint16_t num2)
{
    int length = std::snprintf(nullptr, 0, "%s:%u:%u", name, num1, num2);

    if (length > 0 )
    {
        std::string new_name(length + 1, '\0');
        std::snprintf(&new_name[0], new_name.length(), "%s:%u:%u", name, num1, num2);

       return new_name;
    } 
    // else handle failure
} 

与您的版本（我没有使用boost::lexical_cast，但std::to_string）的差异非常大：运行500 次第一个版本使用72,890 字节，而第二个只使用23,890 字节！ （用 valgrind memcheck 测量）