#include <iostream> 

using namespace std;

int main()       
{
  cout<< (char)65 <<"\n"; 
  // The (char) is a typecast, telling the computer to interpret the 65 as a
  //  character, not as a number.  It is going to give the character output of 
  //  the equivalent of the number 65 (It should be the letter A for ASCII).
  cin.get();
}

 
#include <iostream>

using namespace std;

int main()
{
  for ( int x = 0; x < 256; x++ ) {
    cout<< x <<". "<< (char)x <<" "; 
    //Note the use of the int version of x to 
    // output a number and the use of (char) to 
    // typecast the x into a character 	
    // which outputs the ASCII character that 
    // corresponds to the current number
  }
  cin.get();
}

 
int main()       
{
  cout<< char ( 65 ) <<"\n"; 
  cin.get();
}

 
int main()       
{
  cout<< static_cast<char> ( 65 ) <<"\n"; 
  cin.get();
}

Typecasts in practice

 
/* magical function returns the age in years */
int age = getAge();  
/* magical function returns the number of visits */
int pain_visits = getVisits(); 

float visits_per_year = pain_visits / age;

 
float visits_per_year = pain_visits / static_cast<float>(age);
/* or */
float visits_per_year = static_cast<float>(pain_visits) / age;

Lesson 10: C++ File I/O

ifstream a_file;

ifstream a_file ( "filename" );

 
#include <fstream>
#include <iostream>

using namespace std;

int main()
{
  char str[10];

  //Creates an instance of ofstream, and opens example.txt
  ofstream a_file ( "example.txt" );
  // Outputs to example.txt through a_file
  a_file<<"This text will now be inside of example.txt";
  // Close the file stream explicitly
  a_file.close();
  //Opens for reading the file
  ifstream b_file ( "example.txt" );
  //Reads one string from the file
  b_file>> str;
  //Should output 'this'
  cout<< str <<"\n";
  cin.get();    // wait for a keypress
  // b_file is closed implicitly here
}

 
ios::app   -- Append to the file
ios::ate   -- Set the current position to the end
ios::trunc -- Delete everything in the file

 
ofstream a_file ( "test.txt", ios::app );

 
ifstream a_file ( "example.txt" );

if ( !a_file.is_open() ) {
  // The file could not be opened
}
else {
  // Safely use the file stream
}

 
[][][][][][] 

 
int examplearray[100]; // This declares an array

 
char astring[100]; 

 
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]

 
int twodimensionalarray[8][8];

 
arrayname[arrayindexnumber] = whatever; 

 
arrayname[arrayindexnumber1][arrayindexnumber2] = whatever;

 
#include <iostream>

using namespace std;

int main()
{
  int x;
  int y;
  int array[8][8]; // Declares an array like a chessboard
  
  for ( x = 0; x < 8; x++ ) {
    for ( y = 0; y < 8; y++ )
      array[x][y] = x * y; // Set each element to a value
  }
  cout<<"Array Indices:\n";
  for ( x = 0; x < 8;x++ ) {
    for ( y = 0; y < 8; y++ )
      cout<<"["<<x<<"]["<<y<<"]="<< array[x][y] <<" ";
    cout<<"\n";
  }
  cin.get();
}

 
char *ptr;
char str[40];
ptr = str;  // Gives the memory address without a reference operator(&)

 
int *ptr;
int num;
ptr = # // Requires & to give the memory address to the ptr

 
struct Tag {
  Members
};

 
struct Tag name_of_single_structure;

 
name_of_single_structure.name_of_variable;

 
struct example {
  int x;
};
struct example an_example; //Treating it like a normal variable type
an_example.x = 33;  //How to access it's members

 
struct database {
  int id_number;
  int age;
  float salary;
};

int main()
{
  database employee;  //There is now an employee variable that has modifiable 
                      // variables inside it.
  employee.age = 22;
  employee.id_number = 1;
  employee.salary = 12000.21;
}

 
database fn();

 
#include <iostream>

using namespace std;

struct xampl {
  int x;
};

int main()
{  
  xampl structure;
  xampl *ptr;
  
  structure.x = 12;
  ptr = &structure; // Yes, you need the & when dealing with structures
                    //  and using pointers to them
  cout<< ptr->x;    // The -> acts somewhat like the * when used with pointers
                    //  It says, get whatever is at that memory address
                    //  Not "get what that memory address is"
  cin.get();                    
}

Lesson 6: An introduction to pointers

Pointer Syntax

 
<variable_type> *<name>; 

 
int *points_to_integer;

 
// one pointer, one regular int
int *pointer1, nonpointer1;

// two pointers
int *pointer1, *pointer2;

 
call_to_function_expecting_memory_address(pointer);

Pointing to Something: Retrieving an Address

 
#include <iostream>

using namespace std;

int main()
{ 
  int x;            // A normal integer
  int *p;           // A pointer to an integer

  p = &x;           // Read it, "assign the address of x to p"
  cin>> x;          // Put a value in x, we could also use *p here
  cin.ignore();
  cout<< *p <<"\n"; // Note the use of the * to get the value
  cin.get();
}

 
int *ptr = new int;

 
delete ptr;

Taking Stock of Pointers

Lesson 5: switch case in C and C++

 
switch ( <variable> ) {
case this-value:
  Code to execute if <variable> == this-value
  break;
case that-value:
  Code to execute if <variable> == that-value
  break;
...
default:
  Code to execute if <variable> does not equal the value following any of the cases
  break;
}

 
int a = 10;
int b = 10;
int c = 20;

switch ( a ) {
case b:
  // Code
  break;
case c:
  // Code
  break;
default:
  // Code
  break;
}

 
#include <iostream>

using namespace std;

void playgame()
{
    cout << "Play game called";
}
void loadgame()
{
    cout << "Load game called";
}
void playmultiplayer()
{
    cout << "Play multiplayer game called";
}
	
int main()
{
  int input;
  
  cout<<"1. Play game\n";
  cout<<"2. Load game\n";
  cout<<"3. Play multiplayer\n";
  cout<<"4. Exit\n";
  cout<<"Selection: ";
  cin>> input;
  switch ( input ) {
  case 1:            // Note the colon, not a semicolon
    playgame();
    break;
  case 2:            // Note the colon, not a semicolon
    loadgame();
    break;
  case 3:            // Note the colon, not a semicolon
    playmultiplayer();
    break;
  case 4:            // Note the colon, not a semicolon
    cout<<"Thank you for playing!\n";
    break;
  default:            // Note the colon, not a semicolon
    cout<<"Error, bad input, quitting\n";
    break;
  }
  cin.get();
}

Lesson 4: Functions

 
#include <cstdlib>   // Include rand()

using namespace std; // Make rand() visible

int a = rand(); // rand is a standard function that all compilers have

 
return-type function_name ( arg_type arg1, ..., arg_type argN ); 

 
int mult ( int x, int y );

 
#include <iostream>

using namespace std;

int mult ( int x, int y );

int main()
{
  int x;
  int y;
  
  cout<<"Please input two numbers to be multiplied: ";
  cin>> x >> y;
  cin.ignore();
  cout<<"The product of your two numbers is "<< mult ( x, y ) <<"\n";
  cin.get();
}

int mult ( int x, int y )
{
  return x * y;
}

 
cout<<"The product of your two numbers is "<< x * y <<"\n";