Should this have a destructor, and should I free dynamically allocated memory? Any suggestions?

[newB c PlusPlusGuy]

// Assign dynamically allocated derived class objects to base class pointers
// and use polymorphism to display output based on the type of the object.

#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;

// base class Employee
class Employee
{
private:
	// employee ID
	int empID;

public:
	// Constructor that will take an int as an argument and
	// assign it to empID
	Employee(int);

	// Destructor
	~Employee();

	// Return the empID
	int getEmpID() const;

	// pure virtual function
	virtual void printPay() = 0;

};
// Constructor that will take an int as an argument and
// assign it to empID
Employee::Employee(int empID)
{
	this->empID = empID;
}

// Destructor
Employee::~Employee()
{
}

// Return the empID
int Employee::getEmpID() const
{
	return empID;
}

// derived class HourlyEmployee
class HourlyEmployee : public Employee
{
public:
	// Constructor that will take in three arguments: The employee
	// id, the number of hours worked, and the pay rate.
	HourlyEmployee(int, double, double);

	// Destructor
	~HourlyEmployee();

	// Return the hours
	double getHours() const;

	// Return the payRate
	double getPayRate() const;

	// Print the hourly employee's id and the weekly pay with 2 digits
	// after the decimal place.
	void printPay();

private:
	// number of hours worked
	double hours;
	// pay rate
	double payRate;
};

// Constructor that will take in three arguments: The employee
// id, the number of hours worked, and the pay rate.
HourlyEmployee::HourlyEmployee(int empID, double hours, double payRate) 
	: Employee(empID)
{
	this->hours = hours;
	this->payRate = payRate;
}

// Destructor
HourlyEmployee::~HourlyEmployee()
{
}


// Return the hours
double HourlyEmployee::getHours() const
{
	return hours;
}

// Return the payRate
double HourlyEmployee::getPayRate() const
{
	return payRate;
}

// Print the hourly employee's id and the weekly pay with 2 digits
// after the decimal place.
void HourlyEmployee::printPay()
{
	// calculate weekly pay
	double weeklyPay = hours * payRate;

	// set floating point output to 2 digits after the decimal place
	cout << fixed << showpoint << setprecision(2);

	cout << "The pay for the hourly employee with ID number ";
	cout << getEmpID() << " is  $" << weeklyPay << endl;
}

// derived class SalariedEmployee
class SalariedEmployee : public Employee
{
public:
	// Constructor that will take in two arguments: The employee id and
	// the salary.
	SalariedEmployee(int, double);

	// Destructor
	~SalariedEmployee();

	// Return the salary
	double getSalary() const;

	// Print the salaried employee's id number and the weekly pay with
	// 2 digits after the decimal place.
	void printPay();

private:
	// salary
	double salary;
};

// Constructor that will take in two arguments: The employee id and
// the salary.
SalariedEmployee::SalariedEmployee(int empID, double salary) : Employee(empID)
{
	this->salary = salary;
}

// Destructor
SalariedEmployee::~SalariedEmployee()
{
}

// Return the salary
double SalariedEmployee::getSalary() const
{
	return salary;
}

// Print the salaried employee's id number and the weekly pay with
// 2 digits after the decimal place.
void SalariedEmployee::printPay()
{
	// calculate the weekly pay
	double weeklyPay = salary / 52;

	// set floating point output to 2 digits after the decimal place
	cout << fixed << showpoint << setprecision(2);

	cout << "The pay for the salaried employee with ID number ";
	cout << getEmpID() << " is  $" << weeklyPay << endl;
}

// function prototypes
void getInput(vector <Employee *> & Ve);
void printList(const vector <Employee *> & Ve);

int main()
{
	
	vector <Employee *> VEmp;
	
	getInput(VEmp);
	
	printList(VEmp);
	
	system("pause");
	return 0;
}

// Contain a loop that will give the user an option to enter information
// about an hourly employee or a salaried employee. Depending on the user's
// choice, collect the appropriate input information from the user and use
// this information to dynamically construct a derived class object. Assign
// the address of the dynamically created derived class object to an element
// of the Ve vector.
void getInput(vector <Employee *> & Ve)
{
	// employee id
	int empID;
	// number of hours worked
	double hours;
	// pay rate
	double payRate;
	// salary
	double salary;
	// user's choice
	int option;

	// do until option 3 is entered
	do
	{
		// display options
		cout << "Enter 1 for Hourly Employee" << endl;
		cout << "Enter 2 for Salaried Employee" << endl;
		cout << "Enter 3 to stop:  ";

		// read option
		cin >> option;
		cout << endl;

		// process option
		switch (option)
		{
		case 1:
			// read employee ID
			cout << "Enter the ID: ";
			cin >> empID;
			// read number of hours worked
			cout << "Enter the number of hours worked: ";
			cin >> hours;
			// read pay rate
			cout << "Enter the pay rate: ";
			cin >> payRate;
			// dynamically construct a HourlyEmployee object and 
			// push back into vector
			Ve.push_back(new HourlyEmployee(empID, hours, payRate));
			break;
		case 2:
			// read employee ID
			cout << "Enter the ID: ";
			cin >> empID;
			// read salary
			cout << "Enter the salary: ";
			cin >> salary;
			// dynamically construct a SalariedEmployee object and 
			// push back into vector
			Ve.push_back(new SalariedEmployee(empID, salary));
			break;
		case 3:
			break;
		default:
			cout << "Error: invalid option" << endl;
		}

		cout << endl;
	} while (option != 3);
}

// Loop through the elements of the Ve vector and call the printPay() function
// of each of the dynamically allocated objects.
void printList(const vector <Employee *> & Ve)
{
	for (size_t i = 0; i < Ve.size(); i++)
	{
		Ve[i]->printPay();
	}
}

[booradley60]

Your program only dynamically allocates memory in the getInput function. getInput is making an implicit contract with main that says "You give me a vector and I'll fill it up, but you're responsible for that memory when I'm finished." Since these allocations don't happen in any of your class methods, then destructors will do you no good. At the end of main() you should iterate over the vector and free the memory at each element.

void cleanUpList(vector <Employee *> & Ve)
{
    for (size_t i = 0; i < Ve.size(); i++)
    {
        delete Ve[i];
    }

    Ve.clear();
}

[newB c PlusPlusGuy]

booradley60 - thank you. I am "not allowed to touch main" per the instructor.

[Zaita]

At this point no you do not need to worry. The memory will be cleaned up at the end of the main function. Your code does not have any tasks that rely on flushing buffers/text writes etc that rely on a destructor so for now you can ignore it.

Your instructor has most likely done this on purpose so you can focus on the core problem while developing fundamental knowledge.