#include <iostream>
using std::cout;
using std::endl;
using std::fixed;
 
#include <iomanip>
using std::setprecision;
 
#include <vector>
using std::vector;
 
// include definitions of classes in Employee hierarchy
#include "Employee.h"
#include "SalariedEmployee.h" 
#include "HourlyEmployee.h"
#include "CommissionEmployee.h"  
#include "BasePlusCommissionEmployee.h" 
 
int main()
{
   // create derived-class objects
   SalariedEmployee salariedEmployee( 
      "John", "Smith", "111-11-1111", 800 );
   HourlyEmployee hourlyEmployee( 
      "Karen", "Price", "222-22-2222", 16.75, 40 );
   CommissionEmployee commissionEmployee( 
      "Sue", "Jones", "333-33-3333", 10000, .06 );
   BasePlusCommissionEmployee basePlusCommissionEmployee( 
      "Bob", "Lewis", "444-44-4444", 5000, .04, 300 );
 
   // create vector of four base-class pointers
   vector < Employee * > employees( 4 );
 
   // initialize vector with Employees
   employees[ 0 ] = &salariedEmployee;
   employees[ 1 ] = &hourlyEmployee;
   employees[ 2 ] = &commissionEmployee;
   employees[ 3 ] = &basePlusCommissionEmployee;
 
   return 0;
} // end main

Employee( const string &, const string &, const string & );
 
//constructor definition
Employee::Employee( const string &first, const string &last,
   const string &ssn )
   : firstName( first ), lastName( last ), socialSecurityNumber( ssn )
{
   // empty body 
} // end Employee constructor

HourlyEmployee( const string &, const string &, 
      const string &, double = 0.0, double = 0.0 );
 
// constructor definition
HourlyEmployee::HourlyEmployee( const string &first, const string &last, 
   const string &ssn, double hourlyWage, double hoursWorked )
   : Employee( first, last, ssn )   
{
   setWage( hourlyWage ); // validate hourly wage
   setHours( hoursWorked ); // validate hours worked
} // end HourlyEmployee constructor

SalariedEmployee( const string &, const string &, 
      const string &, double = 0.0 );
 
// constructor definition
SalariedEmployee::SalariedEmployee( const string &first, 
   const string &last, const string &ssn, double salary )
   : Employee( first, last, ssn )
{ 
   setWeeklySalary( salary ); 
} // end SalariedEmployee constructor

CommissionEmployee( const string &, const string &,
      const string &, double = 0.0, double = 0.0 );
 
// constructor defintion
CommissionEmployee::CommissionEmployee( const string &first, 
   const string &last, const string &ssn, double sales, double rate )
   : Employee( first, last, ssn )  
{
   setGrossSales( sales );
   setCommissionRate( rate );
} // end CommissionEmployee constructor

BasePlusCommissionEmployee( const string &, const string &,
      const string &, double = 0.0, double = 0.0, double = 0.0 );
 
//constructor definition
BasePlusCommissionEmployee::BasePlusCommissionEmployee( 
   const string &first, const string &last, const string &ssn, 
   double sales, double rate, double salary )
   : CommissionEmployee( first, last, ssn, sales, rate )  
{
   setBaseSalary( salary ); // validate and store base salary
} // end BasePlusCommissionEmployee constructor

salariedEmployee = new Employee;
salariedEmployee = new SalariedEmployee;

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <fstream>
 
// include definitions of classes in Employee hierarchy
#include "Date.h"
#include "Employee.h"
#include "SalariedEmployee.h" 
#include "HourlyEmployee.h"
#include "CommissionEmployee.h"  
#include "BasePlusCommissionEmployee.h" 
using namespace std;
 
int main()
{
   vector < Employee * > employees;
   string firstName;
   string lastName;
   string ssn;
   double salary;
   double hourlyWage;
   double hoursWorked;
   double sales;
   double rate;
   int    month;
   int    day;
   int    year;
   char   type;   
   fstream indata;                          // The file to be opened
 
   indata.open("employee.txt"); // Open the file to be read
   if(!indata) 
   { 
      cout << "Error: file could not be opened" << endl;
      exit(1);
   }
 
   do
   {
      indata>>type;
      switch(type)
      {
         case 'S':
            indata >> firstName;
            indata >> lastName;
            indata >> ssn;
            indata >> salary;
            indata >> month;
            indata.ignore(1);
            indata >> day;
            indata.ignore(1);
            indata >> year;
            break;
         case 'H':
            indata >> firstName;
            indata >> lastName;
            indata >> ssn;
            indata >> hourlyWage;
            indata >> hoursWorked;
            indata >> month;
            indata.ignore(1);
            indata >> day;
            indata.ignore(1);
            indata >> year;
            break;
         case 'C':
            indata >> firstName;
            indata >> lastName;
            indata >> ssn;
            indata >> sales;
            indata >> rate;
            indata >> month;
            indata.ignore(1);
            indata >> day;
            indata.ignore(1);
            indata >> year;
            break;
         case 'B':
            indata >> firstName;
            indata >> lastName;
            indata >> ssn;
            indata >> sales;
            indata >> rate;
            indata >> salary;
            indata >> month;
            indata.ignore(1);
            indata >> day;
            indata.ignore(1);
            indata >> year;
            break;
      }
   }while(!indata.eof());
 
   return 0;
}

Employee* p;
string line;
istringstream sstr;
char key;
bool goon = true;
...
while (goon && getline(indata,line)) {
    sstr.str(line);   // attach new line to sstr
    sstr.seekg(0); // read sstr from the beginning
    sstr >> key;
    switch (key) {
    case 'S':
        ... // get S... fields from sstr
        p = new salariedEmployee(...);
        v.push_back(p);
        break;
    ...
    default: // bad key
        goon = false; // then print error message
        break;
    }
}