How to write to char* from a function in C

Question

I am struggling to write a char* passed as an argument. I want to write some string to char* from the function write_char(). With the below code, I am getting a segmentation fault.

#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

You have two problems (related to what you try to do, there are other problems as well):

1. Arguments in C are passed by value, which means that the argument variable (c in your write_char function) is a copy of the value from test_char in the main function. Modifying this copy (like assigning to it) will only change the local variables value and not the original variables value.

2. Assigning to a variable a second time overwrites the current value in the variable. If you do e.g.

   int a;
   a = 5;
   a = 10;
   

   you would (hopefully) not wonder why the value of a was changed to 10 in the second assignment. That a variable is a pointer doesn't change that semantic.

---

Now how to solve your problem... The first problem could be easily solved by making the function return a pointer instead. And the second problem could be solved by copying the string into the memory instead of reassigning the pointer.

So my suggestion is that you write the function something like

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
}

This could then be used as

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

Within the function

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

the parameter c is a local variable of the function. Changing it within the function does not influence on the original argument because it is passed by value. That is the function deals with a copy of the original argument.

You have to pass the argument by reference through pointer to it.

Also the function has a memory leak because at first the pointer was assigned with the address of the allocated memory and then reassigned with the address of the first character of the string literal "some string".

If you want to create a copy of a string literal then what you need is the following

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

The program output is

some string

Do not forget to allocate dynamically a character array that is large enough to store also the terminating zero of the string literal.

And you should free the allocated memory when the allocated array is not needed any more.

If you want just to initialize a pointer with the address of a string literal then there is no need to allocate dynamically memory.

You can write

#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

In C, you'll need to pass a pointer to a pointer. Your malloc call is trying to change the value of the variable that's being passed in, but it's actually only a copy. The real variable you pass in will not be changed.

Also, the way that you copy a string into a char* is not using assignment... Here's some revised code:

#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

String assignment in C is very different from most modern languages. If you declare a char * and assign a string in the same statement, e.g.,

char *c = "some string";

that works fine, as the compiler can decide how much memory to allocate for that string. After that, though, you mostly shouldn't change the value of the string with =, as this use is mostly for a constant string. If you want to make that especially clear, declare it with const. You'll need to use strcpy. Even then, you'll want to stay away from declaring most strings with a set string, like I have above, if you're planning on changing it. Here is an example of this:

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

If you're passing a pointer to a function that will reallocate it, or even malloc in the first place, you'll need a pointer to a pointer, otherwise the string in main will not get changed.

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