C 如何返回字符串地址，然后将其分配给新字符串？

我有一个函数，我想将分配字符串的地址返回给主函数，并分配一个具有相同地址的新字符串指针，以便新字符串包含旧字符串的内容

例如：

 unknown_datatype function()
 {
      char *old = "THE STRING";
      return old;
 }

 int main()
 {
      char *snew = "";
      snew = function();
      return 0;
 }

*未知的数据类型意味着我不知道要放在那里

---

*如何在不更改main（）方法中的任何内容的情况下实现这一点

您只需返回一个

char*

。由于要返回指向字符串文字的指针，最好返回

常量char*

，因为您无法修改字符串文字：

const char* function()

同样，您希望将返回值分配给

常量char*

：

const char* snew = 0;
snew = function();

---

您只需返回一个

char*

。由于要返回指向字符串文字的指针，最好返回

常量char*

，因为您无法修改字符串文字：

const char* function()

同样，您希望将返回值分配给

常量char*

：

const char* snew = 0;
snew = function();

---

通常，您将传入字符数组中第一个元素的地址以及长度，并让函数填充它

int fillMyString(char *str, int buffer_size)
{
  if(buffer_size > strlen("test"))
  {
    strncpy(str, "test", buffer_size-1);
    str[buffer_size-1] = '\0';
    return strlen(str);
  }

  return 0;
}


//In some function or main
char buffer[1024];
fillMyString(buffer, 1024);
ASSERT(!strcmp(buffer, "test"));

---

编辑：您提到出于某种原因需要返回字符*。在这种情况下，我建议使用

malloc

来分配函数中的字符串，但要确保无论何时调用函数，最终都会释放返回值。

通常，您会传入字符数组中第一个元素的地址以及长度，并让函数填充它

int fillMyString(char *str, int buffer_size)
{
  if(buffer_size > strlen("test"))
  {
    strncpy(str, "test", buffer_size-1);
    str[buffer_size-1] = '\0';
    return strlen(str);
  }

  return 0;
}


//In some function or main
char buffer[1024];
fillMyString(buffer, 1024);
ASSERT(!strcmp(buffer, "test"));

---

编辑：您提到出于某种原因需要返回字符*。在这种情况下，我建议使用

malloc

来分配函数中的字符串，但要确保无论何时调用函数，最终都会释放返回值。

未知数据类型必须是

char*

，但在这种情况下，由于

函数中的变量（）

是局部变量，一旦函数退出并从堆栈中弹出，它们就会消失。您可以在函数内部使用

malloc（）

调用并返回指向新字符串的指针。只是别忘了用完后把它放出来

未知数据类型必须是

char*

，但在这种情况下，它不会像您期望的那样执行，因为

function（）

中的变量是局部变量，一旦函数退出并从堆栈中弹出，这些变量就会消失。您可以在函数内部使用

malloc（）

调用并返回指向新字符串的指针。只是别忘了用完后把它放出来

正如Brian指出的，在C中最惯用的方法是传递缓冲区，因此您可以：

int give_me_a_string(char* buffer, int buffersize) { const char* result = "Hello world!"; int requiredbufferlen = strlen(result)+1; if ( (buffer==0) || (buffersize<requiredbufferlen) ){ errno = EINVAL; return -1; } strncpy(buffer,"Hello world!",buffersize); buffer[buffersize-1]='\0'; return 0; } int main(int argc, char* argv[]) { int buffersize = 256; char* buffer = (char*) malloc(buffersize); if ( buffer == 0 ){ printf("Out of memory!\n"); return 1; } if ( give_me_a_string(buffer,buffersize) < 0 ){ printf("Oh my god, there's an error!\n"); free(buffer); return 1; }else{ printf("%s\n",buffer); } free(buffer); return 0; } 最后一个解决方案不需要任何释放，因为函数本身就是所有者。如果使用计算字符串执行此操作，它将如下所示：

// declaration char* give_me_a_string(void); // implementation char* global_string = 0; static void deallocate_global_string() { free(global_string); global_string=0; } char* give_me_a_string(void) { if ( global_string == 0){ // allocate global_string // ... // initialize global_string // ... // ensure it is eventually freed atexit(&deallocate_global_string); } return global_string; } //声明 char*给我一个字符串（void）； //实施 字符*全局_字符串=0； 静态无效解除分配\u全局\u字符串（） { 自由（全局_字符串）； 全局_字符串=0； } char*给我一个字符串（void） { if（全局_字符串==0）{ //分配全局字符串 // ... //初始化全局字符串 // ... //确保它最终被释放 atexit（&deallocate_global_string）； } 返回全局_字符串； }

---

显而易见，如果您这样做，它是不可重入的（它不能与多个线程一起工作），因此这是一个非常非常糟糕的想法。如果你被烧坏了，让我说，我警告过你。

正如Brian指出的，在C语言中最惯用的做法是传递缓冲区，所以你会：

int give_me_a_string(char* buffer, int buffersize) { const char* result = "Hello world!"; int requiredbufferlen = strlen(result)+1; if ( (buffer==0) || (buffersize<requiredbufferlen) ){ errno = EINVAL; return -1; } strncpy(buffer,"Hello world!",buffersize); buffer[buffersize-1]='\0'; return 0; } int main(int argc, char* argv[]) { int buffersize = 256; char* buffer = (char*) malloc(buffersize); if ( buffer == 0 ){ printf("Out of memory!\n"); return 1; } if ( give_me_a_string(buffer,buffersize) < 0 ){ printf("Oh my god, there's an error!\n"); free(buffer); return 1; }else{ printf("%s\n",buffer); } free(buffer); return 0; } 最后一个解决方案不需要任何释放，因为函数本身就是所有者。如果使用计算字符串执行此操作，它将如下所示：

// declaration char* give_me_a_string(void); // implementation char* global_string = 0; static void deallocate_global_string() { free(global_string); global_string=0; } char* give_me_a_string(void) { if ( global_string == 0){ // allocate global_string // ... // initialize global_string // ... // ensure it is eventually freed atexit(&deallocate_global_string); } return global_string; } //声明 char*给我一个字符串（void）； //实施 字符*全局_字符串=0； 静态无效解除分配\u全局\u字符串（） { 自由（全局_字符串）； 全局_字符串=0； } char*给我一个字符串（void） { if（全局_字符串==0）{ //分配全局字符串 // ... //初始化全局字符串 // ... //确保它最终被释放 atexit（&deallocate_global_string）； } 返回全局_字符串； }

---

显而易见，如果您这样做，它是不可重入的（它不能与多个线程一起工作），因此这是一个非常非常糟糕的想法。如果您被烧坏了，我只想说，我警告过您。

好的，答案是：由于我无法编辑main（意味着我无法传递任何参数），以下解决方案是可能的：

char *function()
{

    char *old;
    old = (char*)malloc(9999);
    strcpy(old,"THE STRING");
    return old;
}

int main()
{
    char *snew = "";
    snew = function();
    return 0;
}

---

感谢所有回复者。

好，以下是答案：由于我无法编辑main（意味着我无法传递任何参数），因此以下解决方案是可能的：

char *function()
{

    char *old;
    old = (char*)malloc(9999);
    strcpy(old,"THE STRING");
    return old;
}

int main()
{
    char *snew = "";
    snew = function();
    return 0;
}

char * function()
{
    char *old = "THE STRING";
    return old;
}

int main()
{
     char *snew = "";
     snew = function();
     return 0;
}

---

感谢所有的回复。

你的问题和例子相互矛盾

char * function()
{
    char *old = "THE STRING";
    return old;
}

int main()
{
     char *snew = "";
     snew = function();
     return 0;
}

这就是你要找的吗？下面给出两个简单的解决方案

char*func（char*）

int main（）

{

}

char*func（char*s）

{

}

或者，假设您的字符串是在函数调用中创建的，那么Y_Y给出的解决方案也可以。为了防止您不想使用malloc，下面的解决方案是有效的

char*func（）

int main（）

{

}

char*func（）

{

---

}你的问题和例子相互矛盾

这就是你要找的吗？下面给出两个简单的解决方案

char*func（char*）

int main（）

{

}

char*func（char*s）

{

}

或者，假设您的字符串是在函数调用中创建的，那么Y_Y给出的解决方案也可以。为了防止您不想使用malloc，下面的解决方案是有效的

char*func（）

int main（）

{

}

char*func（）

{

}

这不是e