Thread: Getting a function to return a string

You're declaring those strings on the stack, local to that function, but then trying to return a pointer to it (sort of), which is a nono.

You can fix problem 1 by declaring each of those strings as static:

Code:

static char zero[MAX] = "NR";
static char one[MAX] = "*";
...

That way, when the function returns, the memory that those strings reside in remains valid.

Once you're done with that, you just need to change your function declaration to return a char * instead of just a char.

Code:

char *findstars(ind d)[

No, you are not doing things correctly. The error messages from your compiler are legitimate. However, in your defence, there is no completely correct approach.

To return a string from a function, there are generally four approaches that can be used. All have advantages and disadvantages.

The first is to return a pointer to char, and (inside the function) return a statically allocated string. For example;

Code:

char *first_approach(int v)
{
     static char retval[MAX];
     if (v > 0)
          strcpy(retval, "Hello");
     else
          strcpy(retval, "Bye");
     return retval;
}

The disadvantage of this approach is that, if the function cannot be called multiple times in one statement. For example, printf("%s %s\n", first_approach(0), first_approach(1)) does not produce predictable output, since the static buffer is reused (and overwritten) the second time the function is called. A function that uses any static data also is quite difficult to use safely in a multithreaded environment.

The second approach is to return a pointer to char, and dynamically allocate memory to return. For example;

Code:

char *second_approach(int v)
{
      char *retval = malloc(MAX);
     if (v > 0)
          strcpy(retval, "Hello");
     else
          strcpy(retval, "Bye");
     return retval;
}

The disadvantage of this approach is that, if the caller does not correctly free() the returned pointer, there will be a memory leak. printf("%s %s\n", second_approach(0), second_approach(1)) produces predictable output, but also guarantees a memory leak.

The third approach is to pass an array to the function, write to it, and return it. For example;

Code:

char *third_approach(int v, char *buffer)
{
     if (v > 0)
          strcpy(buffer, "Hello");
     else
          strcpy(buffer, "Bye");
     return buffer;
}

The disadvantage of this approach is that the caller must know what buffer lengths are needed. If the function assumes an array of 100 char, and the caller only passes an array of 10 char, then the function may overwrite random areas of memory. That often means a crashing program. The usage is also more complex. For example, printf("%s %s\n", third_approach(0, first_buffer), third_approach(1, second_buffer)) will work, but it is also easier for the programmer to get wrong. It also has the same problems as the first approach above if the caller forgets to pass distinct arrays.

The fourth approach is to wrap the string in a struct. For example;

Code:

struct Something {char buffer[MAX];};

struct Something fourth_approach(int v)
{
     struct Something retval;
     if (v > 0)
          strcpy(retval.buffer, "Hello");
     else
          strcpy(retval.buffer, "Bye");
     return retval;
}

The disadvantage of this approach is that the caller needs to know how to extract members from a "struct Something" in order to use them (as well as knowing buffer lengths).

The problem with returning a pointer to a static local is that you must be careful not to call the function again before copying what the pointer points to, otherwise you will find that your data has mysteriously changed.

I suggest that you write a function like this instead:

Code:

int determine_num_stars(int average) {
    int stars = 0;
    if (average >= 200)
        stars = 4;
    else if (average >= 170 && average <= 199)
        stars = 3;
    else if (average >= 125 && average <= 169)
        stars = 2;
    else if (average >= 100 && average <= 124)
        stars = 1;
    return stars;
}

Then you could use it like this:

Code:

/* Assume a variable named average already exists */
char stars[MAX] = "";
int num_stars = determine_num_stars(average);
if (num_stars == 0) {
    strcpy(stars, "NR");
} else {
    int i;
    for (i = 0; i < num_stars; ++i) {
        stars[i] = '*';
    }
}

Originally Posted by uural4792

If I want to return multiple types of data (2 strings and number) what would I declare the function as? Both or just one? I need to create a function that returns the name, average, and rating of each bowler. Should I just translate the integer average into a string?

The whole purpose of (non-const) pointer arguments is to allow the caller to supply something that a function can change. So, if you want a function that returns two strings and a number, one approach is that the function accepts three pointers (two char *, and one to the number) and writes to them. For example;

Code:

int some_function(char *first_string, char *second_string, int *number)
{
     strcpy(first_string, "Hello");
     strcpy(second_string("Bye");
     *number = 42;
     return 26;
}

is perfectly acceptable. There is no universal rule that everything done by a function is reflected in a return value. The caller supplies the pointers, so knows how to access them.

It is also possible to return a dedicated struct that contains both strings and the number.

Originally Posted by CommonTater

Compile this and run it... Try it both with and without defined behavior.... you'll get the idea.

Oh boy... talk about stepping in it.

Whiteflags.... Editing quotations to make me appear to say something I clearly did not say is both dishonest and despicable.

The actual sentence I used (clearly visible in post #8) was...

Compile this and run it... Try it both with and without the static keyword.... you'll get the idea.

(And FWIW... This is not the first time I've observed this tactic in use on these Forums!)

Originally Posted by CommonTater

Editing quotations to make me appear to say something I clearly did not say is both dishonest and despicable.

It is not dishonest when the revised version was explicitly termed as "fixed"... though it is still a little despicable, heh.

whiteflags' has a point though: no point trying without the static keyword since the results of undefined behaviour is not necessarily instructive. Besides, an attempt to do so was the reason why this thread was started in the first place.

Other than that, your example is an elaboration of certain points made in posts #4 and #5, with the recommendation to just go for a pointer parameter approach.

Originally Posted by CommonTater

WRONG ANSWER... Trying to justify a dishonest practice is not going to let you off the hook... not by a long shot.

The practice is not dishonest. Basically, whiteflags was trying to say that this:

Compile this and run it... Try it both with and without the static keyword.... you'll get the idea.

should have been:

Compile this and run it... Try it both with and without defined behavior.... you'll get the idea.

But whiteflags merely injected a little twisted humour by presenting it as a "fixed" quote, hence "FTFY" (Fixed That For You). After all, we shouldn't be all so glum around here, right?