CODEWITHSUNDEEP
cmacros
A.s. Bhullar
A.s. Bhullar

Reputation: 2788

integer to string converter(using macros)

I was doing basics of macros. I define a macro as follows:

#define INTTOSTR(int) #int

to convert integer to string.

Does this macro perfectly converts the integer to string? I mean are there some situations where this macro can fail?

Can I use this macro to replace standard library functions like itoa()?

for example:

int main()
{
    int a=56;
    char ch[]=INTTOSTR(56);
    char ch1[10];
    itoa(56,ch1,10);
    printf("%s %s",ch,ch1);
    return 0;
}

The above program works as expected.

Interestingly this macro can even convert float value to string.

for example:

INTTOSTR(53.5);

works nicely.

Till now I was using itoa function for converting int to string in all my projects. Can I replace itoa confidently in all projects. Because I know there is less overhead in using macro than function call.

Upvotes: 8

Views: 4749

Answers (3)

Homero C. de Almeida
Homero C. de Almeida

Reputation: 199

Your macro does not convert integers to strings, it converts a literal into a string literal, which is something very different.

Literals are any plain numbers or definitions of values in your code. when you do int x = 10; the numeral 10 in an integer literal, while x is a variable and int is the type. const char* ten = "10"; also defines a literal, in this case a string literal, with value "10" and a variable called ten which points to the address where this literal is defined. What your macro actually does is change the way the literal is represented before any actual compilation goes on, from an integer literal into a string literal.

So, the actual change is being done before any compilation, just at source code level. Macros are not functions and cannot inspect memory, and your convertion would not work with variables. If you try:

int x = 10;
const char* ten = INTTOSTR(x);

You would be very puzzled to find that your variable ten would actually hold the value "x". That's because x is treated as a literal, and not as a variable.

If you want to see what's going on, I recommend asking your compiler to stop at preprocessing, and see the output before your code is acutally compiled. You can do this in GCC if you pass the -E flag.

PS. Regarding the apparent "success" with conversion of float values, it just comes to show the danger of macros: they are not type-safe. It does not look at 53.5 as a float, but as a token represented by characters 5, 3, . and 5 in the source code.

Upvotes: 1

László Papp
László Papp

Reputation: 53145

In C, you can use itoa or if you are desperate and would like to avoid it, use snprintf for instance:

snprintf(my_str, sizeof(int), "%i", my_int);

The problem with your macro is that you are thinking about constants, but of course, your macro will be broken when you need to use a variable holding an integer. Your macro would try to stringify the macro name as opposed to the value it would be holding.

If you are fine with constants, your macro is "good", otherwise it is b0rked.

Upvotes: 2

ThiefMaster
ThiefMaster

Reputation: 318488

Macros execute during (before to be exact) compile time, so you can convert a literal number in your sourcecode to a string but not a number stored in a variable

In your example, INTTOSTR(56) uses the stringification operator of the preprocessor which eventually results in "56". If you called it on a variable, you'd get the variable name but not its content.

Upvotes: 5

Related Questions