改变 C 字符串时避免内存泄漏

Question

出于教育目的，我在一些测试程序中使用 cstrings。 我想用“...”等占位符来缩短字符串。

也就是说，如果我的最大长度设置为 13，“Quite a long string” 将变为 “Quite a lo...”。此外，我不想销毁原始字符串 - 因此缩短的字符串必须是副本。

下面的（静态）方法是我想出的。 我的问题是：为我的缩短字符串分配内存的类也应该负责释放它吗？ 我现在所做的是将返回的字符串存储在单独的“用户类”中，并推迟将内存释放给该用户类。

const char* TextHelper::shortenWithPlaceholder(const char* text, size_t newSize) {
    char* shortened = new char[newSize+1];

    if (newSize <= 3) {
        strncpy_s(shortened, newSize+1, ".", newSize);
    }
    else {
        strncpy_s(shortened, newSize+1, text, newSize-3);
        strncat_s(shortened, newSize+1, "...", 3);  
    }
    return shortened;
}

Answer 1

此类函数的标准方法是让用户传入 char[] 缓冲区。 例如，您可以在像 sprintf() 这样的函数中看到这一点，这些函数将目标缓冲区作为参数。 这允许调用者负责分配和释放内存，将整个内存管理问题放在一个地方。

Answer 2

为了避免缓冲区溢出和内存泄漏，在这种情况下，您应该始终使用 C++ 类，例如 std::string。

只有最后一个实例才应将类转换为低级别的内容，例如 char*。 这将使您的代码简单且安全。 只需将代码更改为：

std::string TextHelper::shortenWithPlaceholder(const std::string& text,
                                               size_t newSize) {
    return text.substr(0, newSize-3) + "...";
}

在 C 上下文中使用该函数时，只需使用 cstr() 方法：

some_c_function(shortenWithPlaceholder("abcde", 4).c_str());

仅此而已！

一般来说，您不应该像使用 C 编程那样使用 C++ 进行编程。将 C++ 视为一种完全不同的语言更为合适。

Answer 3

我从来不高兴返回指向本地分配的内存的指针。 我喜欢对任何调用我的清理功能的人保持健康的不信任。

相反，您是否考虑过接受一个缓冲区并将缩短的字符串复制到其中？

例如。

const char* TextHelper::shortenWithPlaceholder(const char* text, 
                                               size_t textSize, 
                                               char* short_text, 
                                               size_t shortSize)

其中 short_text = 复制缩短字符串的缓冲区，shortSize = 提供的缓冲区大小。 您还可以继续返回指向 short_text 的 const char* ，以方便调用者（如果 shortSize 不够大，则返回 NULL到）。

Answer 4

实际上，您应该只使用 std::string，但如果必须，请查看现有库以获取使用指南。

在C标准库中，最接近你正在做的事情的函数是

char * strncpy ( char * destination, const char * source, size_t num );

所以我会这样做：

const char* TextHelper::shortenWithPlaceholder(
    char * destination, 
    const char * source, 
    size_t newSize);

调用者负责内存管理 - 这允许调用者使用堆栈，或堆，或内存映射文件或保存该数据的任何来源。 您不需要记录您使用 new[] 来分配内存，并且调用者不需要知道使用 delete[] 而不是 < code>free 或 delete，甚至是较低级别的操作系统调用。 将内存管理留给调用者只会更灵活，并且更不容易出错。

返回指向目的地的指针只是允许您执行以下操作的一个好处：

char buffer[13];
printf("%s", TextHelper::shortenWithPlaceholder(buffer, source, 12));

Answer 5

最灵活的方法是返回一个包装分配内存的辅助对象，这样调用者就不必担心它。 该类存储指向内存的指针，并具有复制构造函数、赋值运算符和析构函数。

class string_wrapper
{
    char *p;

public:
    string_wrapper(char *_p) : p(_p) { }
    ~string_wrapper() { delete[] p; }

    const char *c_str() { return p; }

    // also copy ctor, assignment
};

// function declaration
string_wrapper TextHelper::shortenWithPlaceholder(const char* text, size_t newSize)
{
    // allocate string buffer 'p' somehow...

    return string_wrapper(p);
}

// caller
string_wrapper shortened = TextHelper::shortenWithPlaceholder("Something too long", 5);

std::cout << shortened.c_str();

大多数实际程序都使用 std::string 来实现此目的。

Answer 6

在您的示例中，调用者别无选择，只能负责释放分配的内存。

然而，这是一个容易出错的习惯用法，我不建议使用它。

允许您使用几乎相同代码的一种替代方法是将 shortened 更改为引用计数指针，并让方法返回引用计数指针而不是裸指针。

Answer 7

我认为有两种同样常见的基本方法：
a) TextHelper 返回 c 字符串并忘记它。 用户必须删除内存。
b) TextHelper 维护已分配字符串的列表，并在销毁时释放它们。

现在这取决于您的使用模式。 b) 对我来说似乎有风险：如果 TextHelper 必须取消分配字符串，那么在用户处理完缩短的字符串之前，它不应该这样做。 您可能不知道这一点何时到来，因此您使 TextHelper 保持活动状态，直到程序终止。 这会导致内存使用模式等同于内存泄漏。 我建议仅当字符串在语义上属于提供它们的类时才使用 b)，类似于 std::string::c_str()。 您的 TextHelper 看起来更像是一个工具箱，不应与已处理的字符串相关联，因此如果我必须在两者之间进行选择，我会选择 a)。 考虑到固定的 TextHelper 接口，您的用户类可能是最好的解决方案。

Answer 8

编辑：不，我错了。 我误解了你想要做什么。 调用者必须删除实例中的内存。

C++ 标准规定删除 0/NULL 不会执行任何操作（换句话说，这样做是安全的），因此无论您是否调用过该函数，都可以删除它。 编辑：我不知道这是怎么被遗漏的......你的另一个选择是放置删除。 在这种情况下，即使形式不好，您也应该使用placement new 将分配/释放保持在同一位置（否则不一致会使调试变得荒谬）。

也就是说，您如何使用该代码？ 我不知道什么时候你会多次调用它，但如果你这样做，如果你不记得每个不同的内存块，就会有潜在的内存泄漏（我认为）。

我只会使用 std::auto_ptr 或 Boost::shared_ptr。 它在退出时会删除自身，并且可以与 char* 一起使用。

您可以做的另一件事是考虑 TextHelper 的分配方式。 这是一个理论演员：

TextHelper(const char* input) : input_(input), copy(0) { copy = new char[sizeof(input)/sizeof(char)]; //mess with later }
~TextHelper() { delete copy; }