将 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

我在以下代码中看到内存泄漏！

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分配新内存并将其分配给已经存在的指针指向有效的内存位置并包含有效的 struct str 数据！ ..可以通过执行以下操作进行简单检查来避免这种情况

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);
}