Applying "not" operator on long double in C

Question

I have below C code in which I have applied a not operator on a long double variable:

#include <stdio.h>

int main()
{
   long double a;
   signed char b;
   int arr[sizeof(!a+b)];
   printf("\n%d",sizeof(arr));
   return 0;
}

This code outputs 16. I have problem in understanding what happenes when we apply not operator on long double, as we have done with a.

Please help me to understand whats happeneing with this code.

Thank You!

`!a` has type `int`; `(!a) + b` has type `int` ... OTOH, depending on precedence (which I'm not even going to think about), `!(a + b)` has type `int` ==> the end result is the same: `sizeof (!a+b) == sizeof ((!a)+b) == sizeof (!(a+b)) == sizeof (int)`, so you have `int arr[4]` — pmg, Aug 21 '20 at 12:31
What is wrong with this code? Have I written something wrong? — Vipul Tyagi, Aug 21 '20 at 12:37
"when we apply not operator on long double" we get either `0` or `1` of type `int` — pmg, Aug 21 '20 at 12:38
@VIPULTYAGI "Wrong" is subjective, but if you were trying to use a screwdriver to cut tomatoes, we would also ask why. So what are you trying to achieve with `sizeof(!a+b)`? It makes no sense. — klutt, Aug 21 '20 at 12:40
I want to know what will be the exact value and datatype of !a and !b( had we done that)? — Vipul Tyagi, Aug 21 '20 at 12:41
@klutt it was a question that came in my placement test. I haven't written that. — Vipul Tyagi, Aug 21 '20 at 12:42
@pmg is it true with every datatype( i.e. char, float, int, double, long etc.)? — Vipul Tyagi, Aug 21 '20 at 12:44
@VIPULTYAGI Ok. Well, the code makes no sense at all. It's only to see if you understand `sizeof` and implicit casts and promotions. — klutt, Aug 21 '20 at 12:45
Yes @VIPULTYAGI, `!` has a value of `0` or `1` of type `int` — pmg, Aug 21 '20 at 12:46
@VIPULTYAGI One interesting thing is that `sizeof i++` will NOT increment `i`. — klutt, Aug 21 '20 at 12:48
@klutt Except when it will! `int i=1; int(*skunk)[i]; printf("%d\n",(sizeof(skunk[i++]),i));` :) — Lundin, Aug 21 '20 at 12:55
"Coz it is post increment?" No, because `sizeof` does not evaluate its operand (except for VLA) ... `sizeof (1/sin(0))` does not divide by zero. — pmg, Aug 21 '20 at 12:59

Vlad from Moscow · Answer 1 · 2020-08-21T12:40:16.760

From the C Standard (6.5.3.3 Unary arithmetic operators)

5 The result of the logical negation operator ! is 0 if the value of its operand compares unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int. The expression !E is equivalent to (0==E).

So in this expression

sizeof(!a+b)

the sub-expression !a has the type int.

There are used the integer promotions of the operand b to the type int in the expression!a + b because the rank of the type signed char is less than the rank of the type int and the type int can represent all values of the type signed char.

From the C Standard (6.3.1.1 Boolean, characters, and integers)

...If an int can represent all values of the original type (as restricted by the width, for a bit-field), the value is converted to an int; otherwise, it is converted to an unsigned int. These are called the integer promotions. 58) All other types are unchanged by the integer promotions.

So the full expression is equivalent to

sizeof( int )

If the sizeof( int ) is equal to 4 then you have an array declared like

int arr[4];

Its size is equal to 16 that is to 4 * sizeof( int ).

Applying "not" operator on long double in C

1 Answers1

Linked

Related