435,247 Members | 1,427 Online + Ask a Question
Need help? Post your question and get tips & solutions from a community of 435,247 IT Pros & Developers. It's quick & easy.

difference inbetween macro & function

 P: n/a Hi, I learned my lesson about passing pointers, but now I have a question about macros. Why does the function work and the MACRO which is doing the same thing on the surface, does not work in the following small example ? #include #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) double percent(double a, double b) { return ((a - b) / a) * 100.0; } int main(void) { printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); return 0; } Thank you ! jason Nov 6 '07 #1
6 Replies

 P: n/a On 6 Nov, 17:59, jason #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) double percent(double a, double b) { return ((a - b) / a) * 100.0; } int main(void) { printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); return 0; } Thank you ! jason Well, that macro isn't the same as percent(). You have to cast to double, e.g.: #define PERCENTAGE(a, b) ( (a - b) / (double) a * 100 ) Nov 6 '07 #2

 P: n/a On Tuesday 06 Nov 2007 10:29 pm jason : Hi, I learned my lesson about passing pointers, but now I have a question about macros. Why does the function work and the MACRO which is doing the same thing on the surface, does not work in the following small example ? #include #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) double percent(double a, double b) { return ((a - b) / a) * 100.0; } int main(void) { printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); return 0; } Thank you ! Macros have no concept of types because they are processed before the compiler proper begins. In your example the constants in the macro invocation are treated as integers causing the division by 'a' to be truncated to zero. Use a decimal point on the constants to force the compiler to treat them as double values. PERCENTAGE(1000.0, 100.0); Nov 6 '07 #3

 P: n/a In <47**********************@dreader12.news.xs4all.nl jason #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) double percent(double a, double b) { return ((a - b) / a) * 100.0; } int main(void) { printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); return 0; } You're using 1000 and 100 instead of 1000.0 and 100.0 and therefore all of the calculations except for the final multiplication are done using integer math instead of floating-point math. Specifically, this part of the macro: ((a - b) / a) Will expand to this: ((1000 - 100) / 1000) Which further simplifies to this: 900 / 1000 And since these numbers are both integers, integer math is used, which produces a reult of zero. -- John Gordon A is for Amy, who fell down the stairs go****@panix.com B is for Basil, assaulted by bears -- Edward Gorey, "The Gashlycrumb Tinies" Nov 6 '07 #4

 P: n/a On Tue, 06 Nov 2007 17:38:02 +0000, John Gordon wrote: In <47**********************@dreader12.news.xs4all.nl jason Why does the function work and the MACRO which is doing the same thingon the surface, does not work in the following small example ? >#include >#define PERCENTAGE(a, b) (((a - b) / a) * 100.0) >double percent(double a, double b) { return ((a - b) / a) * 100.0;} >int main(void) { > printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); > return 0;} You're using 1000 and 100 instead of 1000.0 and 100.0 and therefore all of the calculations except for the final multiplication are done using integer math instead of floating-point math. Specifically, this part of the macro: ((a - b) / a) Will expand to this: ((1000 - 100) / 1000) Which further simplifies to this: 900 / 1000 And since these numbers are both integers, integer math is used, which produces a reult of zero. Ah sounds logical indeed.. Thank you all, for the answers & explanations. Jas. Nov 6 '07 #5

 P: n/a jason #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) double percent(double a, double b) { return ((a - b) / a) * 100.0; } int main(void) { printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); return 0; } Others have explained why your macro doesn't work. I'll offer some additional advice. You get 100 points (on a scale of 0 to whatever the heck) for posting a complete program that exhibits the problem, but you lose 20 points for merely telling us that it "does not work" without explaining *how* it doesn't work. In this case, it was easy enough to figure out the problem, but in general you should tell us *how* it didn't work -- i.e., what output you expected, what output you got, and perhaps why you think your expected output is right and what you got is wrong. A good resource for this kind of thing is . As for your macro, leaving aside the type problem, I see two other potential issues. First, it always evaluates the first argument twice. This isn't necessarily a problem; the all-caps name warns users that this is a macro, and this kind of thing might happen. Second, for a function-like macro that expands to an expression, you should always fully parenthesize the entire expression (which you did) *and* each occurrence of an argument (which you didn't). Specifically: #define PERCENTAGE(a, b) ((((a) - (b)) /(a)) * 100.0) (Note: it's not *always* strictly necessary, but I find it much easier to be consistent than to remember the cases where it isn't.) This doesn't matter if the arguments are simple identifiers or constants, but imagine what happens if the arguments are more complex subexpressions. Macro expansion knows nothing about operator precedence; it just blindly expands each argument in place. Here's an example of how failing to parenthesize sufficiently: #include #define SIX 1+5 #define NINE 8+1 int main(void) { printf("%d * %d = %d\n", SIX, NINE, SIX * NINE); return 0; } -- Keith Thompson (The_Other_Keith) ks***@mib.org Looking for software development work in the San Diego area. "We must do something. This is something. Therefore, we must do this." -- Antony Jay and Jonathan Lynn, "Yes Minister" Nov 6 '07 #6

 P: n/a "jason" In <47**********************@dreader12.news.xs4all.nl jason>Why does the function work and the MACRO which is doing the same thingon the surface, does not work in the following small example ? >>#include >>#define PERCENTAGE(a, b) (((a - b) / a) * 100.0) >>double percent(double a, double b) { return ((a - b) / a) * 100.0;} >>int main(void) { >> printf("%g%%\n", percent(1000, 100)); printf("%g%%\n", PERCENTAGE(1000, 100)); >> return 0;} You're using 1000 and 100 instead of 1000.0 and 100.0 and therefore allof the calculations except for the final multiplication are done usinginteger math instead of floating-point math.Specifically, this part of the macro: ((a - b) / a)Will expand to this: ((1000 - 100) / 1000)Which further simplifies to this: 900 / 1000And since these numbers are both integers, integer math is used, whichproduces a reult of zero. Ah sounds logical indeed.. It should also be noted that macro arguments must be parenthesized in the expansion to prevent operator precedence problems: Your definition of PERCENTAGE will not work as expected some of the arguments are expressions: #define PERCENTAGE(a, b) (((a - b) / a) * 100.0) PERCENTAGE(1 + 2, 3) will expand as (((1 + 2 - 3) / 1 + 2) * 100.0) which evaluates to 200.0 instead of the expected 0.0 The fix is easy: #define PERCENTAGE(a, b) ((((a) - (b)) / (a)) * 100.0) Also note that the initial part of the computation will be done with integer arithmetics if both a and b are integers. A simple fix for this is: #define PERCENTAGE(a, b) ((((double)(a) - (b)) / (a)) * 100.0) The expression can actually be simplified a bit because / and * are left associative, so ``(a / b) * c'' is the same is ``a / b * c'' and the left operand of * is already a double so 100 can be used instead of 100.0. #define PERCENTAGE(a, b) (((double)(a) - (b)) / (a) * 100) Finally, you notice that a is evaluated twice in the expansion of the macro. Invoking this macro with an expression with side effects as a first argument will not perform as expected, and may even invoke undefined behaviour: PERCENTAGE(compute_total_and reset(), 100) will invoke the function compute_total_and_reset twice. The only way to fix this is to use a function instead of a macro. In c99, this function can be declared ``inline'' as a hint for the compiler to generate code without a function call, but this is an optimisation you should not be concerned with at this stage. So remember this: 1- use functions, not macros. 2- if you break rule 1, always parenthesize the macro arguments in the expansion 3- if you break rule 1, be careful about multiple evaluation, use capitals for the macro name to make them obvious. 4- if you break rule 1, macros are untyped, be careful how the expansion will evaluate depending on the types of the arguments. 5- don't break rule 1 -- Chqrlie. Nov 8 '07 #7

This discussion thread is closed

Replies have been disabled for this discussion. 