Question

我想使用返回结果字符串的函数来连接两个字符串。它会是这样的：

char *String_Concat (char *String_1, char *String_2)
{
    char *StringResult;

    //memmove String_1 to StringResult
    //memmove String_2 to StringResult

    return StringResult;
}

我想知道这是否是一种很好的方法，因为我对内存管理知之甚少。 StringResult没有定义的长度，我不确定两次memmove操作后会发生什么。

我想StringResult将被函数本身清理掉，因为我不使用malloc（），对吗？

Answer 1

char *String_Concat (char *String_1, char *String_2)
{
    size_t len1 = strlen(String_1);
    size_t len2 = strlen(String_2);
    char *StringResult = malloc(len1+len2+1);
    //might want to check for malloc-error...
    memcpy(StringResult, String_1, len1);
    memcpy(&StringResult[len1], String_2, len2+1);
    return StringResult;
}

因此，C对于对象具有storage的概念。对象的存储决定了它的生命周期，因为C不是垃圾收集的。如果要创建新字符串，则必须为其保留存储空间。最简单的方法是自动存储，但这与声明它的函数的范围相关联，因此自动变量在函数返回后不再存在。或者，您可以使用静态存储，但不能使用可变大小，并且对该函数的多次调用将使用相同的存储。最后，您可以使用已分配存储，这需要malloc()/calloc()/realloc()/free()。

参见C11标准草案，6.2.4 Storage durations of objects部分

Answer 2

以下是我将如何处理它，使用现有的字符串命令而不是memcpy。我假设你想要一些不影响源字符串的strcat。

char* string_concat(char *dest, const char* string1, const char* string2)
{
   strcpy(dest, string1);
   strcat(dest, string2);
   return dest;
}

要使用它，您需要将指针传递给您希望存储结果的缓冲区。您可以使用malloc使其达到您需要的大小。完成后释放它。

char *str1 = "abc";
char *str2 = "def";
size_t len = strlen(str1) + strlen(str2);
char *newstr = malloc(len + 1);
string_concat(newstr, str1, str2);
printf("%s\n", newstr);
free(newstr);

在没有分配内存的情况下，根本无法处理任意长度的字符串，所以除非你使用固定长度的字符数组，否则你将无法使用malloc / free。如果你想抽象决定分配多大缓冲区的逻辑，你可以这样做：

size_t string_concat(char* dest, char* string1, char* string2)
{
   if(!dest)
   {
      return strlen(string1) + strlen(string2) + 1;
   }
   strcpy(dest, string1);
   strcat(dest, string2);
   return 0;
}

然后你可以问这个分配多少：

char* newstr = malloc(string_concat(0, str1, str2));

但是你失去了返回指向dest的指针的语法上的便利。

Answer 3

这是一个非常糟糕的主意，并且该功能不会神奇地发生“清洁”。

你不能这样做，它不是在C中实现字符串连接的有效方法。

你必须确保在做任何事情之前有足够的可写内存，所以通常你必须拨打malloc()。

Answer 4

如果您想避免动态分配，可以执行类似

的操作

int main( int argc, char **argv)
{
    char        String_1[8] = "Exa";
    /*                   ^ enough space for Example\0 */
    const char *String_2    = "mple";

    printf("%s\n", strcat(String_1, String_2));

    return 0;
}

Answer 5

为了完整性，假设使用memmove()只是一个想法，而不是一个要求，strcpy()和strcat()是这里的首选功能，因为它们是专门为C-＆而工作的＃34;字符串＆＃34;，即0 - 已终止char - 数组。

#include  <stdlib.h> /* for malloc() */
#include  <string.h> /* for strcpy() and strcat() */
#include  <errno.h> /* for errno and EINVAL */

char * stralloc_and_cat(const char * s1, const char * s2)
{ 
  char * s = NULL;

  if ((NULL == s1) || (NULL == s2))
  {
    errno = EINVAL;
  }
  else 
  {
    if (NULL != (s = malloc(strlen(s1) + strlen(s2) + 1)))
    {
      strcpy(s, s1);
      strcat(s, s2);
    }
  }

  return s;
}

并称之为：

#include  <stdlib.h>
#include  <stdio.h>

char * stralloc_and_cat(const char * s1, const char * s2);

int main(void)
{
  char * s1 = "hello ";
  char * s2 = "world";

  char s = stralloc_and_cat(s1, s2);
  if (NULL == s)
  {
    perror("stralloc_and_cat() failed");
  }
  else
  {
    printf("%s\n", s);

    free(s);
  }

  return 0;
}

Answer 6

您必须使用malloc()为生成的concat字符串动态分配一些内存在这种情况下，调用者负责调用free()来释放返回的字符串指针所指向的内存。

另一种方法是设计一个期望指向调用者分配的目标缓冲区的函数的函数，该函数大到足以存储总结果字符串。

在第一个选项之后，您可以考虑这样的代码（live on Ideone）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Concatenates string1 and string2.
// Returns the concatenated (string1+string2), or NULL on errors.
// NOTE: Memory for the returned string is allocated with malloc() 
// by the function, so the caller is responsible to release it with
// a call to free().
char *StringConcat(const char *string1, const char *string2)
{
    char *stringResult;
    size_t len1;
    size_t len2;

    // Check for NULL pointers...
    // (Return NULL, or whatever your design is...)
    if (string1 == NULL || string2 == NULL) {
        return NULL;
    }

    len1 = strlen(string1);
    len2 = strlen(string2);

    // +1 for terminating NUL ('\0')
    stringResult = malloc(len1 + len2 + 1);
    if (stringResult == NULL) {
        return NULL; // Allocation error
    }

    // Copy characters from first string    
    // (exclduing the terminating NUL --> len1)
    memcpy(stringResult, string1, len1);

    // Copy characters from second string
    // (including the terminating NUL --> len2+1)
    memcpy(stringResult + len1, string2, len2+1);

    // Return destination string pointer to the caller.
    // NOTE: Memory must be freed by the caller calling free().
    return stringResult;
}


// *** TEST ***
int main(void)
{
    // Test the function
    char * str = StringConcat("Hello ", "World");

    // Print the resulting string
    printf("%s\n", str);

    // Don't forget to free() memory allocatd by the concat function
    free(str);

    // All right
    return 0;
}

在函数中使用memmove（）连接字符串

6 个答案: