将 var 分配给 var - 会起作用吗？

Question

我正在尝试为我正在开发的包装器做一些有用的事情。我正在为 C 的标准字符串库编写一个包装器，因为我不喜欢它。

我现在不想将 C 字符串引入我的包装器。我有一个名为 `str 的结构，其中包含字符串的长度和缓冲区：

struct str
{
    char *buf;
    size_t len;
};

在我的头文件中，我有这个：

typedef struct str str;

现在我已经实现了封装（我认为）。

所以我声明这样的字符串：

str *a_string = NULL;

我已经完成了我想做的所有事情，但是我有一个问题。我想为一个功能添加这样的东西：

str.h:

extern str *str_str(str *, char *);

和str.c

str *str_str(str *buf, char *ns)
{
    buf->len = strlen(ns);
    buf->buf = (char *) malloc(buf->len + 1);
    strncpy(buf->buf, ns, buf->len);
    return buf;
}

测试效果很好：

str *s = str_new();
printf("%s\n", str_cstr(str_str(s, "hello")));

output: hello

但这会起作用吗？

str_assign(s, str_str(s, "ok"));

我认为这实际上是将s 分配给s。当我打印时，它什么也不打印！

我没有收到任何错误！ 非常感谢所有帮助。我是 C 语言的新手。

str_assign()的来源：

void str_assign(str *s1, str *s2)
{
    s1->len = s2->len;
    s1->buf = (char *) malloc(s2->len + 1);
    strncpy(s1->buf, s2->buf, s2->len);
}

Answer 1

我知道这是 C，但将其与 C++ 进行比较很有用。当您在 C++ 中编写赋值运算符时，您总是必须考虑自赋值的情况。当你在 C 中做同样的工作时也是如此。

因此，我认为你需要：

void str_assign(str *s1, const str *s2)
{
    if (s1 != s2)
    {
        free(s1->buf);  // Added!
        s1->len = s2->len;
        if ((s1->buf = (char *) malloc(s2->len + 1)) != 0)
            memcpy(s1->buf, s2->buf, s2->len + 1);
        else
            s1->len = 0;  // Is this sufficiently safe with a null buf?
    }
}

您可以使用memcpy()，因为 (a) 保证字符串是不相交的，并且 (b) 您知道字符串有多长，因此您不需要在每一步都检查字符串的结尾就像使用 strncpy() 或 strcpy() 一样。

实际上，有一种情况可以说您永远不需要使用strcpy() 或strncpy() 或strcat() 或strncat()；您应该始终知道源字符串和目标字符串的长度（否则您无法确定不会出现缓冲区溢出），因此您始终可以使用memmove() 或memcpy()。

---

我还注意到，您有时会不得不担心内存泄漏。我刚刚修改了上面的分配以释放旧字符串，然后用新字符串覆盖它。

您还可以通过仅在新字符串比旧字符串长时分配新空间来优化操作。您也可以考虑使用realloc() 而不是malloc()。但是，您必须小心内存泄漏陷阱。这是realloc()的错误用法：

s1->buf = realloc(s1->buf, s1->len + 1);

如果 realloc() 失败，您只是用 null 覆盖了您的观点 - 失去了对旧空间的唯一引用。您应该始终将realloc() 的结果存储在与第一个参数不同的变量中：

char *new_buf = realloc(s1->buf, s1->len + 1);
if (new_buf == 0)
    ...handle out of memory condition...

您最终可能决定在结构中保留两个长度 - 分配的空间和使用的空间。然后你可以更有效地重用空间，只在新字符串比之前分配的空间长时分配更多空间，但仍然允许你随时缩短字符串。

Answer 2

你需要在你的str_str函数中有一个return语句，所以添加return buf;。

如果您稍微考虑一下，您会发现您的 str_assign 函数中有一个错误，因为在您更改 s1->buf 指针后，您实际上是在更改 s2->buf 也是因为它们指向同一个结构。下面是一个更适合您的实现：

str * str_assign(str * dest, const str * src)
{
    char * old_buffer = dest->buf;
    if (src->buf)
    {
       char * buf = malloc(src->len+1);
       strncpy(buf, src->buf, src->len);
       dest->buf = buf;
       dest->len = src->len;
    }
    else
    {
       dest->buf = 0;
    }

    if (old_buffer)
    {
      free(old_buffer);
    }
    return dest;
}

Answer 3

我在下面的代码中看到了memory leak！

void str_assign(str *s1, str *s2)
{
    s1->len = s2->len;
    s1->buf = (char *) malloc(s2->len + 1);
    strncpy(s1->buf, s2->buf, s2->len);
}

如果s1 和s2 指向同一个内存位置，那么您将使用malloc 分配新内存并将其分配给已经指向有效内存位置并包含有效@987654326 的指针@ 数据！ ..这可以通过执行以下操作进行简单检查来避免

void str_assign(str *s1, str *s2)
{
    if (s1 == s2)
        return;

    /* 
    if s1 is pointing to any valid memory 
    then free it before making it point to 
    the memory that was allocated by malloc.
    */
    if (s1 != NULL)
        free(s1);

    if ((s1->buf = (char *) malloc(s2->len + 1)) == NULL) {
        printf("ERROR: unable to allocate memory\n");
        return;
    }

    s1->len = s2->len;
    strncpy(s1->buf, s2->buf, s2->len);
}