LETS START                         "LEARN BY DOING"

1)   C++ AND IT' S TOKENS ARE CASE SENSITIVE  2)   A C PROGRAM CAN BE COMPILED IN A CPP COMPILER WITHOUT ANY ERROR, BUT  THE VICE VERSA IS NOT POSSIBLE.  3)   REMEMBER TO #INCLUDE THE HEADERS FOR THE FACILITIES YOU ARE USE.  4)   EVERY PROGRAM MUST CONTAIN A MAIN FUNCTION OF IT'S OWN OF INCLUDED FROM OTHER.  5)   YOU MUST DECLARE A VARIABLE BEFORE USING IT. (But not in D). IT IS BETTER TO DECLARE IT WHERE IT IS NEEDED, INSTEAD OF BEGINNING.  6)  CHOOSING GOOD NAME(?) AS A VARIABLE NAME IS AN ART.  7)   INDENTATION IS A BETTER WAY  TO SHOW YOU A MASTER.  8)   COMMENTS DO NOT AFFECT THE PROGRAM SIZE (exe & obj).  9)   BAD COMMENTS CAN BE WORSE THAN NO COMMENTS.   10) USE UPPERCASE VARIABLES TO DENOTE CONSTANTS, PREPROCESSOR CONSTANTS AND MACROS.  11)* YOU CANNOT USE A KEYWORD AS A VARIABLE, AND ALSO BUILT-IN FUNCTIONS ONLY IF THEY ARE CALLED ANYWHERE IN THE PROGRAM.  12)* A VARIABLE MORE THAN 32 CHAR LENGTH CAN BE ACCESSED USING ITS FIRST 32ND CHARACTERS (NOT FOR ANSI -99).  13)   USE THE MINIMUM POSSIBLE DATA TYPE THAT IS ENOUGH TO HOLD THE DATA.  14)** COMBINING  DECLARATION, DEFINITION AND INITIALIZATION IN A SINGLE STATEMENT IF POSSIBLE, EXPRESS YOU A MASTER.  15)*  CASCADE THE OUTPUTS WITH MANIPULATOR IN A SINGLE STATEMENT.  16)** THE TERMINATING CHARACTER OF CIN IS NOT ONLY THE 'ENTER', BUT ALL WHITE_SPACES (TAB,SPACE) ALSO TERMINATE IT.  17)* YOU CAN NOT DEFINE A CONSTANT WITHOUT EXPLICIT INITIALIZATION.  18)*  THE PRECEDENCE OF COUT<< OPERATOR IS RIGHT TO LEFT ( BUT NOT GUARENTEED).  19)    WHITE_SPACES IN PREPROCESSOR, COMMENTS, STRINGS CANNOT BE IGNORED.  20)*  PREFER THE INCREMENT OPERATOR INSTEAD OF ARITHMETIC ADDITION BY ONE.  21)   CAST EXPLICITLY WHILE ASSIGNING A LARGE DATA TYPE INTO SMALL TYPE.  22)   A SAME VARIABLE CAN BE REDECLARED, ONLY IF THE STORAGE CLASSES OF THAT VARIABLES ARE DIFFERENT.  23)   EXTERN KEYWORD CAN BE USED ONLY IF IT IS WITHIN ANY FUNCTION OR MAIN AND SHOULD BE DEFINED OUTSIDE OF ANY FUNCTION OR IN ANOTHER FILE.  24)   AN EXTERNAL VARIABLE WITH EXTERN KEYWORD CANNOT BE INITIALIZED.  25)   THERE IS NO IMPLICIT INTEGERS. EVERY DECLARATION MUST SPECIFY IT'S TYPE (FOR ANSI-99 ONLY).  26)   A VARIABLE DEFINED WITHIN A BLOCK IS VISIBLE ONLY WITHIN THE BLOCK, EXCEPT THE VARIABLE DEFINED IN A CONDITIONAL STATEMENT.  27)   BE CAREFUL IN BACKSLASHES '\' .IF YOU PUT'/' INSTEAD OF OLD, NO ERROR. BUT THE ANSWER MAY WRONG.  28)   BE CAREFUL IN ASSIGNMENT OPERATOR '=' AND RELATIONAL EQUAL TO '==' .  29)   AVOID PARENTHESIS BY CONSIDERING OPERATOR PRECEDENCE. (UARLCA)  30)*  PREFER AN ARITHMETIC ASSIGNMENT OPERATOR INSTEAD OF A TWO VARIABLE ASSIGNMENT EXPRESSION.  31)   PREFER THE CONDITIONAL OPERATOR INSTEAD OF AN 'IF-ELSE' SIMPLE CONSTRUCT.  32)   THE REMAINDER OPERATOR ONLY WORKS WITH INTEGER OPERANDS.  33)   ANY VALUE OTHER THAN 0 IS TRUE. ONLY ZERO IS FALSE. (BUT NOW BOOL TYPE IS ALSO AVAILABLE WITH ANSI -99)  34)   TO RECEIVE A MULTILINE STRING USE CIN.GET(), AND TO OUTPUT A MULTILINE STRING USE '\' AT THE END OF EACH LINE.  35)  A VARIABLE MAY BE LVALUE AND RVALUE ,WHILE A CONSTANT MUST NOT BE  LVALUE.  36)  USE < --- > STYLE FOR BUILT-IN HEADER FILES AND  " --- " STYLE TO INCLUDE AN USER DEFINED HEADER FILES.  37)   THE SETW(limit) MANIPULATOR IGNORE THE INPUT AFTER THE (LIMIT-1) ONLY IF THE INPUT IS OF ARRAY OF CHARACTER. BUT IT NOT IGNORE ANY OUTPUT .  38)   THERE IS NO OBJECT SUCH AS VOID, EVEN VOID IS A BASIC DATA TYPE. BUT VOID CAN BE USED AS A GENERIC POINTER.  39)  PREINCREMENT INCREMENT FIRST BEFORE OPERATING ON, WHILE POSTINCREMENT ONLY INCREMENT AFTER EXECUTING.  40)   A CONDITIONAL OPERATOR ONLY WORK WITH 3 OPERANDS AND CANNOT OPERATE STRINGS.  41)   THE LAST CHARACTER OF THE STRING IS NULL - '\0' TO INDICATE THE STRING TERMINATION.  42)   PREFER FOR LOOP WHILE THERE IS A CONSTANT INCREMENT OF LOOP VARIABLE.  43)   THE INCREMENT EXPRESSION IN A FOR LOOP ONLY EXECUTES AFTER THE BLOCK EXECUTED.  44)   THE LOOP VARIABLE SHOULD BE CHANGED IN THE LOOP TO TERMINATE THE LOOP.  45)   THE THREE STATEMENTS IN A FOR LOOP ARE OPTIONAL. IT IS ASSUMED TO BE 1 IF THE TEST EXPRESSION IS MISSING.  46)*  A LOOP VARIABLE MUST BE DECLARED BEFORE STARTING THE LOOP. (not for FOR Loop)  47)**  YOU CANNOT DEFINE/INITIALIZE THE LOOP VARIABLE WITHIN THE LOOP EVEN AS STATIC. (Except for loop)   48)   THE DO-WHILE LOOP MUST ENDS WITH A SEMICOLON WHILE OTHERS NOT.  49)   AN ELSE IS MATCHED WITH THE LAST IF THAT DOESN'T HAVE ITS OWN ELSE. (Only if not braced properly)  50)   PREFER A SWITCH STATEMENT INSTEAD OF AN IF ELSE LADDER/ NESTED IF, IF POSSIBLE.  51)*  EACH CASE STATEMENT MUST HAVE IT'S OWN BREAK STATEMENT EXCEPT THE LAST CASE OR DEFAULT.  52)   THE SWITCH VARIABLE MUST BE AN INTEGRAL TYPE AND THE CASE CONSTANT MUST BE AN INTEGRAL (int/long/char) CONSTANT.  53)*  BREAK AND CONTINUE CAN NOT BE USED WITH AN UNEMBEDDED IF STATEMENT. AND BREAK ONLY WORKS WITH UNEMBEDDED SWITCH STATEMENT (not break).  54)   AVOID GOTOs BY THE USE OF BREAK, CONTINUE & FLAG VARIABLES.  55)   THE BREAK EXIT FROM THE INNERMOST LOOP WHILE THE CONTINUE ITERATE THE  INNERMOST LOOP AGAIN.  56)** ALWAYS PASS ZERO BY DEFAULT TO TELL AS 'I AM OK' TO OPERATING SYSTEM.  57)   ARRAY INDEX STARTING FROM ZERO, HENCE THE MAXIMUM LIMIT IS (SUSCRIPT-1) ,THAT IS (ARRAYSIZE-1).  58)   THE SUBSCRIPT VALUE MUST BE A CONSTANT INTEGER VARIABLE OR ANY INTEGER VALUE OR AN EXPRESSION THAT EVALUATES AN INTEGER CONSTANT.  59)*  THE ARRAY SIZE MUST BE AT LEAST ONE. NO ARRAY OF SIZE ZERO.  60)   ARRAYS, CLASS AND STRUCTURE MEMBERS ARE NOT INITIALIZED AUTOMATICALLY. YOU MUST INITIALIZE THEM EXPLICITLY.  61)   ALL MISSING TRAILING ELEMENTS ARE AUTOMATICALLY INITIALIZED TO ZERO IN ARRAY AND STRUCTURE INITIALIZATION.  62)   USE NAMESPACE TO AVOID AMBIGUITY AMONG OVERLOADED FUNCTIONS IN A PROGRAM.  63)** YOU CAN EMPTY AN ARRAY ONLY IF YOU INITIALIZE ALL IT'S ARGUMENTS. (EXCEPT WITHIN STRUCTURE & CLASS SPECIFIER).  64)  REMEMBER THAT ARRAY INITIALIZATION ,STRUCTURE INITIALIZATION  ENUMERATED DEFINITIONS AND ARRAY OF OBJECTS USES BRACES { ---};  65)  REMEMBER THAT ENUMERATOR MEMBERS ARE GROUPED BY COMMA WHILE STRUCTURE/CLASS MEMBERS ARE GROUPED BY SEMICOLON.  66)* THE DATA TYPE OF AN ARRAY MAY BE A BASIC TYPE OR ANY USER DEFINED TYPE (INTEGRAL/FLOAT/STRUCTURE NAME/CLASS NAME/ENUM/POINTER)  67) **YOU CANNOT INITIALIZE THE MEMBERS OF CLASS, STRUCTURE OR UNION WITHIN IT.  68)** YOU MUST EXPLICITLY DEFINE A STATIC DATA MEMBER OF A CLASS OR STRUCTURE 69)  A STRUCTURE CAN BE DECLARED AND ALSO CAN BE DEFINED WITHIN ANOTHER STRUCTURE.  70)  USE GENERIC PROGRAMMING STYLE WHENEVER YOU NEED A OVERLOADED FUNCTIONS DIFFERENTIABLE WITH ONLY ONE TYPE OF ARGUMENTS.  71)  YOU CANNOT DEFINE A FUNCTION WITHIN ANOTHER FUNCTION.  72)  ENUMERATOR VARIABLES ARE JUST INTEGERS INTERNALLY. SO YOU CAN OPERATE THEM LIKE INTEGERS.  73)  AN ENUMERATOR MEMBER MUST NOT BE A VALUE OR PREDEFINED VARIABLE.  74)  AN INTEGER VARIABLE MUST BE CASTED BEFORE ASSIGNING TO ENUM VARIABLE.  75)   AN ENUMUMERATED, UNION AND NAMESPACES  CAN BE DEFINED WITHOUT HAVING THE ITS NAME AND VARIABLES.  76)   ON DEFINITION ENUM MEMBERS ARE INITIALIZED TO INTEGERS AUTOMATICALLY STARTING FROM ZERO, WHILE ENUM VARIABLES ARE NOT INITIALIZED AUTOMATICALLY.  77)** A FUNCTION MUST RETURN SOMETHING , BUT IT MAY BE NOTHING (void) WHILE  CONSTRUCTORS , DESTRUCTORS AND CAST CONVERSION OVERLOADERS DOESN'T RETURN ANYTHING.  78)    HANDLE THE VALUE RETURNED BY THE FUNCTION (not for void) BY A VARIABLE WITH SAME TYPE OR BY THE COUT OBJECT.  79)   THE FUNCTION RETURN ONLY ONE VALUE, BUT IT PASS ANY MORE VALUES.  80)   THE MISSING ARGUMENTS MUST BE THE TRAILING ARGUMENTS, IF THE FUNCTION IS INITIALIZED.  81)   INLINE FUNCTIONS MUST DEFINED BEFORE, INSTEAD OF DECLARE.  82)   THE DEFAULT RETURN TYPE IS 'INT', ONLY IF THE FUNCTION DECLARATION IS OUTSIDE OF ALL FUNCTIONS ( BUT NOT FOR ANSI C++).  83)   YOU CANNOT INITIALIZE THE FIRST ARGUMENT IF THE SAME FUNCTION IS OVERLOADED.  84)   FUNCTIONS DEFINED WITHIN THE CLASS SPECIFIER ARE INLINE BY DEFAULT ( CONSTRUCTORS ALSO).  85)    STATIC VARIABLES ARE AUTOMATICALLY INITIALIZED, BUT ONLY ONCE.  86)   THERE IS ONLY ONE STATIC DATA MEMBER CREATED FOR ALL OBJECTS.  87)   THE LOCAL VARIABLES ARE NOT CREATED UNTIL THE FUNCTION/BLOCK IS  CALLED BY MAIN FUNCTION.  88)*  THERE IS NO KEYWORD SUCH AS 'STATIC AUTO' OR 'STATIC EXTERN'. THEY ALL ARE DEPEND ON THE PLACE WHERE STATIC DEFINED.  89)8  NEVER USE AN ARRAY WITH SIZE GREATER THAN 5000.  90)   THE MAXIMUM DIGITS HOLD BY A FLOAT IS 7, DOUBLE IS 15, LONG DOUBLE IS 19. (Except exponent).  91)* THE MAIN ( ) FUNCTION AND DESTRUCTORS CANNOT BE OVERLOADED.  92)   YOU CANNOT OVERLOAD A FUNCTION DIFFERENTIABLE ONLY WITH RETURN TYPE.  93)   FUNCTION PARAMETERS CANNOT BE 'EXTERN'AL OR 'STATIC'. BUT A FUNCTION MAY BE EXTERN OR STATIC.  94)*  THE MAXIMUM NO OF ARGUMENTS PASSED TO MAIN ( ) FUNCTION IS 3 (not 2).  95)   ALWAYS PREFER C STYLE CASTING FOR EXPLICIT TYPE CONVERSION.  96)   YOU CANNOT USE ITERATIONS, SWITCH, GOTO & RECURSION STATEMENTS WITHIN A CLASS SPECIFIER (inline member functions). 97)*  YOU CAN NOT OVERLOAD FUNCTIONS HAVING SAME NUMBER OF ARGUMENTS AND HAVE DIFFERENT TYPE BUT WITH IN THE SAME GROUP. (as  int   VS   long or FLOAT vs DOUBLE) 98)    A VOID POINTER CANNOT BE DIRECTLY ASSIGNED TO OTHER TYPE POINTER (CAST NEEDED). 99)   THE MEMBERS OF ENUMERATOR CANNOT BE ASSIGNED AGAIN  EXCEPT INITIALIZATION. 100)  A REFERENCE VARIABLE MUST BE INITIALIZED EXCEPT FUNCTION PARAMETER. 101) YOU CAN  ACCESS  THE GLOBAL VARIABLE DEFINED OUT OF ALL FUNCTIONS ONLY USING THE SCOPE RESOLUTION OPERATOR. 102) THE ONLY DIFFERENCE BETWEEN A CLASS AND STRUCTURE IS , THE MEMBERS OF A STRUCTURES ARE PUBLIC BY DEFAULT. 103)  A CONSTRUCTOR SHOULD BE PUBLIC. (not must !). 104)  IF THERE IS A CONSTRUCTOR ,THERE MUST BE A MATCH FOR EVERY OBJECT OF THE CLASS. 105)  YOU CANNOT CALL A CONSTRUCTOR USING AN OBJECT. (DOT OPERATOR CALL). 106)  DESTRUCTOR CAN NOT HOLD ANY ARGUMENTS, MEANS CANNOT BE OVERLOADED. 107) OPERANDS SMALLER THAN INTEGERS ARE IMPLICITLY CONVERTED TO INTEGERS, BEFORE DOING ANY ARITHMETIC OPERATIONS. 108)  IF IT IS NOT FIND, THE COMPILER IMPLICITLY CONVERT THE PARAMETER TO ITS NEAREST NEIGHBOR OF THE SAME GROUP. 109)  COMPILER ONLY EXECUTES THE RIGHT HAND SIDE EXPRESSION ONLY IF THE LEFT HAND SIDE EXPRESSION IS FALSE,  IN A || STATEMENT. ( ALSO FOR && ) 110)  THE BOOLEAN VALUE OF ANY ASSIGNMENT STATEMENT IS 1. 111)  IN A SEQUENCING STATEMENT (COMMA OPERATOR), THE ARITHMETIC EXPRESSION OCCURS AT THE END OF SEQUENCING IS ONLY EXECUTED (but not increment operators). COMMA ASSIGNS THE LAST EXPRESSION ONLY. 112)  BUILT IN STRING FUNCTIONS INDICATE A ZERO TO EXPRESS TRUE. 113) COMPILER IGNORE INLINE IF IT IS RECURSIVE OR HAVING A LOOP/SWITCH/GOTO OR ANY STATIC VARIABLES. 114)  AN ANONYMOUS  GLOBAL UNION MUST BE STATIC. 115)  YOU CANNOT MISS THE TRAILING PARAMETERS, IF THE CURRENT PARAMETER ID INITIALIZED. 116)  AN OBJECT CAN BE INITIALIZED LIKE AN ASSIGNMENT STATEMENT, ONLY IF THERE IS A ONE ARGUMENT CONSTRUCTOR AND THAT CONSTRUCTOR IS NOT EXPLICIT. (also for strings). 117) TWO OBJECT OF SAME CLASSES CAN BE DIRECTLY ASSIGNED WITHOUT ANY CASTING ( ALSO OVERLOADABLE). 118) TYPE CONVERSION OVERLOADED FUNCTIONS CAN NOT HOLD A RETURN TYPE OR ARGUMENT. 119)  AVOID SCOPE RESOLUTION OPERATOR WHEN CALLING A NAMESPACE MEMBER FREQUENTLY USING "USING". 120)  ENDL IS A MANIPULATOR OF IOSTREAM, SO NO NEED OF INCLUDING <conio>. AND ALWAYS PREFER USING '\n' INSTEAD OF ENDL. 121) STATIC MEMBER FUNCTION ONLY HAVE THE ACCESS TO STATIC DATA MEMBER OF THE CLASS. 122) ONLY THE STATIC MEMBER FUNCTIONS CAN BE CALLED IN MAIN FUNCTION USING SCOPE RESOLUTION OPERATOR. 123)  MAKE USE OF STRING DATA TYPE INSTEAD OF ARRAY OF CHAR OR POINTER TO CHARACTER. 124) THE LOCAL VARIABLE OVERRIDE THE GLOBAL VARIABLE, IF THEY HAVE SAME NAME AND EVEN IF THE GLOBAL IS STATIC. 125)  CONSTRUCTORS CANNOT BE VIRTUAL. BUT DESTRUCTOR MAY BE. 126)  WE CANNOT REFER A CONSTRUCTOR'S ADDRESS. 127)  THE FUNCTION CAN NOT AFFECT THE ARGUMENTS WHEN PASS BY VALUES, EVEN IF THE PARAMETERS ARE GLOBAL OR STATIC. 128)  AN OBJECT WITH A CONSTRUCTOR CANNOT BE USED AS THE MEMBER OF A UNION. 129)  CONSTRUCTOR IMPLICITLY CALL NEW & DELETE OPERATORS , WHEN MEMORY ALLOCATION IS REQUIRED FOR THE OBJECT. 130)  WHEN NO COPY CONSTRUCTOR IS FOUND COMPILER SUPPLIES ITS OWN COPY CONSTRUCTOR. 131)  THE SIZE OF ANY MEMORY ADDRESS (POINTER TO) IS 2 BYTES EXPECT 'FAR' ED ADDRESS(4) . 132)  LOCAL VARIABLES ARE STORED IN STACK BY DEFAULT. 133)  DON'T TRY TO NEST A COMMAND WITHIN ANOTHER COMMAND. 134)  THE LEFT HAND SIDE OF AN ASSIGNMENT MUST BE A LVALUE. (variable) 135)  AN EXPRESSION CANNOT BE THE LVALUE OF AN ASSIGNMENT. 136)  YOU CANNOT INITIALIZE A DYNAMICALLY ALLOCATED ARRAY. (but can a  variable) 137)  REMEMBER TO ADD + 1 FOR THE NULL CHARACTER IN STRINGS. (size of the array of type char) 138)  ALL CONSTANTS ARE STATIC BY DEFAULT. 139)  YOU CAN NOT ADD / MULTIPLY / DIVIDE TWO POINTERS. 140)  YOU CAN COMPARE / SUBTRACT /INCREMENT TWO POINTERS. 141)  YOU CANNOT DO ANY ARITHMETIC ON POINTERS TO VOID . (BUT ASSIGN & COMPARE). 142)  THE DIFFERENCE BETWEEN TWO SUBSEQUENT POINTERS IS ALWAYS 1. 143)  YOU MUST PROVIDE A SPACE WHILE DIVIDING BY A POINTER CONTENT.  (*P/    *R) 144)  THE INITIALIZATION TO A POINTER MUST BE A LVALUE EXCEPT IN POINTER TO CHAR . 145)  THE ARRAY NAME & FUNCTION NAME ITSELF IS THE STARTING ADDRESS. 146)  ADDRESS OF Nth ELEMENT OF AN ARRAY IS GIVEN BY,                                                    &X [n] = &X + ( n * DATA TYPE RANGE IN BYTES) 147)  MULTIDIMENSIONAL ARRAYS ARE ACTUALLY STORED IN HEAP AS SINGLE DIMENSIONAL ARRAY WITH RESPECT TO ROW SIZE. 148)  TO ACCESS THE Nth ELEMENT OF Mth COLUMN OF AN ARRAY DEFINED AS    A [ i ] [ j ]                                                  A [ M ] [ N ]  = * ( A + ( j * M) + N ) 149)  THE POINTER TO A CHARACTER IS A STRING. 150)  IF AN ARRAY IS DEFINED WITHIN A FUNCTION WITH 'auto' KEYWORD , IT CANNOT PASS THE ADDRESS OF THAT ARRAY BACK TO THE MAIN FUNCTION FOR SUBSEQUENT WORKS. 151)  COMBINE TWO WORD VARIABLE INTO ONE USING SECOND WORD'S FIRST LETTER CAPITAL INSTEAD OF AN UNDERSCORE. 152)  IF YOU USE CIN / COUT IN A CONDITIONAL OPERATOR BOTH CHOICE MUST BE SAME TYPE. 153)  EVERY SUCCESSIVE DECLARATION IN CPP MUST END WITH A SEMICOLON EXPECT FUNCTION PARAMETERS. 154)  EVERY BLOCK IN CPP MUST BE BRACED. 155)  BAD COMMENTS ARE WORSE THAN NO COMMENTS. 156)  NEVER TRY TO NEST A COMMENT WITH ANOTHER COMMENT 157)  DON'T USE STATIC MEMBERS OUTSIDE OF FUNCTIONS AND CLASS. PREFER ANONYMOUS NAMESPACE  THAN EXTERNAL STATIC VARIABLE. 158)  EVERY MULTI LINE COMMENT MUST END, EVEN AT END OF PROGRAM. 159)  LOCAL VARIABLES, FUNCTION PARAMETERS AND FUNCTION RETURN ADDRESSES ARE STORED IN STACK BY DEFAULT. 160)  DYNAMIC OBJECTS, STRUCTURE&CLASS ELEMENTS, GLOBAL &STATIC VARIABLES, ARRAY ELEMENTS AND POINTERS ARE STORED IN HEAP BY DEFAULT. 161)  MULTI DIMENSIONAL ARRAYS ARE STORED IN HEAP AS A SINGLE DIMENSIONAL ARRAY. SO YOU MUST SPECIFY ITS ROW SIZE WHILE INITIALIZING IT. 162)  THE MINIMUM DATA TYPE FOR ARITHMETIC IS INTEGER. SO ALL TYPES LESS THAT THAT THAT ARE IMPLICITLY CONVERTED TO INT. 163)   THE DEFAULT DATA TYPE FOR A INTEGRAL NUMBER IS SIGNED INTEGER. AND THE DEFAULT DATA TYPE FOR A REAL NUMBER IS DOUBLE. 164)  IF ONE OPERAND IS LONG & OTHER IS UNSIGNED INT, AND IF THE RESULT CAN'T BE REPRESENTED BY LONG, THEN BOTH OPERANDS ARE IMPLICITLY CONVERTED TO UNSIGNED LONG. 164)  IF AN EXPRESSION CONTAINS MIXED MODE ARITHMETIC , THE RESULT IS IMPLICITLY CONVERTED INTO LONG DATA TYPE. 165)  PREFER A DOUBLE INSTEAD OF FLOAT. 166)  YOU CANNOT 'GOTO' TO ANY FUNCTION 167)  GOTO CANNOT BY PASS A DECLARATION. BUT THE DECLARATION MAY BE BLOCKED TO ALLOW JUMPING BY GOTO. 168)  THE MAXIMUM NO OF POSSIBLE NESTED CASE STATEMENT IS 1023. 169)  THE ARRAY NAME AND FUNCTION NAME CONTAINS THE ADDRESS OF IT. ( EXCEPT WHEN SIZE OF AND REFERENCE USED) 170)  WHEN YOU PRINT THE ENUM VARIABLE THE CORRESPONDING INTEGER VARIABLE IS DISPLAYED INSTEAD OF USER DEFINED VARIABLE. 171) YOU CAN INITIALIZE ONLY THE FIRST ELEMENT OF UNION. 172)  ARITHMETIC EXPRESSIONS MUST NOT BE LVALUE. 173)  SIZE OF A POINTER VARIABLE IS ALWAYS 2, SINCE IT REFER A 16 BIT ADDRESS. 174)  SIZE OF A CLASS IS TOTAL SIZE OS ALL DATA MEMBERS. SIZE OF AN UNION IS MAXIMUM DATA TYPE'S SIZE. 175)  THE MINIMUM SIZE OF ANY VARIABLE IS 1. 176)  SIZE OF AN ARRAY NAME RETURNS ITS ARRAY SIZE AND NOT 2. 177)  YOU SHOULD INITIALIZE THE POINTER VARIABLE BEFORE USING IT. (not must) !!! 178)   YOU CAN SUBTRACT  A POINTER VARIABLE FROM OTHER POINTER. ( BUT CAN'T ADD, MULTIPLY OR DIVIDE) 179)  YOU CANNOT DO ANY ARITHMETIC OPERATION (EVEN SUBTRACT) OF VOID TYPE POINTER. 180)  USE VOID* ONLY TO RECEIVE ANY DATA TYPE IN FUNCTION PARAMETER. 181)  YOU CAN INCREMENT AND CAN COMPARE POINTERS. 182)  THE INITIALIZER TO A POINTER MUST BE THE ADDRESS OF AN LVALUE. 183)  THE ADDRESS OF THE Nth ELEMENT IN AN ARRAY IS OBTAINED BY                                            & X[N] = X + ( N * SCALE FACTOR)          // SCALE FACTOR IS RANGE OF DATA TYPE 184)  YOU CAN DIRECTLY ASSIGN AN RVALUE ONLY TO POINTER TO CHARACTERS. 185)  THE ADDRESS OF A CONSTANT VARIABLE MUST BE ASSIGNED TO CONSTANT POINTER ONLY. 186)  AVOID USING POINTER TO FUNCTION EXPECT PASSING A FUNCTION AS AN ARGUMENT TO ANOTHER FUNCTION. 187)  YOU CANNOT INITIALIZE THE CLASS WITH POINTER VARIABLE. 188)  DYNAMICALLY  ALLOCATED ARRAYS CAN NOT BE INITIALIZED. 189)  EVERY OBJECT CREATED WITH NEW SHOULD BE DELETED EXPLICITLY. (not must). 190)  AVOID USING MACROS UNLESS THEY REQUIRED FREQUENTLY IN THE SAME PROGRAM. 191)  ALWAYS PLACE THE DEFAULT STATEMENT AT THE END OF ALL CASE STATEMENTS. 192)  SWITCH STATEMENT CONTINUES THE EXECUTION FROM SELECTED CASE TOWARDS END OF SWITCH UNTIL A BREAK FOUND. 193)  A VARIABLE LENGTH PARAMETERIZED FUNCTION MUST HAVE ATLEAST ONE PARAMETER. 194)  AN ELLIPSIS HAVE LESS POWER WHEN THE SAME FUNCTION IS OVERLOADED. 195)  THE MAXIMUM NO OF ARGUMENTS POSSIBLE TO A FUNCTION IS 127. 196)  YOU CAN DECLARE UPTO 1023 MEMBERS IN A CLASS/ STRUCTURE/ UNION. 197)  C++ DOES NOT SUPPORT DESIGNATED INITIALIZERS. 198)  YOU CAN NOT INITIALIZE THE STRUCTURE/ CLASS IF IT HAS AN ARRAY MEMBER. 199)  IT IS POSSIBLE TO INCLUDE 15 NESTED HEADER FILES IN C++. 200)  ALL VARIABLES USED IN CONDITIONAL COMPILATION DIRECTIVES MUST BE CONSTANT. 201)  THE POST INCREMENT OPERATOR DOESN'T CARE ABOUT PRECEDENCE AND ASSOCIATIVE. 202)  YOU CAN NOT CHANGE THE VALUE OF THE POINTER TO CONSTANT AND ADDRESS OF THE CONSTANT POINTER. 203)  AVOID USING REFERENCE VARIABLES EXCEPT AS FUNCTION ARGUMENTS. 204)  YOU CAN NOT REFER A REFERENCE. 205)  THERE IS NO ARRAY OF REFERENCES. 206)  A CONSTANT VARIABLE CAN DE REFERENCED BY A NON CONSTANT VARIABLE. (but not pointed). 207)  AVOID USING TYPEDEF EXCEPT THERE IS THE FREQUENT NEED OF CRITICAL DECLARATION. 208)  YOU CANNOT OBTAIN THE ADDRESS OF ANOTHER REFERENCE. 209)  YOU CAN NOT CREATE A POINTER TO REFERENCE. 210)  A REFERENCE VARIABLE MUST BE INITIALIZED ON DECLARATION EXCEPT WITH IN FUNCTION AND CLASS/STRUCTURE. 211)  A VARIABLE MUST BE DECLARED ONLY ONE TIME IN A SINGLE SCOPE, BUT A FUNCTION MAY BE DECLARED ANY TIME. 212)  UNION CAN  NOT BE A BASE CLASS AND CANNOT INHERIT OTHERS. 213)  THE = OPERATOR CAN NOT BE OVERLOADED WITH UNION VARIABLES. 214)  ANONYMOUS UNION MUST NOT HAVE ANY MEMBER FUNCTIONS. 215)   UNION CANNOT HAVE VIRTUAL FUNCTIONS 216)   UNION CANNOT HAVE STATIC MEMBERS. 217)   AVOID OPERATOR OVERLOADING. 218)   THERE IS NO INBUILT ONE ARGUMENT CONSTRUCTOR. 219)   BUT THERE IS AN INBUILT COPY CONSTRUCTOR. 220)   INHERITED CONSTRUCTORS CALLED FROM TOP TO BOTTOM, WHILE DESTRUCTORS CALLED FROM BOTTOM TO TOP. 221)   IF THERE IS NO CONSTRUCTOR IN DERIVED CLASS, ONLY THERE DEFAULT CONSTRUCTOR FROM BASE IS CALLED. 222)   IF YOU INITIALIZE THE DERIVED CLASS OBJECT, YOU MUST EXPLICITLY OVERRIDE NOT ONLY THE  PARAMETERIZED CONSTRUCTOR IN DERIVED CLASS BUT ALSO THE DEFAULT CONSTRUCTOR. 223)   IF YOU DON'T EXPLICITLY CALL THE BASE CLASS ONE ARGUMENT CONSTRUCTOR IN DERIVED CLASS ONE ARGUMENT DEFINITION, WHEN YOU INITIALIZE A DERIVED CLASS OBJECT , THEN THE BASE CLASS DEFAULT CONSTRUCTOR ALSO CALLED FIRST. 224)  PASS INT AS ARGUMENT WHEN OVERLOADING POST INCREMENT AND PASS BY REFERENCE WHEN OVERLOADING ASSIGNMENT OPERATOR. 225)  YOU CANNOT RETURN AND PASS PARAMETERS FOR CAST CONVERSION OVER LOADERS. 226)  CAST EXPLICITLY WHILE ASSIGNING USER DEFINED TYPE TO BASIC DATA TYPE  AND TO ANOTHER USER DEFINED TYPE BY THE USE OF OVERLOADING. 227)  YOU CANNOT OVERLOAD( . ) , ( :: ) , ( ?: ) , ( .*) 228)  ALSO YOU CANNOT OVERLOAD ( = ) , ([ ]) , ( ( ) ) , ( -> )  USING FRIEND FUNCTIONS. 229)  IF THE CALLED FUNCTION IS NOT AVAILABLE IN DERIVED CLASS, THEN ONLY IT IS TRIED IN IT'S NEAREST BASE AND THEN TO TOP MOST BASE ONLY IF IT IS NOT AVAILABLE IN ANY MIDDLE BASES. 230)  IF VIRTUAL BASE CLASSES ARE DERIVED , THEN ONLY ONE COPY OF DATA MEMBERS ARE CREATED TO HYBRID INHERITED DERIVED CLASS. 231)  USE VIRTUAL FUNCTIONS ONLY WHEN THERE IS A CHANCE OF CALLING OVERRIDED DERIVED CLASS FUNCTION BY THE USE OF BASE CLASS POINTER OR REFERENCE. 232)  MAKE BASE CLASS VIRTUAL FUNCTION PURE, IF YOU WANT THE DERIVED CLASS FUNCTION MUST OVERRIDE ITS OWN DEFINITIONS. 233)  A CLASS THAT HAS ATLEAST ONE VIRTUAL FUNCTION IS SAID TO BE ABSTRACT. 234)  YOU CANNOT CREATE OBJECTS FOR THE CLASS THAT HAVING PURE VIRTUAL FUNCTION. 235)  RETURN TYPE IS NOT CONSIDERED TO CHOOSE THE CORRESPONDING OVERLOADED FUNCTION FOR ITS CALL. 236)  FUNCTIONS IN DIFFERENT SCOPES CANNOT BE OVERLOADED. 237)  THE MAIN FUNCTION CANNOT BE OVERLOADED. 238)  DEFAULT ACCESS SPECIFIER FOR A DERIVED CLASS IS PRIVATE. 239)  IF YOU USE CONSTRUCTORS , THEN EVERY OBJECT MUST HAVE ITS OWN TYPE CONSTRUCTOR. 240)  YOU CANNOT CALL THE MAIN FUNCTION RECURSIVELY. 241)  THE MAXIMUM ALLOWABLE CHARACTERS FOR A VARIABLE IS 1024.BUT ALWAYS USE MNEMONICS NAME AS A VARIABLE THAT IS NOT GRATER THAN 31 CHARACTERS. 242)  A CONSTANT MEMBER FUNCTION CHANGE THE DATA MEMBER ONLY IF IT IS MUTABLE. 245)  YOU CAN OVERLOAD NAMESPACES AND DEFINE A NAMESPACE WITHIN ANOTHER. 246)  YOU CAN OVERLOAD A TEMPLATE FUNCTION ONLY IF THEIR DEFINITIONS ARE FUNCTIONALLY EQUAL. 247)  YOU CAN PASS/INITIALIZE ONLY INTEGERS, POINTERS AND REFERENCES  AS PARAMETERS WITH GENERIC CLASSES. 248) USE TYPENAME INSTEAD OF CLASS WHILE DENOTING TEMPLATE DECLARATOR. 249)  PREFER EXCEPTION HANDLING WHILE CRETING DYNAMIC OBJECTS. 250)  AND AT LAST LEARN C++ BY DOING. SHARE WHAT YOU GOT  WITH OTHERS. THAT ALLOWS YOU NOT ONLY A GOOD PROGRAMMER BUT A MASTER.                                                                                TO BE CONTINUED..........>     IF YOU CAN'T FALLOW                             THIS RULES ARE NOT STRUCTURED. SO BEGINNERS CAN'T FOLLOW THEM. SO IF YOU NEED THE RULES -  ARRANGED BY CHAPTER WISE IN WORD FORMAT PLEASE CONTACT ME. YET CAN'T UNDERSTAND,                             SOME RULES MAY NOT BE UNDERSTANDABLE. IF YOU NEED THE EXPLANATION OR PROOF OF THAT RULES , PLEASE CONTACT ME SPECIFYING ONLY THE RULE NUMBER.                               SOME USERS REQUEST ME TO PUBLISH THE PROOF. SORRY FRIENDS, I PLANNED TO RELEASE A BOOK NAMELY 'GOLDEN RULES OF CPP' WITH MORE THAN 1000 RULES WITH PROOF AND EXPLANATION. PLEASE EXPECT THE BOOK WITHIN ONE YEAR.                                ALL OVER THIS I EXPECT YOUR COMMENTS, SUGGESTIONS AND PROBLEMS BASED WITH THIS RULES. BECAUSE THIS IS ONLY A BETA VERSION AND PLEASE HELP ME  TO DEBUG.