Thread: beginner question: returning a string from a function

This code "works", but not because it's correct, just because it "happens to".
Multiple issues here. First, string literals, such as "hello world", are really pointers. const char* to be exact. So first you malloc memory, then you overwrite that pointer with something else. Memory leak.
But since string literals are stored in a part of your executable, you can return them as you wish. They work just fine.

Otherwise, you need to send in a buffer to your function, including the size of your buffer, and copy data into it. Make sure you don't copy more data than you have room. That's why you need your size parameter.
And finally, main returns int and your getString prototype is mismatching.

Don't forget that test must an array with sufficient storage, such as:

Code:

char test[100];
strcpy(test, "This is a string");

nonoob's suggestion is a correct one and Elysia's assertion is certainly right, but if you integrate Elysia's example into your code, you would then be returning a pointer to a local variable, which is wrong. Rather, one might write:

Code:

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

char *getString(void);

int main(void) {
    char *test = getString();
    printf("%s\n", test);
    free(test);
    return 0;
}

char *getString(void) {
    char *test = malloc(20 * sizeof(*test));
    strcpy(test, "this is a string");
    return test;
}

Observe that the correct headers were included, and that I removed the cast of the return value of malloc. Furthermore, sizeof(char) is always 1, so you could leave it out, but I chose to change it to the more general sizeof(*test).

EDIT:
Additionally, one should check that malloc did not return a null pointer before accessing the memory presumed to be allocated.

This amounts to having to free the malloc later which is certainly easy to forget and error prone. Furthermore, it is inflexible, because you cannot choose whether to use dynamic memory or not. And it is slower because dynamic memory is slower than stack based allocation.
Which amounts to passing in a buffer to the function as I mentioned in the first place.