| Comments Ratio | Number of Comments divided by Lines of Code. | 
 
                        			 
                         
                           				
                           | Computational Statements | Number of statements performing arithmetic calculations. | 
 
                        			 
                         
                           				
                           | Constructors | Number of constructors. | 
 
                        			 
                         
                           				
                           | Data Members | Number of data members. | 
 
                        			 
                         
                           				
                           | Depth of Inheritance Hierarchy | Maximum nesting of the inheritance hierarchy. | 
 
                        			 
                         
                           				
                           | Destructors | Number of destructors. | 
 
                        			 
                         
                           				
                           | Error Estimate | B = E**(2/3) / 3000, where E is Programming Effort. | 
 
                        			 
                         
                           				
                           | Executable Statements | All assignments, function calls (alone on a line), calls, returns, IF, DO, FOR, CHOOSE, EXIT, CONTINUE, and GOTO statements. | 
 
                        			 
                         
                           				
                           | Function Points | Lines of Code divided by K, where K depends on the language: Cobol=77, Natural=52, PL/I=67. Estimate of the number of end-user
                              business functions implemented by the program. | 
 
                        			 
                         
                           				
                           | Inherited Methods | Number of inherited methods. | 
 
                        			 
                         
                           				
                           | Intelligent Content | I = L * V, where L is Program Level and V is Program Volume. Complexity of a given algorithm independent of the language used
                              to express the algorithm. | 
 
                        			 
                         
                           				
                           | Lines of Code | Number of lines of code, plus the number of lines of code in included files and any files they include. Comments and blank
                              lines are not counted. | 
 
                        			 
                         
                           				
                           | Logical Operators in Conditions | Number of binary logical operators used in conditions. | 
 
                        			 
                         
                           				
                           | Maintainability Index | MI = 171 - 5.2 * ln (PgmVolume) - 0.23 * ExtCycComp - 16.2 * ln (LOC) + 50 * sin (sqrt (2.46 * CommentLines/SourceLines)),
                              where PgmVolume is Program Volume, ExtCycComp is Extended Cyclomatic Complexity, LOC is Lines of Code, CommentLines is Comment
                              Lines, and SourceLines is Source Lines. | 
 
                        			 
                         
                           				
                           | Member Functions | Number of member functions. | 
 
                        			 
                         
                           				
                           | Number of Comments | Number of items containing text preceded by // or enclosed between /* and */. | 
 
                        			 
                         
                           				
                           | Operands | Number of operand occurrences (N2). Operands are variables and literals used in operators. Compare Unique Operands. | 
 
                        			 
                         
                           				
                           | Operators | Number of operator occurrences (N1). Operators are executable statements and unary and binary operations. Compare Unique Operators. | 
 
                        			 
                         
                           				
                           | Pointers | Number of data elements declared as pointers. | 
 
                        			 
                         
                           				
                           | Program Length | N = N1 + N2, where N1 is Operators and N2 is Operands. | 
 
                        			 
                         
                           				
                           | Program Level | L = 1 / D, where D is Difficulty. | 
 
                        			 
                         
                           				
                           | Program Volume | V = N * log2(n), where N is Program Length and n is Vocabulary. Minimum number of bits required to code the program. | 
 
                        			 
                         
                           				
                           | Programming Effort | E = V / L, where V is Program Volume and L is Program Level. Estimated mental effort required to develop the program. | 
 
                        			 
                         
                           				
                           | Programming Time | T = E / 18, where E is the Programming Effort and 18 is Stroud’s Number. Estimated amount of time required to implement the
                              algorithm, in seconds. | 
 
                        			 
                         
                           				
                           | Public Data Members | Number of public data members. | 
 
                        			 
                         
                           				
                           | Public Member Functions | Number of public member functions. | 
 
                        			 
                         
                           				
                           | Response for Class | Response for class. | 
 
                        			 
                         
                           				
                           | Static Data Members | Number of static data members. | 
 
                        			 
                         
                           				
                           | Static Functions | Number of static functions. | 
 
                        			 
                         
                           				
                           | Static Member Functions | Number of static member functions. | 
 
                        			 
                         
                           				
                           | Unique Operands | Number of distinct operands (n2). Operands are variables and literals used in operators. Uniqueness of literals is determined
                              by their notation. Compare Operands. | 
 
                        			 
                         
                           				
                           | Unique Operands in Conditions | Number of distinct operands used in conditions. | 
 
                        			 
                         
                           				
                           | Unique Operators | Number of distinct operators (n1). Operators are executable statements and unary and binary operations. Compare Operators. | 
 
                        			 
                         
                           				
                           | Vocabulary | n = n1 + n2, where n1 is the number of Unique Operators and n2 is the number of Unique Operands. |