fcvt and itoa differences?

I posted earlier about problems using MessageBox (windows.h) with dynamic input from fcvt (string.h) and I found the problem. It seems that itoa requires the address of a character array while fcvt uses a character pointer. My question is: why? Aren’t these two things theoretically the same other than a predefined amount of memory for the array?:

*char string1,string2[10];
string1=“test”;
string2=“test”;

The way I am looking at it, these should be the same. If this is the case, why does fcvt require string1 while itoa/ltoa requires string2?

The way fcvt works is that it returns a pointer to a static variable inside its function, much like strtok. Therefore, the memory is already allocated and all you have to do is point to it. Thus, you use a char *. Also note that calling fcvt again will overwrite whatever was returned previously. Therefore, you should immediately do a strcpy(localString, stringFromFcvt) so that you don’t loose the data.

itoa, on the other hand, probably does the strcpy for you, meaning that the buffer needs to already be allocated and large enough to accept the string.

Other random fcvt notes: Remember that fcvt will not insert a decimal point in the string for you. The location of this decimal point is returned as the third parameter to the function. Same with the sign, which is returned as the fourth.

That makes sense. Kind of annoying that two very similar functions have such a different syntax… This Direct3D is giving me so much trouble… My new problem is that it won’t calculate my vertex normals correctly! Instead of placing normals for each triangle on a face, it seems to do a few triangles in the array only… arg…

ITOA code from the CRT:

static void __cdecl xtoa (
        unsigned long val,
        char *buf,
        unsigned radix,
        int is_neg
        )
{
        char *p;                /* pointer to traverse string */
        char *firstdig;         /* pointer to first digit */
        char temp;              /* temp char */
        unsigned digval;        /* value of digit */

        p = buf;

        if (is_neg) {
            /* negative, so output '-' and negate */
            *p++ = '-';
            val = (unsigned long)(-(long)val);
        }

        firstdig = p;           /* save pointer to first digit */

        do {
            digval = (unsigned) (val % radix);
            val /= radix;       /* get next digit */

            /* convert to ascii and store */
            if (digval > 9)
                *p++ = (char) (digval - 10 + 'a');  /* a letter */
            else
                *p++ = (char) (digval + '0');       /* a digit */
        } while (val > 0);

        /* We now have the digit of the number in the buffer, but in reverse
           order.  Thus we reverse them now. */

        *p-- = '\0';            /* terminate string; p points to last digit */

        do {
            temp = *p;
            *p = *firstdig;
            *firstdig = temp;   /* swap *p and *firstdig */
            --p;
            ++firstdig;         /* advance to next two digits */
        } while (firstdig < p); /* repeat until halfway */
}

http://www.cplusplus.com/ref/cstdlib/fcvt.html

Kind of annoying that two very similar functions have such a different syntax

itoa cant convert a double to a string, fcvt can.

Anyways, Adam Shapiro, visit http://www.cplusplus.com/ref/. it contains information about functions in the standard c library and iostream.
i think in the future they might cover STL but you can always visit the STL docs for information: http://www.sgi.com/tech/stl/stl_index.html

*Originally posted by Zmeko *
visit http://www.cplusplus.com/ref/

That was actually the first place I checked for the info. Their info helped but I was still a bit confused. I think I understand now though.