This question already has answers here:
Macro vs Function in C
(11 answers)
Closed 6 years ago.
Please explain the output — I am getting the output as 20,
but it should be 64 if I am not wrong.
#include<stdio.h>
#define SQUARE(X) (X*X)
main()
{
int a, b=6;
a = SQUARE(b+2);
printf("\n%d", a);
}
The correct result is 20.
Macros are simple text substitutions.
To see that the result is 20, just replace the X with b+2. Then you have:
b+2*b+2
as b is 6 it is
6+2*6+2
which is 20
When using macros it is important to use parenthesis so the macro should look
# define SQUARE(X) ((X)*(X))
Then the result will be 64 as the evaluation is
(b+2)*(b+2)
(6+2)*(6+2)
8*8
64
Related
This question already has an answer here:
Macros not producing required result
(1 answer)
Closed 1 year ago.
#include <stdio.h>
#define SQRT(X)X*X
int main(){
int x=16/SQRT(4);
printf("%d",x);
return 0;
}
this output is 16 why? firstly i defined macro and then try do calculation
Currently int x=16/SQRT(4); will expand to int x=16/4*4; which is clearly 16. Use brackets to ensure the macro expansion is as intended:
#define SQRT(X) ((X)*(X))
Aside: SQRT is an odd name for the macro as that usually means "square root". SQR or SQUARE would be a more appropriate name.
This question already has answers here:
The need for parentheses in macros in C [duplicate]
(8 answers)
Closed 2 years ago.
#include<stdio.h>
#define sqr(x) x*x
int main()
{
int a = 16/sqr(4);
printf("%d", a);
}
if I am not wrong the output should be 1
as ,a = 16/sqr(4) gives 16/16 => 1
but the output is 16
this is happening only when I take division operator(/) ,I am getting correct output when using other operators
may I know the reason? .. and thank you
16 / 4 * 4 is (16 / 4) * 4 = 16
Moral: always take care with macros. In your case you should enclose in parenthesis:
#define sqr(x) ((x)*(x))
There are still problems with this macro as it evaluates the argument twice.
For instance:
int read_int();
int a = 16 / sqr(read_int());
Will unexpectedly evaluate read_int() twice as it expands to:
int a = 16 / ((read_int() * (read_int());
The advice would be to use functions for this. Make it inline to give the compiler better chances to optimize it.
a = 16/sqr(4);
Expanded the above expression gives:
a = 16 / 4 * 4
Which is 16 based on normal mathematical order of operations.
That's why macros should always be enclosed in parentheses:
#define sqr(x) ((x) * (x))
Are you trying to make a function definiton? If yes, then i don't think it should be on a #define. Instead, make a function sqr(x). Here's how:
#include <stdio.h>
int sqr(int x)
{
return x*x;
}
int main()
{
int a = 16/sqr(4);
printf("%d", a);
}
And you'll get the result 1.
Edit: but anyway, you've already get the solution with macros. This is just another way to do what you want.
This question already has answers here:
C macros and use of arguments in parentheses
(2 answers)
Closed 3 years ago.
I have a doubt in the output of a code. The code uses preprocessors of c language. The code is given below,
#include <stdio.h>
#define sqr(x) x*x
int main() {
int x = 16/sqr(4);
printf("%d", x);
}
The result of sqr(4) is equal to 16. So, the value in x must be 1 (16/16=1). But if I print the value of x, the output is 16. Please explain me why this is happening.
I am attaching the screenshot of output pane.
Output Window
In C, macros are filled into your code upon compilation. Let's consider what happens in your case:
Your macro is:
#define sqr(x) x*x
When it gets filled into this:
int x = 16/sqr(4);
You would get:
int x = 16/4*4;
Operator precedence being equal for / and *, this gets evaluated as (16/4)*4 = 16, that is, from left to right.
However, if your macro were this:
#define sqr(x) (x*x)
then you would get:
int x = 16/(4*4);
... and that reduces to 1.
However, when the argument for your macro is more complex than a simple number, e.g. 2+3, it would still go wrong. A better macro is:
#define sqr(x) ((x)*(x))
After macro replaces your expression, it becomes int x = 16/4*4 and is evaluated accordingly. i.e. (16/4)*4 which is 16.
sqr(x) doesn't calculate 4*4, it is not a function.
You are actually doing 16/4*4 which is in fact 16.
You can change your define to
#define sqr(x) (x*x)
Now you will be doing 16/(4*4).
It is expanded to
int x = 16/4*4;
Something like
#define sqr(x) ((x) * (x))
would be more safe, precedence and associativity-wise, still works poorly in expressions like sqr(a++). Inline functions are simpler to use in this context.
This question already has answers here:
C macros and use of arguments in parentheses
(2 answers)
The need for parentheses in macros in C [duplicate]
(8 answers)
Closed 3 years ago.
I find no difference between these two macros except the parentheses surrounding the macro in the first one.
Is it a matter of readability or is it a way to deal with the priority of operators?
#define TAM_ARRAY(a) (sizeof(a)/sizeof(*a))
#define TAM_ARRAY2(a) sizeof(a)/sizeof(*a)
Yes, there is a difference. The parentheses are needed so that the result of the macro is evaluated as a single expression, rather than being mixed with the surrounding context where the macro is used.
The output of this program:
#include <stdio.h>
#define TAM_ARRAY(a) (sizeof(a)/sizeof(*a))
#define TAM_ARRAY2(a) sizeof(a)/sizeof(*a)
int main(void)
{
int x[4];
printf("%zu\n", 13 % TAM_ARRAY (x));
printf("%zu\n", 13 % TAM_ARRAY2(x));
}
is, in a C implementation where int is four bytes:
1
3
because:
13 % TAM_ARRAY (x) is replaced by 13 % (sizeof(x)/sizeof(*x)), which groups to 13 % (sizeof(x) / sizeof(*x)), which evaluates to 13 % (16 / 4), then 13 % 4, then 1.
13 % TAM_ARRAY2(x) is replaced by 13 % sizeof(x)/sizeof(*x), which groups to (13 % sizeof(x)) / sizeof(*x), which evaluates to (13 % 16) / 4, then 13 / 4, then 3.
Along these lines, TAM_ARRAY would be better to include parentheses around the second instance of a as well:
#define TAM_ARRAY(a) (sizeof(a)/sizeof(*(a)))
Macros are replaced textually in an early phase of code translation. Unless side effects are specifically expected, it is very important to fully parenthesize macro arguments in the macro expansion and the macro expansion itself if it is an expression.
In the case posted, you are unlikely to have a problem because few operators have higher precedence and they would probably not be used around the macro expansion, but here is a pathological example:
TAM_ARRAY(a)["abcd"] expands to (sizeof(a)/sizeof(*a))["abcd"] whereas
TAM_ARRAY2(a)["abcd"] expands to sizeof(a)/sizeof(*a)["abcd"] which is equivalent to sizeof(a) / (sizeof(*a)["abcd"]).
Note however that an operator with the same precedence placed before the macro expansion such as % would definitely cause problems as explained in Eric Postpischil's answer.
Note also that a should be parenthesized too:
#define TAM_ARRAY(a) (sizeof(a) / sizeof(*(a)))
The way macros work is that the code is "swapped out" when compiling.
So something like
#define ADD(i, j) i + j
int k = ADD(1, 2) * 3
would be seen as: int k = 1 + (2 * 3)
Whereas,
#define ADD(i, j) (i + j)
int k = ADD(1, 2) * 3
would be seen as: int k = (1 + 2) * 3
So, there are two macros likely because of operator priority.
This question already has answers here:
C macros and use of arguments in parentheses
(2 answers)
Closed 3 years ago.
I have a question about C behavior I don't understand...
#define KB 1024
#define FOUR_KB 4*KB
int main() {
uint32_t a;
uint32_t b = 24576;
a = ceil((float)b/FOUR_KB);
//want to get number of 4K transfers
//(and possibly last transfer that is less than than 4K)
}
At this point I would expect a to be 6, but result I get is 96.
Any explanation for this?
Multiplication and division have the same priority but compiler compute from left to right when push to stack :
24576÷(4×1024) = 6 // what you expect
24576÷4×1024 = 6291456 // what compiler compute, this mean : 6144 * 1024
You should use of parenthesis and #define like this :
#define FOUR_KB (4*KB)