如何从 C 中的函数写入 char*

Question

我正在努力编写作为参数传递的 char*。我想从函数 write_char() 向 char* 写入一些字符串。使用下面的代码，我遇到了分段错误。

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

void write_char(char* c){
    c = (char*)malloc(11*(sizeof(char)));
    c = "some string";
}

int main(){
    char* test_char;
    write_char(test_char);
    printf("%s", test_char);

    return 0;
}

Answer 1

您有两个问题（与您尝试做的事情有关，还有其他问题）：

1. C 中的参数是按值传递的，这意味着参数变量（write_char 函数中的c）是来自test_char 中的值的副本 main 函数。修改这个副本（比如给它赋值）只会改变局部变量的值，而不是原来的变量值。

2. 再次分配给变量会覆盖变量中的当前值。如果你这样做，例如

   int a;
   a = 5;
   a = 10;
   

   您（希望）不会想知道为什么在第二个作业中a 的值被更改为10。变量是指针并不会改变语义。

---

现在如何解决您的问题... 第一个问题可以通过将函数 return 改为指针来轻松解决。第二个问题可以通过将字符串复制到内存中而不是重新分配指针来解决。

所以我的建议是你编写类似的函数

char *get_string(void)
{
    char *ptr = malloc(strlen("some string") + 1);  // Allocate memory, +1 for terminator
    strcpy(ptr, "some string");  // Copy some data into the allocated memory
    return ptr;  // Return the pointer
}

这可以用作

char *test_string = get_string();
printf("My string is %s\n", test_string);
free(test_string);  // Remember to free the memory we have allocated

Answer 2

函数内

void write_char(char* c){
    c = (char*)malloc(11*(sizeof(char)));
    c = "some string";
}

参数c是函数的局部变量。在函数内更改它不会影响原始参数，因为它是按值传递的。那就是该函数处理原始参数的副本。

你必须通过指向它的指针通过引用传递参数。

该函数也有内存泄漏，因为首先为指针分配了已分配内存的地址，然后重新分配了字符串文字 "some string" 的第一个字符的地址。

如果您想创建字符串文字的副本，那么您需要的是以下内容

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

void write_char( char **s )
{
    const char *literal = "some string";
    *s = malloc( strlen( literal ) + 1 );

    if ( *s ) strcpy( *s, literal );
}

int main( void )
{
    char *test_char = NULL;

    write_char( &test_char );

    if ( test_char ) puts( test_char );

    free( test_char );
}    

程序输出是

some string

不要忘记动态分配一个足够大的字符数组来存储字符串文字的终止零。

当不再需要分配的数组时，你应该释放分配的内存。

如果你只想用字符串字面量的地址初始化一个指针，那么就不需要动态分配内存。

你可以写

#include <stdio.h>

void write_char( char **s )
{
    *s = "some string";
}

int main( void )
{
    char *test_char = NULL;

    write_char( &test_char );

    puts( test_char );
}    

Answer 3

在 C 中，您需要将指针传递给指针。您的 malloc 调用试图更改正在传入的变量的值，但它实际上只是一个副本。你传入的真实变量不会改变。

另外，将字符串复制到 char* 的方式不是使用赋值...这是一些修改后的代码：

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

void write_char(char** c){
    size_t len = strlen("some string");
    *c = (char*)malloc(len + 1); // + 1 for null termination
    strncpy(*c, "some string", len);
}

int main(){
    char* test_char;
    write_char(&test_char);
    printf("%s", test_char);

    return 0;
}

Answer 4

C 中的字符串赋值与大多数现代语言非常不同。如果您声明 char * 并在同一语句中分配一个字符串，例如，

char *c = "some string";

这很好用，因为编译器可以决定为该字符串分配多少内存。不过，在那之后，您通常不应该使用= 更改字符串的值，因为这种用法主要用于常量字符串。如果您想特别清楚，请使用const 声明它。您需要使用strcpy。即使那样，如果您打算更改它，您仍希望避免使用设置字符串声明大多数字符串，就像我上面所说的那样。这是一个例子：

char *c;
c = malloc(16 * sizeof(char));
strcpy(c, "Hello, world\n");

如果您传递一个指向将重新分配它的函数的指针，或者甚至首先是malloc，您将需要一个指向指针的指针，否则main 中的字符串不会被更改。

void myfunc(char **c) {
    char *tmp = realloc(*c, 32 * sizeof(char));
    if(tmp != NULL) {
        *c = tmp;
    }
}

char *c = malloc(16 * sizeof(char));
strcpy(c, "Hello, world\n");
myfunc(&c);

Answer 5

char* test_char="string"; // initialize string at the time of declaration


void write_char(char* c){
    c = (char*)malloc(11*(sizeof(char)));

}

int main(){
    char* test_char="strin";
    write_char(test_char);
    printf("%s", test_char);

    return 0;
}