hi all,

i'm miffed as to why this doesn't work. i get about 20 compile errors
when i compile, which aren't helping.

i think you should be able to see what i'm trying to do but can you help me with how to do it properly ?

compile errors available if wanted.

int circle_sizes[10] = {
   LARGEST_SHADING_CIRCLE_DIAMETER,

That happens at compiling time and the compiler doesn't calculate stuff like:

LARGEST_SHADING_CIRCLE_DIAMETER - (1 * DIAMETER_DECREMENT),

or does it?

yeah that's probably it i guess.

can't see why a compiler can't add a few ints together tho'

it's nicer for me because this way facilitates easily trying different values.

i'll swap the sc's for numbers and see if it's more digestable

will do

noone mentioned it being wrong earlier when i posted that
code on 'simple C question' thread.

(i shouldn't use your brains as my compiler i suppose )

i thought the '=' was out of place (no other defines need one)

hope it works..

Since the resulting value can be arrived at at compile-time, where's the problem?

Any compiler worth its salt will optimize constant operations together into a single constant when compiling. So if you type "640 - 43" in code, it won't actually do a subtraction whenever that's used; the compiler will just put the constant 596 in the program instead.

I didn't see one; that's why it was a wild guess. I saw the '=' later.

#define LARGEST_SHADING_CIRCLE_DIAMETER 520
#define SMALLEST_SHADING_CIRCLE_DIAMETER 192
#define DIAMETER_INCREMENT ((LARGEST_SHADING_CIRCLE_DIAMETER - SMALLEST_SHADING_CIRCLE_DIAMETER) / 10)

#define CIRCLE_SIZE(a) (SMALLEST_SHADING_CIRCLE_DIAMETER + a * DIAMETER_INCREMENT )

This should work ok. Note that I got CIRCLE_SIZE() backwards, but I found that more readable (0 is smallest, 10 biggest)

edit: what, macros are bad?
Good, bad, I'm the guy with the gnu.

That is so very annoying.

Here's the only cool use of macros:

   // arthurmath.cpp
   #include <iostream>
   #define SIX  1 + 5
   #define NINE 8 + 1

   int main()
   {
      std::cout << SIX * NINE << std::endl;
   }

Macros are evil. Use const for variables, inline functions for functions. Macros are evil. Macros are evil. evil

Yes, I agree with gillius. Even if you bypass the const protection, the code at runtime will crash.

As long as there's no way to replace the # and ## macro operations, there's a need for defines. It's that easy.

I never said macros are useless. I also never said they should never be used. They are just evil. All preprocessor stuff is evil, including the header guards. An evil can be a necessary evil. Now, in this case, I think he should be using const variables and not defines.

How often do you use MIN, MID and MAX? I find them very useful.