用C语言将数字打印成字符串

Question

#include <stdio.h>

#define stringify(s)    tostring(s)
#define tostring(s)     #s

#define MAX_VALUE 65536
#define NUM 64 * 1024

enum {
    MIN_VALUE = 1024,
};

int main(int argc, char *argv[])
{
    const char *max_str = stringify(MAX_VALUE);
    const char *min_str = stringify(MIN_VALUE);
    printf("max = %s, min = %s\n", max_str, min_str);
    return 0;
}

The output is "max = 65536, min = MIN_VALUE num = 1024 * 64" Experts, how can I modify my code to output like this: max = 65536, min = 1024 num = 65536

Thanks .

Answer 1

MIN_VALUE is a number. Why do you need to stringify it?

Just use:

printf("%d\n", MIN_VALUE);

Answer 2

I think you're better off using a function instead of a macro for this, the reason being that macros are only expanded even before compile time, let alone runtime.

consider this example:

#define stringify(V) #V

#include <stdio.h>

int main()
{
    int x = 5;
    const char *str = stringify(x);
    printf("%s\n", str);
}

after the preprocessor has done it's work, the code will look like this:

#include <stdio.h>

int main()
{
    int x = 5;
    const char *str = "x";
    printf("%s\n", str);
}

that is because all the preprocessor directive # does, is wrap the given parameter in quotes.

If you want to have an int to string behaviour that works on constants, enums (cast to int) and integer variables, you could use sprintf :

#include <stdio.h>
#include <stdlib.h>

char *stringify(int x)
{
    /* get the length of the required buffer */
    int len = snprintf(0, 0, "%i", x);
    /* allocate memory */
    char *res = malloc(sizeof(char) * (len + 1));
    /* handle allocation failure */
    if(!res)
        return 0;

    /* convert the int to string */
    snprintf(res, len + 1, "%i", x);

    /* return the result */
    return res;
}

int main()
{
    int x = 5;
    char *str = stringify(x);
    printf("%s\n", str);
    /* we free the memory allocated by malloc */
    free(str);
}

this would be one way you could to this in C. If you want to know more about the functions I used, have a look at:

• http://www.manpagez.com/man/3/vsnprintf/
• http://www.manpagez.com/man/3/malloc/

Answer 3

#define statements are handled by the pre-processor before the compiler gets to see the code so it's basically a text substitution (it's actually a little more intelligent with the use of parameters and such).

Since stringify(s) is #defined , the preprocessor faithfully does it job.

stringify(MAX_VALUE) decays to stringify(65536) since MAX_VALUE is #defined to 65536 , also known at preprocessing.

But Enumerations are part of the C language itself and not known at preprocessing, So, stringify(MIN_VALUE) retains as stringify(MIN_VALUE) and hence toString(MIN_VALUE)

To do integer arithmetic or to print

num = 65536

"yes", there is a way to make the preprocessor perform integer arithmetic, which is to use it in a preprocessor condition.

#if 1024*64 == 65536
    printf("num=65536\n");
#endif