Thread: return pointer address from a function

Sorry for the wrong title, what I meant to say was "return the array address from a function"

I have a function that should return the address of a pointer to a string of characters but needs fixing.
The code:

Code:

char * int_to_str(int an_int)
{
    char str[100];
    /* some long process */

    return str;
}

Is the solution to add static to the statement: "char str[100];"?
If the variable is local-static does it mean that it will never be removed from memory and will be sort of treated like a global variable but visible only to the function?
Thank you

Is the solution to add static to the statement: "char str[100];"?

That's one solution, yes. But it introduces other problems, re-entrancy being a huge one. A better approach in general would be to let the caller manage the buffer and pass it in to your function along with the maximum size:

Code:

char *int_to_str(int an_int, char *buf, size_t size);

will be sort of treated like a global variable but visible only to the function?

Yes.

[edit]
On a side note, I'm very interested in the /* some long process */ part. Number to string conversions are quite a bit trickier than they seem, and I enjoy seeing different approaches.
[/edit]

Originally Posted by chris_oliver

Is size_t a datatype of some sort?

Yes, it is an unsigned integer type that is the type of the result of the sizeof operator. It is available via <stddef.h> and some other standard headers.

Originally Posted by chris_oliver

I'm interested to know more about the problem with re-entry, could you please elaborate on the possible problem?

Consider that there's really only one array storing the string, yet the function could be called multiple times. If the function is called a second time before the caller copies the result string, the result for the second call would then be incorrectly treated as the result for the first call.

As an example from the standard library, you might have encountered something similiar when using strtok.

Sorry, I do not use too much other libraries except stdio.

stdio is fun, but the others are interesting too. Oddly enough, a quite robust integer to string conversion function is available in stdlib.h by the name of strtol. There's also an atoi, but just pretend that one doesn't exist, because it's evil and stupid.

Correct me if I'm wrong. So it would mean that #5 would produce undesirable results because both cptr1 and cptr2 share the same address?

Nope, that's it exactly. Both pointers refer to the same string, so changes to cptr2 would also be reflected in cptr1.

Originally Posted by Prelude

Oddly enough, a quite robust integer to string conversion function is available in stdlib.h by the name of strtol.

strtol is for string to (long) integer conversion though. Perhaps you are thinking of sprintf and snprintf from <stdio.h>?

Yes, thank you.

I would like to get your feedback on this process.

I like it. As laserlight kindly pointed out, my mention of trickiness was in reference to the reverse process of converting a string to an integer. I have no excuse other than I was working on my strtod implementation lately, and had a weird bout of conceptual dyslexia. Your approach isn't much different from what I use on the back end for sprintf:

Code:

/*
    @description:
        Converts a long long value into its string representation using the given attributes.

        Attributes:
            * radix         -- The base of the represented number.
            * show_sign     -- Always show a positive sign.
            * alt_case      -- Represent hexadecimal digits in upper case.
            * ignore_locale -- Ignore the current locale in all cases if true.
*/
char *_lltoa(char s[], long long value, int radix, int show_sign, int alt_case, int ignore_locale)
{
    size_t i = 0;

    if (value < 0 || show_sign)
    {
        s[i++] = (value < 0) ? '-' : '+';
    }

    _ulltoa(&s[i], llabs(value), radix, alt_case, ignore_locale);

    return s;
}

/*
    @description:
        Converts an unsigned long long value into its string representation using the given attributes.

        Attributes:
            * radix         -- The base of the represented number.
            * alt_case      -- Represent hexadecimal digits in upper case if true.
            * ignore_locale -- Ignore the current locale in all cases if true.
*/
char *_ulltoa(char s[], unsigned long long value, int radix, int alt_case, int ignore_locale)
{
    const char *digits = alt_case ? "0123456789ABCDEF" : "0123456789abcdef";

    // Locale-specific grouping and separation information
    char *grouping = localeconv()->grouping;
    int group_size = *grouping, group_len = 0;
    size_t i = 0;

    if (value == 0)
    {
        s[i++] = '0'; // Special case to simplify the deconstruction loop
    }
    else
    {
        // Desconstruction loop. Build the string in reverse because we don't know how many digits are present
        while (value)
        {
            if (!ignore_locale && group_size && group_len++ == group_size)
            {
                s[i++] = *localeconv()->thousands_sep;

                // Only move to the next group if it exists, otherwise use the last valid group size
                if (*grouping && *++grouping)
                {
                    group_size = *grouping;
                }

                // Reset the group (to 1, since we're still copying a digit)
                group_len = 1;
            }

            s[i++] = digits[value % radix];
            value /= radix;
        }
    }

    s[i--] = '\0';

    _strrev(s); // Fix the result ordering

    return s;
}

The size of the buffer isn't checked since I have unilateral control over it. Pretty much the only real differences are support for locale-based thousands separators and bases up to hexadecimal.

Now if you want to talk about tricky, try writing a floating-point to string conversion.