difference inbetween macro & function

[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 <stdio.h>

#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

[gallows]

On 6 Nov, 17:59, jason <ji...@notmal.c omwrote:

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 <stdio.h>

#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 )

[santosh]

On Tuesday 06 Nov 2007 10:29 pm jason <ji***@notmal.c omwrote in
article <47************ **********@drea der12.news.xs4a ll.nl>:

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 <stdio.h>

#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);

[John Gordon]

In <47************ **********@drea der12.news.xs4a ll.nljason <ji***@notmal.c omwrites:

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 <stdio.h>

#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.co m B is for Basil, assaulted by bears
-- Edward Gorey, "The Gashlycrumb Tinies"

[jason]

On Tue, 06 Nov 2007 17:38:02 +0000, John Gordon wrote:

In <47************ **********@drea der12.news.xs4a ll.nljason
<ji***@notmal.c omwrites:

>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 <stdio.h>

>#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.

[Keith Thompson]

jason <ji***@notmal.c omwrites:

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 <stdio.h>

#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
<http:°www.catb .org/~esr/faqs/smart-questions.html> .

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 <stdio.h>

#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_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
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"

[Charlie Gordon]

"jason" <ji***@notmal.c oma écrit dans le message de news:
47************* *********@dread er12.news.xs4al l.nl...

On Tue, 06 Nov 2007 17:38:02 +0000, John Gordon wrote:

>In <47************ **********@drea der12.news.xs4a ll.nljason
<ji***@notmal. comwrites:

>>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 <stdio.h>

>>#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..

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(comp ute_total_and reset(), 100) will invoke the function
compute_total_a nd_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.