Returning an array element from an array created within the function in C?

Question

Is this a proper thing to do in C ?

char *func1() {
    char *str[3] = { "so", "is", "amazing" }; 

    return str[1]; 
}

The char *func1() returns an pointer, pointing to a location in memory where the string is stored. But when the func1() returns won't the str array go out of scope and am I not returning a pointer to an object that does not exist? A dangling pointer (is this the right name?)

So I have two solutions make str global so that it never goes out of scope and the pointer always pointer to a valid memory address, but that seems dirty.

The other solutions

char *func2() {
    char *str[3] = { "so", "is", "amazing" };
    int str1Len = strlen(str[1]); 
    char *ret = (char *)malloc(str1Len) ; // create a block of mem to hold the str[1]. 
    strncpy(ret, str[1], str1Len);
    return ret; 
}

Is this correct ? What is the proper way to do this func1() or func2()? Or is there a better way?

I have been using func1() for some time and it has not created any problems for me, does this mean that func1() is doing the right thing? and func2() is unnecessary?

Answer 1

In your first function, there is no problem returning str[1] as it is not pointing to a local variable, it is a pointer to a string literal. Note that string literals should be declared const:

const char *func1(void) {
    const char *str[3] = { "so", "is", "amazing" };
    return str[1]; 
}

Your second function returns a pointer to allocated space. This pointer will need to be freed at some point. The allocation is incorrect, you should allocate 1 extra byte for the final '\0'. You can use strcpy to copy the string to the allocated space, or simply use strdup() that does both:

char *func2(void) {
    const char *str[3] = { "so", "is", "amazing" };
    int size = strlen(str[1]) + 1; 
    char *ret = malloc(size);
    return strcpy(ret, str[1]);
}

Or simply:

char *func2(void) {
    const char *str[3] = { "so", "is", "amazing" };
    return strdup(str[1]);
}

NEVER use strncpy, it does not do what you think it does. It is very error prone for both the programmer and whoever will read your code.

Answer 2

1. Is this a proper thing to do in C ?

   No, it's not! You need to create a copy of the local variable in general, although in this case the pointers point to string literals so it would work.

2. You are allocating and copying the string wrong, you should do this instead

   size_t size =  strlen(str[1]) + 1; 
   char *result = malloc(size) ; // create a block of mem to hold the str[1]. 
   if (result != NULL)
       memcpy(ret, str[1], size);
   

Answer 3

While it is acceptable to return pointers to the string literals, buit not to a local pointer, it might be the wrong approach.

If str does not change, make it static const char * const str[] = .... That qualifies both, the array and the char [] (which is each string literal) it points to const. The static makes it permanent, but with still local scope. It is setup once before your program code starts. In contrast, a non-static version will setup the array for every call.

Note that you have to return a const char * to maintain const-correctness. I strongly recommend that; if you cannot, omit the first const only.

Note: Do not cast the result of malloc & friends (or void * in general) in C.