0

您好我正在尝试将 char * 指针复制到 char [] 数组。

这是我到目前为止的代码

char * string_add(char * base, char * toAdd)
{
    char * string=malloc(strlen(base)+streln(toAdd)+1);
    sprintf(string,"%s%s",base,toAdd);
    char returnString[strlen(string)+1]; 
    // here comes my problem:
    memcpy(returnString,string,strlen(string)+1);
    // want to add free(string) here
    return returnString;
}

我想用这样的功能来保存代码。我不想照顾每个分配的内存。我也试过

memcpy(&returnString,string,strlen(string)+1);

以及一些带有 strcpy 和 strncpy 的变体。但以下问题仍然存在：

如果我像这样调用该函数两次：

int main(int argc, char * argv[])
{
    char * str1=string_add(argv[1],"-test1"); 
    char * str2=string_add(argv[1],"-test2"); 
    printf("%s, %s", str1,str2);
}

输出是这样的：

abc-test2, abc-test2

我怎么能意识到这一点？

先感谢您！

4

5 回答 5

3

在 C 中，您必须照顾 malloc 的内存，您声明的 char 数组在堆栈上，并且在函数返回后将消失，只有 malloc 内存会挂起。是的，你必须照顾它并清理它。

于 2013-08-18T21:24:06.013 回答
0

我假设对您的函数的第二次调用会覆盖第一次调用创建的缓冲区的内容。

据我了解，您正在尝试连接两个字符串。

看看这个答案。

基本上，由于在编译时不知道字符串的长度，因此您需要分配动态内存，同时free在处理完新的string.

于 2013-08-18T21:28:16.653 回答
0

在函数中

char * string_add(char * base, char * toAdd)
{
    char * string=malloc(strlen(base)+streln(toAdd)+1);
    sprintf(string,"%s%s",base,toAdd);
    char returnString[strlen(string)+1]; 
    // here comes my problem:
    memcpy(returnString,string,strlen(string)+1);
    // want to add free(string) here
    return returnString;
}

您定义returnString[]但它只存在于函数的范围内。所以你必须改变使用和声明背后的逻辑returnString[]

于 2013-08-18T21:35:29.257 回答
0

基本上，未malloc'ed 的存储在例程结束后不会持续存在。您也许可以使用全局变量，但这会使一个简单的任务复杂化，即连接两个字符串。

char * string_add(char * base, char * toAdd)
{
    char *string_ptr = malloc(strlen(base)+streln(toAdd)+1);

    sprintf(string_ptr, "%s%s", base, toAdd);

    // string_ptr points to heap storage that is permanent
    return string_ptr;
}

// in main() ....

char *s1 = string_add("A", "B");
// s1 points to storage on the heap as: "AB\0"
//
free(s1);  // OR allow system to clean-up when main() exits
于 2013-08-18T21:36:15.993 回答
0

所以这段代码有点问题。首先你做：

char * string=malloc(strlen(base)+streln(toAdd)+1);

这是错误的，假设每个字符都是 1 个字节，这取决于平台。更好的做法是：

char * string=malloc((strlen(base)+streln(toAdd)+1) * sizeof(char));

加上 malloc 在 CPU 时间方面很昂贵，而且您不会释放它。在该代码中执行您正在执行的操作甚至不需要 malloc。只需这样做：

char returnString[strlen(base) + strlen(toAdd) + 1];

其次，您应该以不同的方式处理字符串。你可以做的是：

strcpy(returnString,base);
strcat(returnString,toAdd);

或者。对这样的事情做的最好的事情是在你的主 str1 和 str2 中声明，在 main 中分配它们，将指针传递给指向函数的指针。像我上面显示的那样让函数复制/收集数据。然后完成。现在你不需要处理返回类型和所有内部 mallocing 和诸如此类的废话。使用后，您只需在 main 中处理两个 malloc，在 main 中处理 2 个 free。这是伪代码：

int main(int argc, char *argv[])
{
    char * str1 = (char *) malloc((sizeof(argv[1]) + sizeof("-test1")) * sizeof(char));
    //do same for str2
    copyString(&str1,argv[1],"-test1");
    //do same for str2
    //print
    //free like this:
    free(str1);
    //do same for str2
    return 0;
}

现在这里是 copyString 函数：

void copyString(char ** returned, char * base, char * add)
{
    strcpy(returned,base);
    strcat(returned,add);
}
于 2013-08-18T22:12:48.473 回答