c = a + b;
d = d + b;
c = c - a;
a = d - a + c;

 

 
'A' + 32;                /* equals 'a' (ASCII only) */
'G' - 'A' + 'a';        /* equals 'g' (both ASCII and EBCDIC) */

c = a * b;
d = D * d;
c = c / a;
A = (A *) / c;

 
7 / 4;                      /* equals 1 */ 


7 * 3 / 4;                 /* equals 5 */

 
 
 
 
9 % 3;          /* equals 0 */ 

7 % 3;          /* equals 1 */
-7 % 3;         /* equals -1 */

c = c+1;

c ++; // (equals c =c+1 ;)
c ++; // increment by 1 the value of the variable c
d--; // increment by 1 the value of the variable d

 

int j = 5;

k = ++j;          /*first j = j + 1=6, then  k = j=6, which gives us j = 6, k = 6 */
but:
int j = 5;
k = j++;          /*first k = j=5 ,then  j = j + 1=6 , which gives us j = 6, k = 5 */

variable_a = variable_b ++;

variable_a = variable_b --;

variable_a = variable_b ++;

variable_a = ++ variable_b ;

int a, b, c;
a = 0;
b=a ++;// b=a=0 then a=0+1=1
c = ++ a;//a=a+1=2 then c=a=2

a + 5 >= c - 1.0 / e   /* → (a + 5) >= (c - (1.0 / e)) */

 
/* ok: */ 
5 > 7                  /* returns 0 */
10 <= 20               /* returns 1 */
 
/* this can be tricky: */
8 == 13 > 5            /* returns 0, as: 8 == (13 > 5)  →  8 == 1  →  0 */
14 > 5 < 3             /* returns 1, as: (14 > 5) < 3  →  1 < 3  →  1 */

a < b < 5              /* returns 1, as: (a < b) < 5  →  (0 or 1) < 5  →  1*/

 

 
c >= '0' && c <= '9';             /* reads as: (c >= '0') && (c <= '9') */
a + 1 == b || ! f(x);                /* reads as: ((a + 1) == b) || (! (f(x))) */

·         المنطق AND && يعود بواحد فقط إذا كان تقييم كلا العبارتين بغير الصفر وإلا عاد بصفر . إذا تم تقييم العبارة الأولى بصفر false فإنه لن يتم تقييم العبارة الثانية كما فى المثال التالى :  

a > b && c < d;     /* reads as  (a > b) && (c < d) */
/* if (a > b) is false (0), (c < d) will not be evaluated */

 
a && b || c && d;  /* reads as: (a && b) || (c && d) */ 
/* if (a && b) is true (1), (c && d) will not be evaluated */

if (c = 10 && b = 5) c = 5; /* condition test : true: if the variable "c" is" equal to 10)"and "the variable b = 5"  then "c" will take the value 5.*/ 
 
if (c> 0 || a == 0) b = a; /*condition test : true: if the "variable "c" is greater than 0" or ""a"  equal to 0" then ""b" is equal to the variable "a" .*/
 
if (! a) b = c; /* condition test : true: if "the variable "a" is not equal to 0" then, "the variable "b" takes on the value of the variable "c"". 
 

0x1234 & 0x5678                 /* equals 0x1230 */
/* because ..
0x1234 : 0001 0010 0011 0100
0x5678 : 0101 0110 0111 1000
----------------------------
     &    : 0001 0010 0011 0000
.. that is, 0x1230 */
/* Similarly: */
0x1234 | 0x5678;                  /* equals 0x567C */
0x1234 ^ 0x5678;                /* equals 0x444C */
~ 0x1234;                                             /* equals 0xEDCB */

int, b;
a = 100;
b = 28;
a = a & b;

a = 100 ---->    01100100              
AND (&)
b = 28 ---->     00011100
___________________
Result =          00000100        // or 4 decimal – only one bit – mask others

 
 
 

int, b;
a = 100;
b = 28;
a = a | b;

 

a = 100 ---->    01100100
OR (|)
b = 28 ---->     00011100
___________________
Result =          01111100 // or 124 decimal

int, b;
a = 100;
b = 28;
a = a ^ b;

 

a = 100 ---->    01100100
XOR (^)
b = 28 ---->     00011100
___________________
Result =          01111000 // or 120 decimal

 
 

int a, b, c;
a = 1;
b = 1;
b = ~ a
~ c = b

 

a = 0B00000001; NOT "a" ----> 0b11111110;
b = 0b00000001; NOT "b" ----> 0b11111110;

 

int a, b, c;
a = 10;
b = 10;
b = a >> 2;
c =b<< 5;

 

variable // ----> 00001010 - value 10 in binary
                                  >>
              // ----> 00000101 - value 5 in binary

 
 
0222222 &  0555555;          /* equals 000000 -bitwise AND >>> 5=101 & 2 =010 =0*/
 
0222222 && 0555555;        /* equals 1- Logical AND && returns 1 only if both expressions evaluate to be nonzero*/
 
~ 0x1234;     /* equals 0xEDCB >>> 0xE=~0x1,0xD=~0x2 … bitwise complement (unary); inverts each bit */
 
! 0x1234;     /* equals 0 >>> logical negation, negation of non-zero is zero-Logical operators always return 1 or 0  */

0x1234 & 0x5678                 /* equals 0x1230 */
/* because ..
0x1234 : 0001 0010 0011 0100
0x5678 : 0101 0110 0111 1000
----------------------------
     &    : 0001 0010 0011 0000
.. that is, 0x1230 */
/* Similarly: */
0x1234 | 0x5678;                  /* equals 0x567C */
0x1234 ^ 0x5678;                /* equals 0x444C */
~ 0x1234;                                             /* equals 0xEDCB */

int, b;
a = 100;
b = 28;
a = a & b;

a = 100 ---->    01100100              
AND (&)
b = 28 ---->     00011100
___________________
Result =          00000100        // or 4 decimal – only one bit – mask others

 
 
 

int, b;
a = 100;
b = 28;
a = a | b;

 

a = 100 ---->    01100100
OR (|)
b = 28 ---->     00011100
___________________
Result =          01111100 // or 124 decimal

int, b;
a = 100;
b = 28;
a = a ^ b;

 

a = 100 ---->    01100100
XOR (^)
b = 28 ---->     00011100
___________________
Result =          01111000 // or 120 decimal

 
 

int a, b, c;
a = 1;
b = 1;
b = ~ a
~ c = b

 

a = 0B00000001; NOT "a" ----> 0b11111110;
b = 0b00000001; NOT "b" ----> 0b11111110;

 

int a, b, c;
a = 10;
b = 10;
b = a >> 2;
c =b<< 5;

 

variable // ----> 00001010 - value 10 in binary
                                  >>
              // ----> 00000101 - value 5 in binary

 
 
0222222 &  0555555;          /* equals 000000 -bitwise AND >>> 5=101 & 2 =010 =0*/
 
0222222 && 0555555;        /* equals 1- Logical AND && returns 1 only if both expressions evaluate to be nonzero*/
 
~ 0x1234;     /* equals 0xEDCB >>> 0xE=~0x1,0xD=~0x2 … bitwise complement (unary); inverts each bit */
 
! 0x1234;     /* equals 0 >>> logical negation, negation of non-zero is zero-Logical operators always return 1 or 0  */