Thread: c preprossor

Is there any reason you can't use

Code:

#define SIZE_16 0x123
#define SIZE_64 0x456
...

?

Basically what you want is a really simple template meta-programming program which translates one constant to another constant at compile time.

I'm feeling generous, so here's exactly what you want:

Code:

#include <assert>

#define SIZE(x) (myMetaProg<(x)>::ret)
template<unsigned x> struct myMetaProg {};
template<> struct myMetaProg<16> { enum { ret = 0x123 }; };
template<> struct myMetaProg<64> { enum { ret = 0x456 }; };
template<> struct myMetaProg<128> { enum { ret = 0x789 }; };
template<> struct myMetaProg<512> { enum { ret = 0xabc }; };

int main(void)
{
    assert(SIZE(16) == 0x123);
    char array[128];
    assert(SIZE(sizeof(array)) == 0x789); // could even use a static_assert here
}

Warning untested code.

Also note that this is C++ code; You've posted in the C++ forum afterall. It wont work in C.

Originally Posted by lxw

of cause #define SIZE_16 0x123 works. then if I have many size, then I have to list them all. It's not looks pretty.

It doesn't matter what technique you use. It is necessary to list all the candidate values, regardless.

Code is not required to look "pretty". It is more important that code be understandable and maintainable.

Originally Posted by saurabhsharma

You can use
#define SUM(x) ((x) == (16)) ? 0x123: ((x)==64) ? 0x456: ((x)==128) ? 0x789: ((x)==512) ? 0xabc:0x99999999

The weakness of that approach is that it will always compile, even if SIZE(x) is supplied an invalid x. After all, ?: cannot be left incomplete, or it will never compile.

Apart from iMalc's approach of using template specialisation (which is definitely preferable in C++) there is also a macro technique.

Code:

#define SIZE_16 0x123
#define SIZE_64 0x456
#define SIZE_128 0x789
#define SIZE_512 0xabc

#define SIZE(x) SIZE_##x

This will mean SIZE(x) will work for x = 16,64, 128, 512, but will trigger a compilation error otherwise. If you want it to work for other values of x (not necessarily integral - any token will do) then simply define a corresponding SIZE_x.

Say, iMalc, you know you can use static const int variables instead of enums, right? It's preferred nowadays instead of enums.

Originally Posted by Elysia

Say, iMalc, you know you can use static const int variables instead of enums, right? It's preferred nowadays instead of enums.

I tend to forget which one is preferred there.
Token pasting operator FTW here I rekon.

Code:

#include <stdio.h>

#define SIZE_16 0x123
#define SIZE_64 0x456
#define SIZE_128 0x789

#define SIZE(x) SIZE_##x

int main()
{
    printf("SIZE(16) = %d\n", SIZE(16));
    printf("SIZE(64) = %d\n", SIZE(64));
    printf("SIZE(128) = %d\n", SIZE(128));
}

EDIT: Doh. Once again, I've posted before reading the entire thread first.