Can a function return char variable?

Can a function return char variable? For example "Billys".

If the string literal "Billys" was defined in a function, it would be gone as soon as the function was gone, with a couple of exceptions. If you did something like:

Code:

---

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

char *foo(void)
{
    static char str[10];
    strcpy(str, "Hello");
    return str;
}

int main(void)
{
    printf("%s, world!\n", foo());
    return 0;
}

---

you could pass the pointer to the string back, because that storage will stay in effect for as long as your program is executing. That said, I am not sure I would recommend doing it. Perhaps some of the other regulars here would care to comment on the pros and cons of such a construct.

Your best bet would be to pass in a pointer to an existing array, as well as the size of the array, and then modify that array from the function (i.e., put your string into it). Or you could malloc some memory in your function, get the string into that, and pass the pointer back. If you use malloc, don't forget to free the memory when you are done with it.

Quote:

---

Originally Posted by kermit

If the string literal "Billys" was defined in a function, it would be gone as soon as the function was gone, with a couple of exceptions.

---

Returning string literals is OK. Don't quote me on it, but I think string literals are stored in static memory anyway. At any rate, this compiles cleanly with -ansi -pedantic -Wall on.

Code:

---

#include <stdio.h>
const char * foo( void )
{
    printf( "%s is located at %p\n" , "Billys" , ( void* )"Billys" );
    return "Billys";
}
int main( void )
{
    const char *p = foo( );
    printf( "p = %p, %s\n" , ( void* )p , p );
    return 0;
}

---

[edit] As whiteflags has beaten me to saying: [/edit] Actually, a string literal is one of the few things that can be returned from a function. Since string literals are declared in static memory, code like

Code:

---

return "Hello";

---

returns a pointer to data that is still in scope for the caller. But string literals, malloc()'d data, and pointers to static arrays are about the only strings that can be returned from functions.

Depending on what you are trying to do, you'll probably want to use something like this.

Code:

---

void f1(char *buffer, int size) {
    /* ... */
}

char *f2(void) {
    char *p = malloc(/* ... */);
    /* ... */
    return p;
}

void split_name(const char *full_name, char **last_name, char **first_name) {
    /* ... */
    *last_name = malloc(/* ... */);
    /* ... */
}

---

Passing in a buffer is nice if you already know how big the data is going to be. If you're going to malloc() your own buffer of some arbitrary size, it may be simplest to return the new buffer. And if you need to return multiple arrays you might need to switch to char** parameters.

Having a function that returns a string literal seems completely useless to me and a computational burden, although it is possible. If you know the string you are going to return in advance just use it as it is or put it in some preprocessor command. Having to do two context switches between the calling function to the function returning the string and then back is just a waste of time.

Quote:

---

Originally Posted by claudiu

Having a function that returns a string literal seems completely useless to me and a computational burden, although it is possible. If you know the string you are going to return in advance just use it as it is or put it in some preprocessor command. Having to do two context switches between the calling function to the function returning the string and then back is just a waste of time.

---

Wouldn't it be useful for handling texts and their translations through a DLL? E.g. call the function with parameter X to get a pointer to text in language Y that is then used to print the string? :)

Quote:

---

Originally Posted by claudiu

Having a function that returns a string literal seems completely useless to me and a computational burden, although it is possible. If you know the string you are going to return in advance just use it as it is or put it in some preprocessor command. Having to do two context switches between the calling function to the function returning the string and then back is just a waste of time.

---

It is useful if a different literal is returned depending on argument.

For example (although I don't advocate this and provide the example for illustrative purposes only)....

Code:

---

enum MethodDown {Fell, Tumbled, Unknown};

char *Who(MethodDown  value)
{
    switch (value)
    {
        case Fell:  return "Jack";
        case Tumbled: return "Jill";
        default : return (char *) NULL;
    }
}

---

Quote:

---

Originally Posted by grumpy

It is useful if a different literal is returned depending on argument.

For example (although I don't advocate this and provide the example for illustrative purposes only)....

Code:

---

enum MethodDown {Fell, Tumbled, Unknown};

char *Who(MethodDown  value)
{
    switch (value)
    {
        case Fell:  return "Jack";
        case Tumbled: return "Jill";
        default : return (char *) NULL;
    }
}

---

---

Indeed, I did not think of this use.

If you're going to have many possibilities, it's best to use array.

Code:

---

enum MethodDown {Fell, Tumbled, ... , Unknown};

const char *Who(MethodDown  value)
{
    static const char *Method_names[ ] = {
                    "Jack",
                      "Jill",
                      ...      /* many more */
              };
    if( value >= Fell && value < Unknown )
          return Method_names[value];
    else return NULL;
}

---

But, it's not thread safe. =(
Unless Method_names is not declared as static.

http://www.eskimo.com/~scs/cclass/int/sx5.html

Quote:

---

Originally Posted by Bayint Naung

If you're going to have many possibilities, it's best to use array.

Code:

---

enum MethodDown {Fell, Tumbled, ... , Unknown};

const char *Who(MethodDown  value)
{
    static const char *Method_names[ ] = {
                    "Jack",
                      "Jill",
                      ...      /* many more */
              };
    if( value >= Fell && value < Unknown )
          return Method_names[value];
    else return NULL;
}

---

But, it's not thread safe. =(
Unless Method_names is not declared as static.

---

Not true. That's perfectly threadsafe as-is. Nothing is ever modifying anything in that snippet, and multiple threads are free to use any of the pointers to those string literals simultaneously.