MDSN Software
The MDSN  DC 1.0 makes snowfall on windows desktop.
  

 
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\Directory\background\shell\runas]
"icon"="imageres.dll,73"
@="Run CMD as administrator"
[HKEY_CLASSES_ROOT\Directory\background\shell\runas\command]
@="cmd.exe /s /k \"pushd %V && title Command Prompt\""
| Character | Escape Sequences | ASCII Value | 
| Null | \0 | 0 | 
| Bell (alert) | \a | 7 | 
| Backspase | \b | 8 | 
| Horizontal tab | \t | 9 | 
| New line | \n | 10 | 
| Vertical tab | \v | 11 | 
| Formfeed | \f | 12 | 
| Carriage return | \r | 13 | 
| Double quote | \" | 34 | 
| Single quote | \' | 39 | 
| Question mark | \? | 63 | 
| Backslash | \\ | 92 | 
| Octal number | \ooo | any | 
| Hexadecimal number | \xhh | any | 
#include <stdio.h>
int main(){
printf("Null=%d\n",'\0');
printf("Bell (alert)=%d\n",'\a');
printf("Backspase=%d\n",'\b');
printf("Horizontal tab=%d\n",'\t');
printf("New line=%d\n",'\n');
printf("Vertical tab=%d\n",'\v');
printf("Formfeed=%d\n",'\f');
printf("Carriage return=%d\n",'\r');
printf("Double quote=%d\n",'\"');
printf("Single quote=%d\n",'\'');
printf("Question mark=%d\n",'\?');
printf("Backslash=%d\n",'\\');
return 0;
}#include <stdio.h>
int main(){
printf("\aC Program\n");
printf("New line =\\n\n");
printf("Percentage symbol=%%");
return 0;
}
| Priority | Category | Operator | What is it (or does) | Associativity | 
| 1 | Highest | ( ) [ ] -> . | Function call Array subscript Indirect component selector Direct component selector | Left to Right | 
| 2 | Unary | ! ~ + - ++ -- & * sizeof (type) | Logical negation (NOT) Bitwise (1's) complement Unary plus Unary minus Preincrement or postincrement Predecrement or postdecrement Address Indirection Size of operand, in bytes TypeCast | Right to Left | 
| 3 | Multiplicative | * / % | Multiply Divide Remainder (modulus) | Left to Right | 
| 4 | Aditive | + - | Binary plus Binary minus | Left to Right | 
| 5 | Shift | << >> | Shift left Shift right | Left to Right | 
| 6 | Relational | < <= > >= | Less than Less than or equal to Greater than Greater than or equal to | Left to Right | 
| 7 | Equality | == != | Equal to Not equal to | Left to Right | 
| 8 | Bitwise AND | & | Bitwise AND | Left to Right | 
| 9 | Bitwise XOR | ^ | Bitwise XOR | Left to Right | 
| 10 | Bitwise OR | | | Bitwise OR | Left to Right | 
| 11 | Logical AND | && | Logical AND | Left to Right | 
| 12 | Logical OR | || | Logical OR | Left to Right | 
| 13 | Conditional | ?: | "a ? x : y" means "if a then x, else y" | Right to Left | 
| 14 | Assignment | = *= /= %= += -= &= ^= |= <<= >>= | Simple assignment Assign product Assign quotient Assign remainder (modulus) Assign sum Assign difference Assign bitwise AND Assign bitwise XOR Assign bitwise OR Assign left shift Assign right shift | Right to Left | 
| 15 | Comma | , | Evaluate | Left to Right | 
#include <stdio.h>
int main(){
float a=1,b=2,c=3,d;
d=a+b*c;
printf("a+b*c=%f\n",d);
d=(a+b)*c;
printf("(a+b)*c=%f",a);
return 0;
}

| Operator | Meanning | 
| [ ] | Array subscript Operator | 
| ( ) | Parentheses Operator | 
| { } | Braces | 
| = | Equal sign | 
| , | Comma Operator (or) Punctuator | 
| : | Colon | 
| ; | Semicolon | 
| * | Astrisk | 
| " " | Quotes | 
| ' ' | Ellipsis | 
| Operator or punctuator | Alternative Representation | 
| # | %: | 
| ## | %:%: | 
| { | <% | 
| } | %> | 
| [ | <: | 
| ] | :> | 
// Alternative Representation Example
%:include<stdio.h>
int main()
<%  //  Open Brace {.
char a<:5:>="MDSN";  // Array subscript operator Ex: a[5]="MDSN"
printf("%s",a);  // Output MDSN
return 0;
%>  // Close Brace {.
| Operator or punctuator | Alternative Representation | 
| & | bitand | 
| && | and | 
| &= | and_eq | 
| | | bitor | 
| || | or | 
| |= | or_eq | 
| ^ | xor | 
| ^= | xor_eq | 
| ! | not | 
| != | not_eq | 
| ~ | compl | 
  %:include<stdio.h> //  # preprocessor 
  %:include<iso646.h>
  int main()
  <%  //  Open Brace {.
  int a=5,b=5,c=2;
  if((a==5)and(a==b)) //if((a==5)&&(a==b))
  {printf("a=5 and a=b\n");}
  
  if(a not_eq c) //if(a != c)
  {printf("a is not equal to c\n");}
  return 0;
  %>  // Close Brace {.
| Operator | Meaning | 
| & | Referencing Operator | 
| * | Dereferencing Operator | 
| + | Unary PlusOperator | 
| - | Unary Minus Operator | 
| ++ | Increment Operator | 
| -- | Decrement Operator | 
| ! | Logical Not Operator | 
| ~ | Bitwise Complement Operator | 
| sizeof | Size of operand in bytes | 
| (type) | Type Cast | 
| Operator | Meaning | 
| ++a | Pre increment | 
| a++ | Post increment | 
| --a | Pre decrement | 
| a-- | Post decrement | 
| Expression | Value | 
| ++a | 6 | 
| a++ | 6 | 
| --b | 4 | 
| b-- | 4 | 
#include<stdio.h>
  int main()
  {
  int a=5,b=5;
  printf("Value of a=%d\n",a);
  printf("Pre increment %d\n",++a);
  printf("After pre increment the value of a=%d\n",a);
  printf("Post increment %d\n",a++);
  printf("After post increment the value of a=%d\n\n",a);
printf("Value of b=%d\n",b);
  printf("Pre decrement %d\n",--b);
  printf("After pre decrement the value of a=%d\n",b);
  printf("Post decrement %d\n",b--);
  printf("After post decrement the value of a=%d\n",b--);
return 0;
  }| Expression | Interpretation | Value | 
| !(a==c) | False | 0 | 
| !(a==b) | True | 1 | 
#include<stdio.h>
int main()
{
int m;
printf("%d",sizeof(int));
printf("\n%d",sizeof(m));
return 0;
}#include<stdio.h>
int main()
{
int a=5,b=3;
float c;
c=(float) a/b;
printf("a/b=%f",c);
return 0;
}
| Operator | Meaning | 
| && | Logical AND | 
| || | Logical OR | 
| ! | Logical NOT | 
| X | Y | !X | !Y | X && Y | X || Y | 
| F | F | T | T | F | F | 
| F | T | T | F | F | T | 
| T | F | F | T | F | T | 
| T | T | F | F | T | T | 
| Expression | Interpretation | Value | 
| (a>=5)&&(a<b) | True | 1 | 
| !(a==c) | False | 0 | 
| (a!=5)||(b>c) | True | 1 | 
| !(a==b) | True | 1 | 
#include<stdio.h>
  int main()
  {
  int a=5,b=7,c=5;
  
  if((a>=5)&&(a<b)){printf("\"(a>=5)&&(a<b)\" = True\n");}
  else{printf("\"(a>=5)&&(a<b)\" = False\n");}
  
  if(!(a==c)){printf("\"!(a==b) or a is not equal to c\" = True\n");}
  else{printf("\"!(a==b) or a is not equal to c\" = False\n");}
  
  if((a!=5)||(b>c)){printf("\"(a!=5)||(b>c)\" = True\n");}
  else{printf("\"(a!=5)||(b>c)\" = False\n");}
  
  if(!(a==b)){printf("\"!(a==b) or a is not equal to b\" = True\n");}
  else{printf("\"!(a==b) or a is not equal to b\" = False\n");}
  
  return 0;
  }

| Operator | Meanning | 
| < | Is less than | 
| <= | Is less then or equal to | 
| > | Is greater then | 
| >= | Is greater then or equal to | 
| != | Is not equal to | 
| == | Is equal to | 
| Expression | Interpretation | Value | 
| a<b | True | 1 | 
| b>c | False | 0 | 
| a<=b | True | 1 | 
| c>=b | True | 1 | 
| c!=3 | False | 0 | 
| a==1 | True | 1 | 
#include<stdio.h>
  int main()
  {
  int a=1,b=2,c=3;
if(a<b)
  {printf("a is less then b  ,value= 1 \n");}
  else{printf("a is not less then b  ,value=0 \n");}
if(b>c)
  {printf("b is greater then c  ,value=1 \n");}
  else{printf("b is not greater then c  ,value=0 \n");}
if(a<=b)
  {printf("a is less then or equal to b  ,value=1 \n");}
  else{printf("a is not less then or equal to b  ,value=0 \n");}
if(c>b)
  {printf("c is greater then or equal to b  ,value=1 \n");}
  else{printf("c is not greater then or equal to b  ,value=0 \n");}
if(c!=3)
  {printf("c is not equal to 3  ,value=1 \n");}
  else{printf("c is equal to 3  ,value=0 \n");}
if(a==1)
  {printf("a is equal to 1  ,value=1 \n");}
  else{printf("a is not equal to 1  ,value=0 \n");}
  return 0;
  }
#include<stdio.h>
int main()
{
int a=7,b=5,c;
c=(0) ? a:b;   // c=5
printf("c=%d\n",c);
c=(1) ? a:b;   // c=7
printf("c=%d\n",c);
return 0;
}
#include<stdio.h>
int main()
{
int a=7,b=5,c;
c=(a>b) ? a:b;
printf("c=%d",c);
return 0;
}
// Conditional operator using multiple function
  #include<stdio.h>
  int comp();
  int prin1();
  int prin2();
  int main()
  {
  comp()?prin1():prin2();//multiple function using Turnary Operator
return 0;
  }
 /* Comparing the values in comp()[function]
  int comp()
  {
  int a=7,b=5;
  if(a<b)
  {return 0;}
  if(a>b)
  {return 1;}
  }
 
int prin1() // printing function 1
  {
  printf("A is bigger\n");
  return 0;
  }
  
int prin2() // printing function 2
  {
  printf("B is bigger\n");
  return 0;
  }
| Operator | Meaning | 
| & | Bitwise AND | 
| | | Bitwise OR | 
| ^ | Bitwise XOR | 
| << | Shift Left | 
| >> | Shift Right | 
| ~ | Bitwise Complement (or) One's Complement | 
| X | Y | X & Y | X | Y | X ^ Y | 
| 0 | 0 | 0 | 0 | 0 | 
| 0 | 1 | 0 | 1 | 1 | 
| 1 | 0 | 0 | 1 | 1 | 
| 1 | 1 | 1 | 1 | 0 | 
| 0001 00112 | Left Shift(2) | 
| 0100 11002 | <-- Insert 2 Zero's (0) | 
| Right Shift(2) | 0001 00112 | 
| Insert 2 Zero's (0) --> | 0100 11002 | 
#include<stdio.h>
int main()
{
int X=19,Y=16,Z;
Z=X&Y;
printf("X&Y=%d\n",Z);
Z=X|Y;
printf("X|Y=%d\n",Z);
Z=X^Y;
printf("X^Y=%d\n",Z);
Z=X<<2;
printf("X<<2=%d\n",Z);
Z=X>>2;
printf("X>>2=%d\n",Z);
Z=~X;
printf("~X=%d\n",Z);
return 0;
}| Binary | Decimal | |
| X & Y | 0001 0000 | 1610 | 
| X | Y | 0001 00112 | 1910 | 
| X ^ Y | 0000 00112 | 310 | 
| X<<2 | 0100 11002 | 7610 | 
| X>>2 | 0000 01002 | 410 | 
| ~X | 1110 11002 | -2010 | 

#include<stdio.h>
int main()
{
int x; // Declaration of a variable
x=5;   // Assignment Operator
printf("x=%d",x);
return 0;
}| Operator | Example | Meaning | 
| + = | X + = Y | X = X + Y | 
| - = | X - = Y | X = X - Y | 
| * = | X * = Y | X = X * Y | 
| / = | X / = Y | X = X / Y | 
| % = | X % = Y | X = X % Y | 
#include<stdio.h>
int main()
{
int x=5,y=5; // Declaration of a variable
x+=y;   // Compound Assignment X = X + Y
printf("x=%d",x);
return 0;
}#include<stdio.h>
int main()
{
int x,y,z=5; // Declaration of a variable
x=y=z;   // Multiple Assignment X=Y=Z(5)
printf("x=%d,y=%d,z=%d",x,y,z);
return 0;
}
| Operator | Meaning | Example | 
| + | Addition | 7 + 3 = 10 | 
| - | Subtraction | 10 - 3 = 7 | 
| * | Multiplication | 5 * 2 = 10 | 
| / | Division | 10 / 2 = 5 | 
| % | Modulus | 9 % 2 = 1 | 
//  Arithmetic Operators
#include<stdio.h>
int main()
{
int X=16,Y=10,Z;
Z=X+Y;
printf("X+Y=%d\n",Z);
Z=X-Y;
printf("X-Y=%d\n",Z);
Z=X*Y;
printf("X*Y=%d\n",Z);
Z=X/Y;
printf("X/Y=%d\n",Z);
Z=X%Y;
printf("X%%Y=%d\n\b",Z); 
return 0;
}


| Decimal Number | 0 to 9 | Ex: 7, 8, 6, -80, 786, etc., | 
| Octal Number | 0 to 7 | EX: 0, 012, 052, etc., | 
| Hexadecimal Number | 0 to 9, A, B, C, D, E, F | Ex: 0x786, 0xA123, 0x2b, etc., | 
| Float Constant | Value | 
| 7.867e3 | 7,867 | 
| 4e-11 | 0.00000000004 | 
| 1e+5 | 100000 | 
| 7.e10 | 60000000000 | 
| 0.16 | 0.16 | 
#include <stdio.h>
#define Length 10    //Preprocessor
#define Width 5      //Preprocessor
int main(){
int Area;
Area=Length*Width;
printf("Area=%d",Area);
return 0;
} 
 #include <stdio.h>
int main(){
const Length=10, Width=5;  // Keyword
int Area;
Area=Length*Width;
printf("Area=%d",Area);
return 0;
} 
| auto | extern | sizeof | 
| break | float | static | 
| case | for | struct | 
| char | goto | switch | 
| const | if | typdef | 
| continue | int | union | 
| default | long | unsigned | 
| do | register | void | 
| double | return | volatile | 
| else | short | while | 
| enum | signed | 
| asm | inline | this | 
| bool | mutable | throw | 
| catch | namespace | true | 
| class | new | try | 
| const_cast | operator | typeid | 
| delete | private | typename | 
| dynamic_cast | protected | using | 
| explicit | public | virtual | 
| export | reinterpret_cast | wchar_t | 
| false | static_cast | |
| friend | template |