//C++ Comments:

• //Compiler ignores comments - they don't affect execution.
• 
  
• //Single-Line Comments...
• 1. //I'm a single-line comment!
• //Multi-Line Comments...
• 1. /*
  2. I'm a...
  3. ...multi-line comment!
  4. */
• Read More...

//C++ Header Files:

• //INCLUDING HEADER FILES:

• //#include <headerFileName>
• 
  
• //Including External Files
• 1. //If function definitions are in external files they must be included to be used
  2. //Place includes at the top of the main file or the top of an included header file
  3. #include <cstdlib>   //Includes some basic functions
  4. #include <iostream>   //Includes functions for stream input & output
  5. #include <iomanip>   //Includes functions for input & output manipulation
  6. #include <fstream>   //Includes functions for file input & output
  7. #include <ofstream>   //Includes functions for file output
  8. #include <ifstream>   //Includes functions for file input
  9. #include <cmath>   //Includes functions for mathematical operations
  10. #include <vector>   //Includes functions for vector math
  11. #include <algorithm>   //Includes functions ranges of elements
• Read More...

• //CREATING HEADER FILES:

• //#ifndef FILENAME_H
• //#define FILENAME_H
• //headerFileCode; #endif
• 
  
• //Using ifndef...endif Structure
• 1. //Save header files with the .h extension like “myHeader.h”
  2. 
     
  3. //The ifndef...endif structure prevents multiple instances of linked header files
  4. //Place the ifndef and define lines at the top of the file
  5. #ifndef MYHEADER_H
  6. #define MYHEADER_H
  7. 
     
  8. //code for function libraries or class declarations goes here
  9. 
     
  10. //Place the endif line at the end of the file
  11. #endif
  12. 
      
  13. 
      
  14. //If the filename is myHeader.h, include it in the main file as follows:
  15. #include “myHeader.h”
• Read More...

//C++ Data Types & Variables:

• //DATA TYPES:

• //Data Types usable in Variables & Function Declarations:

Name	Description	Value Range
bool	Boolean (True/False)	true or false
char	Single Character (Letters)	signed: -128 to 127   //ASCII Values unsigned: 0 to 255   //ASCII Values
int	Integer (Whole Numbers)	signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295
float	Floating Point Number (Decimal #'s w/ 7 digits)	minimum: 1.175494351 E -38 maximum: 3.402823466 E +38
double	Double Precision Floating Pt (Decimal #'s w/ 16 digits)	minimum: 2.2250738585072014 E -308 maximum: 1.7976931348623158 E +308
string	String of Characters (Like a Sentance)	Lots of “Letters”

• Read More...

• //DECLARING & INITIALIZING VARIABLES:

• //dataType varName = value;
• 
  
• //Declaring & Initializing basic Variables...
• 1. bool isTrue = true;   //false == 0, true == anything but zero
  2. char aLetter = ‘Y’;
  3. int intNum = 5;
  4. float floatNum = 5.125;
  5. double doubleNum = 2.2250738585072014;
  6. string sentance = “whatever”;
  7. 
     
  8. //You can also Declare and Initialize multiple Variables in the same line...
  9. int intNum1 = 5, intNum2 = 10;
• Read More...

//C++ Special Characters (used in Strings):

• //Special Characters usable in strings:

Symbol	Name	Description
“  \n  ”	Newline	Creates a new line character or carriage return.
“  \t  ”	Horizontal Tab	Creates a horizontal tab space.
“  \v  ”	Vertical Tab	Creates a vertical tab space.
“  \b  ”	Backspace	Deletes back one space like a backspace.
“  \\  ”	Backslash	Creates a backslash character.
“  \?  ”	Question Mark	Creates a question mark.
“  \'  ”	Single Quote	Creates a single quotation mark.
“  \"  ”	Double Quote	Creates a double quotation mark.
“  \0  ”	Null	Creates a NULL character.

• Read More...

//C++ Operators:

• //ASSIGNMENT & CONCATENATION OPERATORS:

Symbol	Name	Example
=	Assignment	varName = 5;   //5 is saved in varName
+	Concatenation	varName = “My name is ” + “Terrance.” //varName will now equal “My name is Terrance.”

• Read More...

• //STREAM OPERATORS:

Symbol	Name	Example
<<	Stream Insertion	cout << 5;   //sends 5 to the output device
>>	Stream Extraction	cin >> varName;   //saves from input device

• Read More...

• //ARITHMETIC OPERATORS:

Symbol	Name	Example
+	Addition	aNum = 1 + 2;   //aNum = 3
-	Subtraction	aNum = 3 - 2;   //aNum = 1
*	Multiplication	aNum = 2 * 3;   //aNum = 6
/	Division	aNum = 13 / 5;   //aNum = 2 (ignore remainder)
%	Modulo	aNum = 13 % 5;   //aNum = 3 (remainder)

• Read More...

• //COMPOUND ASSIGNMENT OPERATORS:

Symbol	Name	Example
+=	Plus Equals	aNum += 4;   //aNum = aNum + 4
+=	Concatenation Equals	aString += “ more letters.”; //aString = aString + “ more letters.”
-=	Minus Equals	aNum -= 4;   //aNum = aNum - 4
*=	Multiply Equals	aNum *= 4;   //aNum = aNum * 4
/=	Divid Equals	aNum /= 4;   //aNum = aNum / 4
%=	Modulo Equals	aNum %= 4;   //aNum = aNum % 4
--	Decrement	aNum--;   //aNum = aNum - 1
++	Increment	aNum++;   //aNum = aNum + 1
++var	Pre-Increment	myNum = ++urNum; //myNum = urNum + 1, urNum = urNum + 1
var++	Post-Increment	myNum = urNum++; //myNum = urNum, urNum = urNum + 1
--var	Pre-Decrement	myNum = --urNum; //myNum = urNum - 1, urNum = urNum - 1
var--	Post-Decrement	myNum = urNum--; //myNum = urNum, urNum = urNum - 1

• Read More...

• //RELATIONAL OPERATORS:

Symbol	Name	Example (Used in expressions)
==	Equal to	(a == b)   //returns true if a equals b
!=	Not Equal to	(a != b)   //returns true if a doesn't equal b
>	Greater than	(a > b)   //returns true if a is greater than b
<	Less than	(a < b)   //returns true if a is less than b
>=	Greater than or equal to	(a >= b) //returns true if a is greater than or equal to b
<=	Less than or equal to	(a <= b) //returns true if a is less than or equal to b

• Read More...

• //LOGICAL OPERATORS:

Symbol	Name	Example (Used in expressions)
!	Not	(!true)   //returns false (the opposite)
&&	And	(a == b && b > c)   //returns true if both sides are true
||	Or	(a == b || b > c)   //returns true if either side is true

• Read More...

• //BITWISE OPERATORS:

Symbol	Name	Example (Used with binary values)
&	And	aNum = 11 & 5;   //aNum = 1 (“and”s each bit) //11 = 1011 (binary) and 5 = 0101 so... 0001 (binary) = 1
|	Inclusive Or	aNum = 12 | 9;   //aNum = 13 (“or”s each bit - 1 | 1 = 1) //12 = 1100 (binary) and 9 = 1001 so... 1101 (binary) = 13
^	Exclusive Or	aNum = 12 ^ 9;   //aNum = 5 (“or”s each bit - 1 ^ 1 = 0) //12 = 1100 (binary) and 9 = 1001 so... 0101 (binary) = 5
<<	Left-Shift	aNum = 16 << 4;   //aNum = 256 (shift bits 4 spaces) //16 = 10000 (binary) so... 100000000 (binary) = 256
>>	Right-Shift	aNum = 16 >> 2;   //aNum = 4 (shift bits 2 spaces) //16 = 10000 (binary) so... 100 (binary) = 4

• Read More...

• //OVERLOADING OPERATORS:

• //className operatorName(const classNameReference);
• 
  
• //Overloaded Operators...
• 1. //See “OVERLOADING OPERATORS” section under C++ Classes
• Read More...

//C++ Arrays:

• //SINGLE-DIMENSIONAL ARRAYS:

• //dataType varName[elementNum] = {value, value, ...};
• 
  
• //Declaring & Initializing Single-Dimensional Arrays...
• 1. dataType varName[integerValue] = {value, value, ...};
  2. 
     
  3. //example...
  4. //A Single-Dimensional Array is like a list.
  5. //An integer Array
  6. int anArray[3] = {0};   //This will initialize ALL elements in the array to 0!
  7. int anArray2[3] = {1, 2};
     //Saves 1 and 2 to the 1st 2 elements and 0 in ALL others!
  8. 
     
  9. int myArray[5] = {0, 1, 2, 3, 4};   //indexing for Arrays start at 0 so...
  10. cout << myArray[0];   //This statement will print 0 to the screen
  11. 
      
  12. //Assignment works similar to Variables...
  13. myArray[3] = 25;   //The fourth element in myArray is now 25
  14. 
      
  15. //One thing to remember about Arrays...
  16. //int myArray[5]; will create an Array with 5 elements
  17. //But the last element (the 5th one) will be referenced with myArray[4]
• Read More...

• //MULTI-DIMENSIONAL ARRAYS:

• //dataType varName[elementNum][elementNum] ... = {value, value, ...};
• 
  
• //Declaring & Initializing Multi-Dimensional Arrays...
• 1. dataType varName[integerValue][integerValue] ... = {value, value, ...};
  2. 
     
  3. //example...
  4. //Two-Dimensional Arrays are like a grid.
  5. //Multi-Dimensional Arrays can eat up a LOT of memory so be careful!
  6. 
     
  7. //A Two-Dimensional integer Array
  8. int myArray[3][5] = {0};   //This will initialize ALL elements in the array to 0!
  9. int myArray2[3][5] = {1, 2};
     //Saves 1 and 2 to the 1st 2 elements and 0 in ALL others!
  10. 
      
  11. int anArray[3][5] = {    0,    1,   2,    3,    4,
  12.                                  5,    6,   7,    8,    9,
  13.                                10,  11,  12,  13,  14    };
  14. //Using nested for loops to print the values in a Multi-Dimensional Array
  15. for(int i = 0; i < 3; i++) {   //Loops for index i = 0 - 2 (3 times)
  16.      for(int f = 0; f < 5; f++) {   //Loops for index f = 0 - 4 (5 times)
  17.           cout << anArray[i][f] << “, ”;
  18.      }
  19.      //Start a new row after a value for every column is printed...
  20.      cout << endl;
  21. }
  22. 
      
  23. //A Two-Dimensional boolean Array
  24. bool anotherArray[3][5];
  25. //Using nested for loops to initialize the Multi-Dimensional Array
  26. for(int i = 0; i < 3; i++) {   //Loops for index i = 0 - 2 (3 times)
  27.      for(int f = 0; f < 5; f++) {   //Loops for index f = 0 - 4 (5 times)
  28.           anotherArray[i][f] = false;
  29.      }
  30. }
• Read More...

//C++ Decision Structures:

• //IF/ELSE IF/ELSE STATEMENTS:

• //decisionType(expression) { codeToExecute; }
• 
  
• //Using If/Else If/Else Statements...
• 1. if(expressionIsTrue) {
  2. }
  3. else if(expressionIsTrue) {
  4. }
  5. else {
  6. }
  7. 
     
  8. //example...
  9. int varName = 0;
  10. //only one of the following will execute...
  11. //if(expressionIsTrue) { codeToExecute; }
  12. if(varName == 1) {
  13. 
      
  14. }
  15. //else if(expressionIsTrue) { codeToExecute; }
  16. else if(varName == 2) {   //if not equal to 1 is it 2
  17. 
      
  18. }
  19. //else { codeToExecute; }
  20. else {   //any value except 1 or 2
  21. 
      
  22. }
• Read More...

• //SWITCH STATEMENTS:

• //switch(varName) { case value: codeToExecute; break; ... default: codeToExecute; }
• 
  
• //Using Switch Statements...
• 1. switch(varName) {
  2.      case value:
  3.           break;
  4.      case value:
  5.           break;
  6.      default:
  7. }
  8. 
     
  9. //example...
  10. //void srand(unsignedIntegerValue);
  11. srand(time(NULL));   //Initialize random number generator
  12. int i = rand() % 100;   //Limits random number to 0 - 99
  13. //switch(var) { case varValue: codeToExecute; break; default: }
  14. switch(i) {
  15.      //if using a char value you need single quotes - 'A'
  16.      case 0:
  17.           //code for when i = 0;
  18.           break;
  19.      case 1:
  20.           //code for when i = 1;
  21.           break;
  22.      default:
  23.           //code for default processing; - like else statement
  24. }
• Read More...

//C++ Looping Structures:

• //WHILE LOOPS:

• //while(expressionIsTrue) { codeToExecute; }
• 
  
• //Using While Loops...
• 1. while(expressionIsTrue) {
  2. }
  3. 
     
  4. //example...
  5. //while(expressionIsTrue) { codeToExecute; }
  6. while(varName < 10) {
  7.      //code here will execute repeatedly as long as varName is less than 10
  8. }
• Read More...

• //DO...WHILE LOOPS:

• //do { codeToExecute; }while(expressionIsTrue);
• 
  
• //Using Do...While Loops...
• 1. do {
  2. }while(expressionIsTrue);
  3. 
     
  4. //example...
  5. //do...while loops will ALWAYS execute at least once...
  6. //do { codeToExecute; }while(expressionIsTrue);
  7. do {
  8.      //code here will execute once & repeat while varName is less than 10
  9. }while(varName < 10);
• Read More...

• //FOR LOOPS:

• //for(int indexVarName = startValue; indexVarName expressionWhileTrue; indexVarName loopIncrementation) { codeToExecute; }
• 
  
• //Using For Loops...
• 1. for(int indexVarName = value; indexVarName expressionWhileTrue; indexVarName loopIncrementation) {
  2. }
  3. 
     
  4. //example...
  5. //for(startingCondition; exitCondition; iteration) { codeToExecute; }
  6. for(int i = 0; i < 10; i++) {
  7.      //code here will execute exactly 10 times (where i = 0 to 9)
  8. }
• Read More...

//C++ Pointers & Referencing:

• //POINTERS:

• //dataType *varName = memoryAddress;
• 
  
• //Declaring & Initializing Pointers...
• 1. /*
  2. Pointers point to locations in memory
  3. It's faster to redirect pointers than to overwrite values
  4. Pointers are great for sorting arrays!
  5. */
  6. dataType *varName = memoryAddress;
  7. 
     
  8. //example...
  9. //Assigning Memory Addresses to Pointers...
  10. int intVariable = 75;
  11. //There are two ways to assign a memory location to declared pointers...
  12. int *intPointer;
  13. *intPointer = intVariable;   //or...
  14. intPointer = &intVariable;
  15. //There's only one way to declare & initialize pointers in one line...
  16. int *intPointer = &intVariable;
  17. 
      
  18. //Extracting data from Pointers...
  19. cout << intPointer << endl;   //returns Memory Address of pointer
  20. cout << &intPointer << endl;   //returns Memory Address of pointer
  21. cout << *intPointer << endl;   //returns Value stored at pointer
  22. 
      
  23. //Using Values stored at Pointer locations...
  24. *intPointer = 85;   //Saves value 85 to location intPointer is pointing
  25. int aNumber = *intPointer;   //Saves the pointer's value to a variable
  26. 
      
  27. //Pointers are similar to arrays - an index can access adjacent values...
  28. cout << intPointer[0] << endl;   //returns Value stored at pointer
  29. cout << intPointer[1] << endl;   //returns Value stored at next location
  30. cout << &intPointer[0] << endl;   //returns Memory Address of pointer
  31. cout << &intPointer[1] << endl;   //returns Address of next location
  32. 
      
  33. //Dynamically Allocating Memory with Pointers...
  34. int *intPointer;   //Declare a Pointer to the Integer Data Type
  35. intPointer = new int;   //Dynamically Allocate a new place in memory
  36. intPointer = new int[10];   //Integer Pointers can also point to Integer Arrays
  37. 
      
  38. //You can also Declare and Initialize a pointer in the same line...
  39. bool *boolPointer = new bool[10];   //A Boolean Pointer
  40. char *charPointer = new char[10];   //A Character Pointer
  41. int *intPointer = new int[10];   //An integer Pointer
  42. float *floatPointer = new float[10];   //A Floating Point Pointer
  43. double *doublePointer = new double[10];   //A Double Floating Point Pointer
  44. string *stringPointer = new string[10];   //A String Pointer
  45. 
      
  46. //Practical Example...
  47. #include <cstdlib>
  48. #include <iostream>
  49. using namespace std;
  50. 
      
  51. int main(int argc, char *argv[]) {
  52.      int size = 0;
  53.      char tempChar[100] = “\0”;
  54. 
      
  55.      cout << “Please enter the number of names for the list: ”;
  56.      cin >> size;
  57.      cin.ignore();
  58.      cout << endl;
  59. 
      
  60.      string *stringList = new string[size];
  61. 
      
  62.      for(int i = 0; i < size; i++) {
  63.           cout << “Please enter a name: ”;
  64.           cin.getline(tempChar, 100);
  65.           stringList[i] = tempChar;
  66.      }
  67. 
      
  68.      cout << “\nThe names are:\n”;
  69.      for(int i = 0; i < size; i++) {
  70.           cout << stringList[i] << endl;
  71.      }
  72.      cout << endl;
  73. 
      
  74.      system(“PAUSE”);
  75.      return EXIT_SUCCESS;
  76. }
• Read More...

• //REFERENCING:

• //dataType varName& = value;
• 
  
• //Using a Reference...
• 1. dataType varName&;
  2. 
     
  3. //A Reference is like a copy of an object so you cannot change the value of the original
  4. //They are used...
• Read More...

//C++ Functions:

• //FUNCTION PROTOTYPES:

• //returnDataType functionName(dataTypesOfParameters);
• 
  
• //Syntax for Function Prototypes...
• 1. returnDataType functionName(dataType, dataType, ...);
  2. 
     
  3. //example...
  4. //prototype for a function to return an integer value
  5. int getHours(int, bool);
• Read More...

• //FUNCTION DEFINITIONS:

• //returnDataType functionName(dataTypesOfParameters varNames) { }
• 
  
• //Syntax for Function Definitions...
• 1. returnDataType functionName(dataType varName, dataType varName, ...) {
  2.      return value;
  3. }
  4. 
     
  5. //example...
  6. //definition for a function to return an integer value
  7. int getHours(int aNumber, bool isTrue) {
  8.      //Code to complete the function algorithm goes here
  9.      return 5;   //MUST return integer because of returnType
  10. }
• Read More...

• //CALLING FUNCTIONS:

• //varName = functionName( parameterValues );
• 
  
• //Syntax for Calling Functions...
• 1. returnDataType = functionName(varName, varName, ...);
  2. 
     
  3. //example...
  4. int totalHours = 0;
  5. //function call for a function to return an integer value
  6. totalHours = getHours(15, true);
• Read More...

• //FRIEND FUNCTIONS:

• //friend returnDataType functionName(dataTypesOfParameters);
• 
  
• //Friend Functions...
• 1. //See “FRIEND FUNCTIONS TO A CLASS” section under C++ Classes

• //OVERLOADING FUNCTIONS:

• //returnDataType functionName(dataTypesOfParameters);
• 
  
• //Overloading Functions...
• 1. //An Overloaded function has multiple definitions w/ different parameters
  2. //The MUST be a different number of parameters or different dataTypes
  3. returnDataType overloadedFunctionName(dataTypeOfParameter)
  4. returnDataType overloadedFunctionName(dataTypeOfParameter, dataTypeOfParameter)
  5. 
     
  6. //example...
  7. //Valid Overloaded Function Prototypes...
  8. //Notice that the returnDataType & the functionName stay the same
  9. //ONLY the parameters change!
  10. int overloadMe();
  11. int overloadMe(bool);
  12. int overloadMe(int);
  13. int overloadMe(int, int);
  14. 
      
  15. //Valid Overloaded Function Definitions...
  16. int overloadMe() {
  17.      //Code to complete the function algorithm
  18.      return integerValue;
  19. }
  20. int overloadMe(bool varName) {
  21.      //Code to complete the function algorithm
  22.      return integerValue;
  23. }
  24. int overloadMe(int varName) {
  25.      //Code to complete the function algorithm
  26.      return integerValue;
  27. }
  28. int overloadMe(int varName, int varName) {
  29.      //Code to complete the function algorithm
  30.      return integerValue;
  31. }
  32. 
      
  33. //Calling Valid Overloaded Functions...
  34. int num1 = 0, num2 = 0, num3 = 0, num4 = 0;
  35. bool isTrue = false;
  36. num1 = overloadMe();
  37. num1 = overloadMe(isTrue);
  38. num1 = overloadMe(num2);
  39. num1 = overloadMe(num3, num4);
• Read More...

//C++ Classes:

• //DECLARING A CLASS:

• //class className { public: protected: private: };
• 
  
• //Declaring a Class with Member Function Prototypes...
• 1. //Class Declarations should be saved in separate header files
  2. class className {
  3.      public:
  4.      protected:
  5.      private:
  6. };
  7. 
     
  8. //example...
  9. class addClass {
  10.           //Anything above declared sections defaults to public
  11. 
      
  12.      public:
  13.           //Code within public is available to all modules
  14.           //Generally speaking it's good to put your functions in public
  15.           addClass();   //Default Constructor
  16.           ~addClass();   //Destructor
  17.           int addNum(int, int);
  18.           int getNumOne();   //Accessor
  19. 
      
  20.      protected:
  21.           //Code within protected is ONLY available to child classes
  22.           //Private data MUST be here to be accessed with inherited classes
  23. 
      
  24.      private:
  25.           //Code within private is ONLY availabe to this class
  26.           //Generally speaking it's good to put your data in private
  27.           int num1;
  28.           int num2;
  29. };
• Read More...

• //CLASS MEMBER FUNCTION DEFINITIONS:

• //returnType className::functionName( dataTypesOfParameters varNames) { }
• 
  
• //Inline Class Member Function Definitions...
• 1. //Inline Class Member Function Definitions...
  2. inline returnDataType className::functionName(dataType varName, dataType varName, ...) {
  3.      return value;
  4. }
  5. 
     
  6. //example...
  7. //Inline Definitions MUST be in the same file as the Class Declaration
  8. //NEVER dynamically allocate memory in a header file!
  9. //ONLY simple functions should be defined inline like Accessors...
  10. inline int addClass::getNumOne() {
  11.      //All member functions can access num1 because it's a member too
  12.      return num1;
  13. }
  14. 
      
• //Non-Inline Class Member Function Definitions...
• 1. //Non-Inline Class Member Function Definitions...
  2. returnDataType className::functionName(dataType varName, dataType varName, ...) {
  3.      return value;
  4. }
  5. 
     
  6. //example...
  7. //Non-Inline Definitions MUST be in a different file
  8. //Non-Inline Definitions MUST #include “headerFileName.h”
  9. int addClass::addNum(int num1, int num2) {
  10.      int total = num1 + num2;
  11.      return total;
  12. }
• Read More...

• //CALLING CLASS MEMBER FUNCTIONS:

• //classInstanceName.functionName(varNames);
• 
  
• //Calling Class Member Functions...
• 1. varName = classInstanceName.functionName();
  2. 
     
  3. //example...
  4. //ONLY functions in the public category can be called from other modules
  5. //MUST #include “headerFileName.h” to declare a Class Instance...
  6. 
     
  7. #include “addClass.h”
  8. int main() {
  9.      int num1 = 1, num2 = 2, total = 0;   //Initialize some integers
  10.      addClass myClass;   //Call the Default Constructor
  11.      total = myClass.addNum(num1, num2);   //Call the member function
  12.      return 0;   //Return a value to exit the main module
  13. }
  14. 
      
  15. //Accessing Class Data is similar to calling Class Member Functions...
  16. cout << myClass.num1;   //This only works if num1 is declared in “public!”
• Read More...

• //CLASS INHERITANCE:

• //class className : inheritanceType otherClassName { public: prototype: private: };
• 
  
• //Class Inheritance...
• 1. class className : inheritanceType otherClassName {
  2.      public:
  3.      protected:
  4.      private:
  5. };
  6. 
     
  7. //example...
  8. //The inheritanceType affects how data is imported into the child class
  9. 
     
  10. //Parent class “soldier” in soldierClass.h file...
  11. class soldier {
  12.      public:
  13.           soldier();
  14.           soldier(soldier&);
  15.           soldier(int, int, int);
  16.           ~soldier();
  17.           int getHitPoints();
  18.           int getAccuracy();
  19.           int getJogSpeed();
  20.           void setHitPoints(int);
  21.           void setAccuracy(int);
  22.           void setJobSpeed(int);
  23.      protected:
  24.           //Ammo values are save in weapon objects (class DMRClass)
  25.           int hitPoints;
  26.           int accuracy;
  27.           int jogSpeed;
  28.           //CrouchSpeed, & SprintSpeed are = for all classes
  29.      private:
  30. };
  31. 
      
  32. //Child class “sniper” in sniperClass.h file...
  33. //Imports public & protected from soldier and saves to private in sniper
  34. 
      
  35. #include “soldierClass.h”
  36. class sniper : private soldier {
  37.      public:
  38.           sniper();
  39.           sniper(sniper&);
  40.           sniper(int, int, int);
  41.           ~sniper();
  42.           string getAbility();
  43.           int getZeroBloomTime();
  44.           void setAbliity(string);
  45.           void setZeroBloomTime(int);
  46.      protected:
  47.      private:
  48.           string ability;   //Like invisiblity
  49.           int zeroBloomTime;   //Like holding your breath before a shot
  50. };
  51. 
      
  52. /*
  53. The sniper class now has access to all the functions and variables in both the public & protected sections of the soldier class
  54. */
• Read More...

• //FRIEND FUNCTIONS TO A CLASS:

• //friend returnDataType functionName(dataTypesOfParameters);
• 
  
• //Friend Functions to a Class...
• 1. /*
  2. Friend functions are NOT class member functions
  3. But they can access protected & private data of the class
  4. */
  5. class className {
  6.      public:
  7.           friend returnDataType functionName();
  8.      protected:
  9.      private:
  10. };
  11. 
      
  12. //example...
  13. //Friend Function Prototype (in the class declaration)
  14. class myClass {
  15.      public:
  16.           friend myClass Calculations(int);
  17.           myClass();
  18.      protected:
  19.      private:
  20.           int aNumber;
  21. };
  22. 
      
  23. //Friend Function Definition
  24. //Notice that Friend Functions do NOT need className::functionName
  25. myClass Calculations(int anotherNumber) {
  26.      myClass tempClass;
  27.      //Calculations can ONLY access “aNumber” because it's a friend
  28.      tempClass.aNumber *= anotherNumber;
  29.      return tempClass;
  30. }
  31. 
      
  32. //Calling a Friend Function
  33. int calc = 6;
  34. myClass aClass;
  35. //Notice that Friend Functions do NOT need className.functionName
  36. aClass = Calculations(calc);
• Read More...

• //OVERLOADING OPERATORS:

• //returnType operatorName(const dataTypeReference varName) { }
• 
  
• //Example shapeRec Class Declaration...
• 1. #ifndef shapeRecClass_H
  2. #define shapeRecClass_H
  3. 
     
  4. #include <cstdlib>
  5. #include <iostream>
  6. #include <iomanip>
  7. using namespace std;
  8. 
     
  9. class shapeRec {
  10.           //Overloaded Stream Operators...
  11.           friend ostream& operator<<(ostream&, const shapeRec&);
  12.           friend istream& operator>>(istream&, shapeRec&);
  13. 
      
  14.           //Overloaded Arithmetic Operators...
  15.           friend shapeRec operator+(const shapeRec&, const shapeRec&);
  16.           friend shapeRec operator-(const shapeRec&, const shapeRec&);
  17.           friend shapeRec operator*(const shapeRec&, const shapeRec&);
  18.           friend shapeRec operator/(const shapeRec&, const shapeRec&);
  19. 
      
  20.           //Overloaded Assignment Operator...
  21. 
      
  22.           //Overloaded Compound-Assignment Operators...
  23. 
      
  24.           //Overloaded Increment & Decrement Operators...
  25.           friend shapeRec operator++(shapeRec&);
  26.           friend shapeRec operator++(shapeRec&, int);
  27.           friend shapeRec operator--(shapeRec&);
  28.           friend shapeRec operator--(shapeRec&, int);
  29. 
      
  30.           //Overloaded Relational Operators...
  31.           friend bool operator==(const shapeRec&, const shapeRec&);
  32.           friend bool operator!=(const shapeRec&, const shapeRec&);
  33.           friend bool operator<=(const shapeRec&, const shapeRec&);
  34.           friend bool operator<(const shapeRec&, const shapeRec&);
  35.           friend bool operator>=(const shapeRec&, const shapeRec&);
  36.           friend bool operator>(const shapeRec&, const shapeRec&);
  37. 
      
  38.      public:
  39.           //Constructors...
  40.           shapeRec();
  41.           shapeRec(double, double);
  42.           shapeRec(shapeRec&);
  43. 
      
  44.           //Destructor...
  45.           ~shapeRec();
  46. 
      
  47.           //Accessors...
  48.           double getLength() const;
  49.           double getWidth() const;
  50. 
      
  51.           //Mutators...
  52.           void setDimensions(double, double);
  53. 
      
  54.           //Calculators...
  55.           double calcPerimeter() const;
  56.           double calcArea() const;
  57. 
      
  58.      private:
  59.           //Private Data...
  60.           double length;
  61.           double width;
  62. };
  63. 
      
  64. #endif
• 
  
• //Overloaded Stream Operators...
• 1. //Overloaded Stream Insertion Operator...
  2. ostream& operator<<(ostream& varName, const className& varName) {
  3.      return varName;
  4. }
  5. 
     
  6. //example...
  7. //Overloaded Stream Insertion Operator Prototype (in Class Declaration .h)
  8. friend ostream& operator<<(ostream&, const shapeRec&);
  9. 
     
  10. //Overloaded Stream Insertion Operator Definition (in Class Definitions .cpp)
  11. ostream& operator<<(ostream& osObj, const shapeRec& myRec) {
  12.      osObj << fixed << setprecision(2);
  13.      osObj << “Length = ” << myRec.length << endl;
  14.      osObj << “Width = ” << myRec.width << endl;
  15.      osObj << “Perimeter = ” << myRec.calcPerimeter() << endl;
  16.      osObj << “Area = ” << myRec.calcArea() << endl;
  17.      return osObj;
  18. }
  19. 
      
  20. //Overloaded Stream Insertion Operator Call (in Main Definition .cpp)
  21. int main() {
  22.      shapeRec aRec;
  23.      cout << aRec;
  24. }
  25. 
      
  26. 
      
  27. 
      
  28. //Overloaded Stream Extraction Operator...
  29. istream& operator>>(istream& varName, shapeRec& varName) {
  30.      return varName;
  31. }
  32. 
      
  33. //example...
  34. //Overloaded Stream Extraction Operator Prototype (in Class Declaration .h)
  35. friend istream& operator>>(istream&, shapeRec&);
  36. 
      
  37. //Overloaded Stream Extraction Operator Definition (in Class Definitions .cpp)
  38. istream& operator>>(istream& isObj, shapeRec& myRec) {
  39.      double tempLength = 0.0;
  40.      double tempWidth = 0.0;
  41.      char temp = '\0';
  42.      cout << “Please enter length and width (1.0,1.0):\n”;
  43.      isObj >> tempLength >> temp >> tempWidth;
  44.      myRec.setDimensions(tempLength, tempWidth);
  45.      return isObj;
  46. }
  47. 
      
  48. //Overloaded Stream Extraction Operator Call (in Main Definition .cpp)
  49. int main() {
  50.      shapeRec aRec;
  51.      cin >> aRec;
  52. }
• 
  
• //Overloaded Arithmetic Operators...
• 1. //Overloaded Addition Operator...
  2. 
     
  3. //example...
  4. //Overloaded Addition Operator Prototype (in Class Declaration .h)
  5. 
     
  6. //Overloaded Addition Operator Definition (in Class Definitions .cpp)
  7. 
     
  8. //Overloaded Addition Operator Call (in Main Definition .cpp)
  9. 
     
  10. 
      
  11. 
      
  12. //Overloaded Subtraction Operator...
  13. 
      
  14. //example...
  15. //Overloaded Subtraction Operator Prototype (in Class Declaration .h)
  16. 
      
  17. //Overloaded Subtraction Operator Definition (in Class Definitions .cpp)
  18. 
      
  19. //Overloaded Subtraction Operator Call (in Main Definition .cpp)
  20. 
      
  21. 
      
  22. 
      
  23. //Overloaded Multiplication Operator...
  24. 
      
  25. //example...
  26. //Overloaded Multiplication Operator Prototype (in Class Declaration .h)
  27. 
      
  28. //Overloaded Multiplication Operator Definition (in Class Definitions .cpp)
  29. 
      
  30. //Overloaded Multiplication Operator Call (in Main Definition .cpp)
  31. 
      
  32. 
      
  33. 
      
  34. //Overloaded Division Operator...
  35. 
      
  36. //example...
  37. //Overloaded Division Operator Prototype (in Class Declaration .h)
  38. 
      
  39. //Overloaded Division Operator Definition (in Class Definitions .cpp)
  40. 
      
  41. //Overloaded Division Operator Call (in Main Definition .cpp)
  42. 
      
  43. 
      
  44. 
      
  45. //Overloaded Modulus Operator...
  46. 
      
  47. //example...
  48. //Overloaded Modulus Operator Prototype (in Class Declaration .h)
  49. 
      
  50. //Overloaded Modulus Operator Definition (in Class Definitions .cpp)
  51. 
      
  52. //Overloaded Modulus Operator Call (in Main Definition .cpp)
• 
  
• //Overloaded Assignment Operator...
• 1. //Overloaded Assignment Operator...
  2. 
     
  3. //example...
  4. //Overloaded Assignment Operator Prototype (in Class Declaration .h)
  5. 
     
  6. //Overloaded Assignment Operator Definition (in Class Definitions .cpp)
  7. 
     
  8. //Overloaded Assignment Operator Call (in Main Definition .cpp)
• 
  
• //Overloaded Compound-Assignment Operators...
• 1. //Overloaded Addition-Equals Assignment Operator...
  2. 
     
  3. //example...
  4. //Overloaded Addition-Equals Assignment Operator Prototype (in Class Declaration .h)
  5. 
     
  6. //Overloaded Addition-Equals Assignment Operator Definition (in Class Definitions .cpp)
  7. 
     
  8. //Overloaded Addition-Equals Assignment Operator Call (in Main Definition .cpp)
  9. 
     
  10. 
      
  11. 
      
  12. //Overloaded Subtraction-Equals Assignment Operator...
  13. 
      
  14. //example...
  15. //Overloaded Subtraction-Equals Assignment Operator Prototype (in Class Declaration .h)
  16. 
      
  17. //Overloaded Subtraction-Equals Assignment Operator Definition (in Class Definitions .cpp)
  18. 
      
  19. //Overloaded Subtraction-Equals Assignment Operator Call (in Main Definition .cpp)
  20. 
      
  21. 
      
  22. 
      
  23. //Overloaded Multiplication-Equals Assignment Operator...
  24. 
      
  25. //example...
  26. //Overloaded Multiplication-Equals Assignment Operator Prototype (in Class Declaration .h)
  27. 
      
  28. //Overloaded Multiplication-Equals Assignment Operator Definition (in Class Definitions .cpp)
  29. 
      
  30. //Overloaded Multiplication-Equals Assignment Operator Call (in Main Definition .cpp)
  31. 
      
  32. 
      
  33. 
      
  34. //Overloaded Division-Equals Assignment Operator...
  35. 
      
  36. //example...
  37. //Overloaded Division-Equals Assignment Operator Prototype (in Class Declaration .h)
  38. 
      
  39. //Overloaded Division-Equals Assignment Operator Definition (in Class Definitions .cpp)
  40. 
      
  41. //Overloaded Division-Equals Assignment Operator Call (in Main Definition .cpp)
  42. 
      
  43. 
      
  44. 
      
  45. //Overloaded Modulus-Equals Assignment Operator...
  46. 
      
  47. //example...
  48. //Overloaded Modulus-Equals Assignment Operator Prototype (in Class Declaration .h)
  49. 
      
  50. //Overloaded Modulus-Equals Assignment Operator Definition (in Class Definitions .cpp)
  51. 
      
  52. //Overloaded Modulus-Equals Assignment Operator Call (in Main Definition .cpp)
• 
  
• //Overloaded Increment & Decrement Operators...
• 1. //Overloaded Pre-Increment Operator...
  2. 
     
  3. //example...
  4. //Overloaded Pre-Increment Operator Prototype (in Class Declaration .h)
  5. 
     
  6. //Overloaded Pre-Increment Operator Definition (in Class Definitions .cpp)
  7. 
     
  8. //Overloaded Pre-Increment Operator Call (in Main Definition .cpp)
  9. 
     
  10. 
      
  11. 
      
  12. //Overloaded Post-Increment Operator...
  13. 
      
  14. //example...
  15. //Overloaded Post-Increment Operator Prototype (in Class Declaration .h)
  16. 
      
  17. //Overloaded Post-Increment Operator Definition (in Class Definitions .cpp)
  18. 
      
  19. //Overloaded Post-Increment Operator Call (in Main Definition .cpp)
  20. 
      
  21. 
      
  22. 
      
  23. //Overloaded Pre-Decrement Operator...
  24. 
      
  25. //example...
  26. //Overloaded Pre-Decrement Operator Prototype (in Class Declaration .h)
  27. 
      
  28. //Overloaded Pre-Decrement Operator Definition (in Class Definitions .cpp)
  29. 
      
  30. //Overloaded Pre-Decrement Operator Call (in Main Definition .cpp)
  31. 
      
  32. 
      
  33. 
      
  34. //Overloaded Post-Decrement Operator...
  35. 
      
  36. //example...
  37. //Overloaded Post-Decrement Operator Prototype (in Class Declaration .h)
  38. 
      
  39. //Overloaded Post-Decrement Operator Definition (in Class Definitions .cpp)
  40. 
      
  41. //Overloaded Post-Decrement Operator Call (in Main Definition .cpp)
• 
  
• //Overloaded Relational Operators...
• 1. //Overloaded Equality Operator...
  2. 
     
  3. //example...
  4. //Overloaded Equality Operator Prototype (in Class Declaration .h)
  5. 
     
  6. //Overloaded Equality Operator Definition (in Class Definitions .cpp)
  7. 
     
  8. //Overloaded Equality Operator Call (in Main Definition .cpp)
  9. 
     
  10. 
      
  11. 
      
  12. //Overloaded In-Equality Operator...
  13. 
      
  14. //example...
  15. //Overloaded In-Equality Operator Prototype (in Class Declaration .h)
  16. 
      
  17. //Overloaded In-Equality Operator Definition (in Class Definitions .cpp)
  18. 
      
  19. //Overloaded In-Equality Operator Call (in Main Definition .cpp)
  20. 
      
  21. 
      
  22. 
      
  23. //Overloaded Less-Than-or-Equal-To Operator...
  24. 
      
  25. //example...
  26. //Overloaded Less-Than-or-Equal-To Operator Prototype (in Class .h)
  27. 
      
  28. //Overloaded Less-Than-or-Equal-To Operator Definition (in Class .cpp)
  29. 
      
  30. //Overloaded Less-Than-or-Equal-To Operator Call (in Main .cpp)
  31. 
      
  32. 
      
  33. 
      
  34. //Overloaded Less-Than Operator...
  35. 
      
  36. //example...
  37. //Overloaded Less-Than Operator Prototype (in Class Declaration .h)
  38. 
      
  39. //Overloaded Less-Than Operator Definition (in Class Definitions .cpp)
  40. 
      
  41. //Overloaded Less-Than Operator Call (in Main Definition .cpp)
  42. 
      
  43. 
      
  44. 
      
  45. //Overloaded Greater-Than-or-Equal-To Operator...
  46. 
      
  47. //example...
  48. //Overloaded Greater-Than-or-Equal-To Operator Prototype (in Class .h)
  49. 
      
  50. //Overloaded Greater-Than-or-Equal-To Operator Definition (in Class .cpp)
  51. 
      
  52. //Overloaded Greater-Than-or-Equal-To Operator Call (in Main .cpp)
  53. 
      
  54. 
      
  55. 
      
  56. //Overloaded Greater-Than Operator...
  57. 
      
  58. //example...
  59. //Overloaded Greater-Than Operator Prototype (in Class Declaration .h)
  60. 
      
  61. //Overloaded Greater-Than Operator Definition (in Class Definitions .cpp)
  62. 
      
  63. //Overloaded Greater-Than Operator Call (in Main Definition .cpp)
• Read More...

• 
  

• //Coplien's Orthodox Canonical Form - Design:

• • //COCF CLASS PROTOTYPES:
• • //DEFAULT CONSTRUCTOR PROTOTYPE...
  • //className();
  • 
    
  • //COPY CONSTRUCTOR PROTOTYPE...
  • //className(classNameReference);
  • 
    
  • //WORKING CONSTRUCTOR PROTOTYPE...
  • //className(dataTypesOfParameters);
  • 
    
  • //DEFAULT DESTRUCTOR PROTOTYPE...
  • //~className();
  • 
    
  • //COCF Class Prototypes...
  • 1. class className {
    2.      public:
    3.           className();
    4.           className(className&);
    5.           className(dataType, dataType, ...);
    6.           ~className();
    7.      protected:
    8.      private:
    9.           dataType varName;
    10. };
    11. 
        
    12. //example...
    13. class myClass {
    14.           //Anything above declared sections defaults to public
    15. 
        
    16.      public:
    17.           //Code within public is available to all modules
    18.           //Generally speaking it's good to put your functions in public
    19. 
        
    20.           //Default Constructor Prototype...
    21.           myClass();
    22. 
        
    23.           //Copy Constructor Prototype...
    24.           myClass(myClass&);
    25. 
        
    26.           //Working Constructor Prototype...
    27.           //There should be a parameter for every data variable in the class
    28.           myClass(int, int, int);
    29. 
        
    30.           //Default Destructor Prototype...
    31.           ~myClass();
    32. 
        
    33.           //There should be an Accessor and Mutator for every data variable
    34.           int getANum();   //Accessor
    35.           int getAotherNum();   //Accessor
    36.           void setANum(int);   //Mutator
    37.           void setAnotherNum(int);   //Mutator
    38. 
        
    39.      protected:
    40.           //Code within protected is ONLY available to child classes
    41.           //Private data MUST be here to be accessed with inherited classes
    42. 
        
    43.      private:
    44.           //Code within private is ONLY availabe to this class
    45.           //Generally speaking it's good to put your data in private
    46.           int aNum;
    47.           int anotherNum;
    48.           int *anArray;
    49. };
  • Read More...
• • //COCF CLASS DEFINITIONS:
• • //DEFAULT CONSTRUCTOR DEFINITION...
  • //className::className(){ }
  • 
    
  • //COPY CONSTRUCTOR DEFINITION...
  • //className::className(className classInstanceNameReference){ }
  • 
    
  • //WORKING CONSTRUCTOR DEFINITION...
  • //className::className(dataTypesOfParameters varNames){ }
  • 
    
  • //DEFAULT DESTRUCTOR DEFINITION...
  • //className::~className(){ }
  • 
    
  • //COCF Class Definitions...
  • 1. //Default Constructor Definition...
    2. //Constructors have no return type, but do NOT need the keyword void
    3. className::className() {
    4. }
    5. 
       
    6. //example...
    7. myClass::myClass() {
    8.      aNum = 0;
    9.      anotherNum = 0;
    10.      //NEVER dynamically allocate memory in a header file (not inline)
    11.      anArray = new int[10];
    12. }
    13. 
        
    14. 
        
    15. //Copy Constructor Definition...
    16. //Constructors have no return type, but do NOT need the keyword void
    17. className::className(className classInstanceName&) {
    18. }
    19. 
        
    20. //example...
    21. myClass::myClass(myClass anotherClass&) {
    22.      //Use the parameter passed to the Constructor to assign values...
    23.      aNum = anotherClass.aNum;
    24.      anotherNum = anotherClass.anotherNum;
    25.      anArray = anotherClass.anArray;
    26. }
    27. 
        
    28. 
        
    29. //Working Constructor Definition...
    30. //Constructors have no return type, but do NOT need the keyword void
    31. className::className(dataType varName, dataType varName, ...) {
    32. }
    33. 
        
    34. //example...
    35. myClass::myClass(int temp1, int temp2, int temp3) {
    36.      //Use the parameters passed to the Constructor to assign values...
    37.      aNum = temp1;
    38.      anotherNum = temp2;
    39.      //NEVER dynamically allocate memory in a header file (not inline)
    40.      anArray = new int[temp3];
    41. }
    42. 
        
    43. 
        
    44. //Default Destructor Definition...
    45. //Destructors have no return type, but do NOT need the keyword void
    46. inline className::~className() {
    47.      delete varName;
    48. }
    49. 
        
    50. //example...
    51. //It's ok to define Destructors in header files (inline)
    52. inline myClass::~myClass() {
    53.      //ALWAYS delete variables with dynamically allocated memory!
    54.      delete anArray;
    55. }
    56. 
        
  • Read More...
• • //CALLING COCF CLASSES:
• • //CALLING A DEFAULT CONSTRUCTOR...
  • //className classInstanceName;
  • 
    
  • //CALLING A COPY CONSTRUCTOR...
  • //className classInstanceName(classInstanceName);
  • 
    
  • //CALLING A WORKING CONSTRUCTOR...
  • //className classInstanceName(varNames);
  • 
    
  • //CALLING A DEFAULT DESTRUCTOR...
  • //Destructors are automatically called by the system
  • 
    
  • //Calling COCF Classes...
  • 1. //Calling a Default Constructor...
    2. className classInstanceName;
    3. 
       
    4. //example...
    5. //ONLY functions in the public category can be called from other modules
    6. //MUST #include “headerFileName.h” to declare a Class Instance...
    7. 
       
    8. #include “myClass.h”
    9. int main() {
    10.      myClass aClass;   //Call the Default Constructor
    11.      return 0;   //Return a value to exit the main module
    12. }
    13. 
        
    14. 
        
    15. //Calling a Copy Constructor...
    16. className classInstanceName(classInstanceName);
    17. 
        
    18. //example...
    19. //ONLY functions in the public category can be called from other modules
    20. //MUST #include “headerFileName.h” to declare a Class Instance...
    21. 
        
    22. #include “myClass.h”
    23. int main() {
    24.      myClass aClass;   //Call the Default Constructor
    25.      myClass anotherClass(aClass);   //Call a Copy Constructor
    26.      return 0;   //Return a value to exit the main module
    27. }
    28. 
        
    29. 
        
    30. //Calling a Working Constructor...
    31. className classInstanceName(varNames);
    32. 
        
    33. //example...
    34. //ONLY functions in the public category can be called from other modules
    35. //MUST #include “headerFileName.h” to declare a Class Instance...
    36. 
        
    37. #include “myClass.h”
    38. int main() {
    39.      int num1 = 5, num2 = 15, num3 = 10;   //Initialize some integers
    40.      myClass aClass(num1, num2, num3);   //Call a Working Constructor
    41.      return 0;   //Return a value to exit the main module
    42. }
    43. 
        
    44. 
        
    45. //Calling a Default Destructor...
    46. //Destructors are automatically called by the system
  • Read More...