Question

Introduction Your eighth assignment will consist of two programs, which will involve the use of simple classes. The source code for these problems should be submitted using the naming conventions we specified in class. Please note that your computer programs should comply with the commenting and formatting rules as described in class. For example, there should be a header for the whole program that gives the author's name, class name, date, and description. End braces should be commented, and there are alignment and indenting requirements as discussed. Please ask if you have any questions. Finally, since these programs involve the use of classes, let's follow the standard techniques of putting our classes in separate implementation and specification files. This technique is described in Section 13.5, starting on page 745 (9E). Create separate header and implementation files for each class. If you ZIP all of these down, they can be more easily submitted on eLearning Program 1: Course Grades (Polymorphism) Introduction For this assignment, let's implement Problem 11 on page 984 (9E) of the text. A scan of this problem will be provided below. The purpose of this problem is to utilize polymorphism (“many shapes”) in a C++ program. The program will demonstrate how a pointer to a base class object can be used to access different derived classes in a very natural way. This is the heart of polymorphism. The problem assumes that we are in an academic environment and are writing a program to deal with four different types of academic activities: a lab assignment, a pass/fail exam, an essay assignment, and a final exam. Each of these activities will derive from a GradedActivity class, either directly or indirectly. The GradedActivity class is given in the text. (More on that later.) This means that all of these activities will have a score that can be printed out and from which a grade, i.e, “A”, “B”, “C”, “D”, or “F” in the case of graded events, or “P” or “F” in the case of pass/fail events, can be determined. We will use polymorphism to distinguish between the graded and the pass/fail events.
I need this in C++. This is all one question.

Answer 1

Working code implemented in C++ and appropriate comments provided for better understanding:

Here I am attaching code for these files:

• main.cpp
• Essay.cpp
• Essay.h
• FinalExam.cpp
• FinalExam.h
• CourseGrades.cpp
• CourseGrades.h
• GradedActivity.cpp
• GradedActivity.h
• PassFailExam.cpp
• PassFailExam.h
• PassFailActivity.cpp
• PassFailActivity.h

Source code for main.cpp:

#include <iostream>
#include "GradedActivity.h"
#include "PassFailExam.h"
#include "FinalExam.h"
#include "CourseGrades.h"
using namespace std;

int main()
{
   // Create a GradedActivity object for the lab.
   GradedActivity lab(80);

   // Create a PassFailExam object. 50 questions,
   // 5 missed questions, minimum passing score is 70.
   PassFailExam pfexam(50, 5, 70);

   // Create an Essay object and set the different
   // types of points.
   Essay essay;
   essay.setGrammerPoints(25);
   essay.setSpellingPoints(15);
   essay.setLengthPoints(20);
   essay.setContentPoints(30);
   cout << essay.getScore () << endl;

   // Create a FinalExam object.
   FinalExam finalExam(50, 5);

   // Create a CourseGrades object.
   CourseGrades myGrades;

   // Store the grade items in the
   // CourseGrades object.
   myGrades.setLab(&lab);
   myGrades.setPassFailExam(&pfexam);
   myGrades.setEssay(&essay);
   myGrades.setFinalExam(&finalExam);

   // Print the grade information.
   myGrades.print();
   return 0;
}

Source code for Essay.cpp:

// Implementation file for the Essay class
#include <iostream>
#include "Essay.h"
using namespace std;

//******************************************
// setGrammerPoints member function *
//******************************************

void Essay::setGrammerPoints(double p)
{
   // Validate the points.
   if (p < 0 || p > 30)
   {
       // Invalid data
       cout << "Invalid number of grammar points.\n";
       // exit(EXIT_FAILURE);
       return;
   }

   // Assign the points.
   grammerPoints = p;
}

//******************************************
// setSpellingPoints member function *
//******************************************

void Essay::setSpellingPoints(double p)
{
   // Validate the points.
   if (p < 0 || p > 20)
   {
       // Invalid data
       cout << "Invalid number of spelling points.\n";
       // exit(EXIT_FAILURE);
       return;
   }

   // Assign the points.
   spellingPoints = p;
}

//******************************************
// setLengthPoints member function *
//******************************************

void Essay::setLengthPoints(double p)
{
   // Validate the points
   if (p < 0 || p > 20)
   {
       // Invalid data
       cout << "Invalid number of length points.\n";
       // exit(EXIT_FAILURE);
       return;
   }

   // Assign the points.
   lengthPoints = p;
}

//******************************************
// setContentPoints member function *
//******************************************

void Essay::setContentPoints(double p)
{
   // Validate the points.
   if (p < 0 || p > 30)
   {
       // Invalid data
       cout << "Invalid number of content points.\n";
       // exit(EXIT_FAILURE);
       return;
   }

   // Assign the points.
   contentPoints = p;
}

//*********************************************************
// getScore *
//*********************************************************

double Essay::getScore() const
{
   int totalPoints = grammerPoints + spellingPoints +
       lengthPoints + contentPoints;
   return totalPoints;
}

//*********************************************************
// getLetterGrade *
//*********************************************************

char Essay::getLetterGrade()
{
   // Add up all the points.
   score = getScore();

   // Return the letter grade as reported from
   // the base class function.
   return GradedActivity::getLetterGrade();
}

Source code for Essay.h:

// Specification file for the Essay class
#ifndef ESSAY_H
#define ESSAY_H
#include "GradedActivity.h"

class Essay: public GradedActivity {
private:
   double grammerPoints;   // To hold grammer points
   double spellingPoints;   // To hold spelling points
   double lengthPoints;   // To hold length points
   double contentPoints;   // To hold content points

public:
   // Default constructor
   Essay() {
       grammerPoints = 0.0;
       spellingPoints = 0.0;
       lengthPoints = 0.0;
       contentPoints = 0.0;
   }

   // Mutators
   void setGrammerPoints(double);
   void setSpellingPoints(double);
   void setLengthPoints(double);
   void setContentPoints(double);

   // Accessors
   double getGrammerPoints() const {
       return grammerPoints;
   }

   double getSpellingPoints() const {
       return spellingPoints;
   }

   double getLengthPoints() const {
       return lengthPoints;
   }

   double getContentPoints() const {
       return contentPoints;
   }

   virtual double getScore() const ;
   virtual char getLetterGrade() ;
};

#endif

Source code for FinalExam.cpp:

#include "FinalExam.h"

//********************************************************
// set function *
// The parameters are the number of questions and the *
// number of questions missed. *
//********************************************************

void FinalExam::set(int questions, int missed)
{
double numericScore; // To hold the numeric score

// Set the number of questions and number missed.
numQuestions = questions;
numMissed = missed;

// Calculate the points for each question.
pointsEach = 100.0 / numQuestions;

// Calculate the numeric score for this exm.
numericScore = 100.0 - (missed * pointsEach);

// Call the inherited setScore function to set
// the numeric score.
setScore(numericScore);

// Call the adjustScore function to adjust
// the score.
adjustScore();
}

//*****************************************************************
// Definition of Test::adjustScore. If score is within 0.5 points *
// of the next whole point, it rounds the score up and *
// recalculates the letter grade. *
//*****************************************************************

void FinalExam::adjustScore()
{
double fraction = score - static_cast<int>(score);

if (fraction >= 0.5)
{
// Adjust the score variable in the GradedActivity class.
score += (1.0 - fraction);
}
}

Source code for FinalExam.h:

#ifndef FINALEXAM_H
#define FINALEXAM_H
#include "GradedActivity.h"

class FinalExam : public GradedActivity
{
private:
int numQuestions; // Number of questions
double pointsEach; // Points for each question
int numMissed; // Number of questions missed
public:
// Default constructor
FinalExam()
{ numQuestions = 0;
pointsEach = 0.0;
numMissed = 0; }
  
// Constructor
FinalExam(int questions, int missed)
{ set(questions, missed); }

// Mutator functions
void set(int, int); // Defined in FinalExam.cpp
void adjustScore(); // Defined in FinalExam.cpp

// Accessor functions
double getNumQuestions() const
{ return numQuestions; }
  
double getPointsEach() const
{ return pointsEach; }

int getNumMissed() const
{ return numMissed; }
};

#endif

Source code for CourseGrades.cpp:

// Implementation file for the CourseGrades class
#include <iostream>
#include "CourseGrades.h"
using namespace std;

void CourseGrades::print() const
{
   // Display the lab score and grade.
   cout << "Lab score: "
       << grades[LAB]->getScore()
   << "\tGrade: "
       << grades[LAB]->getLetterGrade()
       << endl;

   // Display the pass/fail exm score
   // and grade.
   cout << "Pass/Fail Exm score: "
       << grades[PASS_FAIL_EXAM]->getScore()
   << "\tGrade: "
       << grades[PASS_FAIL_EXAM]->getLetterGrade()
       << endl;

   // Display the essay score and grade.
   cout << "Essay score: "
       << grades[ESSAY]->getScore()
   << "\tGrade: "
       << grades[ESSAY]->getLetterGrade()
       << endl;

   // Display the final exm score and grade.
   cout << "Final exm score: "
       << grades[FINAL_EXAM]->getScore()
   << "\tGrade: "
       << grades[FINAL_EXAM]->getLetterGrade()
       << endl;
}

Source code for CourseGrades.h:

#ifndef COURSE_GRADES_H
#define COURSE_GRADES_H
#include <iostream>
#include "GradedActivity.h"
#include "PassFailExam.h"
#include "FinalExam.h"
#include "Essay.h"
using namespace std;

// Constant for the number of grades
const int NUM_GRADES = 4;

// Constants for the subscripts
const int LAB = 0; // Lab score is at subscript 0
const int PASS_FAIL_EXAM = 1; // Pass/fail exm is at subscript 1
const int ESSAY = 2; // Essay is at subscript 2
const int FINAL_EXAM = 3; // Final exm is at subscript 3

class CourseGrades {
private:
   // Array of GradedActivity pointers to
   // reference the different types of grades
   GradedActivity *grades[NUM_GRADES];

public:
   // Default constructor
   CourseGrades() {
       for (int i = 0; i < NUM_GRADES; i++)
           grades[i] = nullptr;
   }

   // Mutators
   void setLab(GradedActivity *activity) {
       grades[LAB] = activity;
   }

   void setPassFailExam(PassFailExam *pfexam) {
       grades[PASS_FAIL_EXAM] = pfexam;
   }

   void setEssay(Essay *essay) {
       grades[ESSAY] = essay;
   }

   void setFinalExam(FinalExam *finalExam) {
       grades[FINAL_EXAM] = finalExam;
   }

   // print function
   void print() const;
};

#endif

Source code for GradedActivity.cpp:

#include "GradedActivity.h"

//******************************************************
// Member function GradedActivity::getLetterGrade *
//******************************************************

char GradedActivity::getLetterGrade()
{
char letterGrade; // To hold the letter grade

if (score > 89)
letterGrade = 'A';
else if (score > 79)
letterGrade = 'B';
else if (score > 69)
letterGrade = 'C';
else if (score > 59)
letterGrade = 'D';
else
letterGrade = 'F';

return letterGrade;
}

Source code for GradedActivity.h:

#ifndef GRADEDACTIVITY_H
#define GRADEDACTIVITY_H

// GradedActivity class declaration

class GradedActivity
{
protected:
double score; // To hold the numeric score
public:
// Default constructor
GradedActivity()
{ score = 0.0; }

// Constructor
GradedActivity(double s)
{ score = s; }

// Mutator function
void setScore(double s)
{ score = s; }

// Accessor functions
virtual double getScore()
{ return score; }

virtual char getLetterGrade() ;
};

#endif

Source code for PassFailExam.cpp:

#include "PassFailExam.h"

//********************************************************
// set function *
// The parameters are the number of questions and the *
// number of questions missed. *
//********************************************************
const int TOTAL_POINTS = 100.0;

void PassFailExam::set(int questions, int missed)
{
double numericScore; // To hold the numeric score

// Set the number of questions and number missed.
numQuestions = questions;
numMissed = missed;

// Calculate the points for each question.
pointsEach = TOTAL_POINTS / numQuestions;

// Calculate the numeric score for this exm.
numericScore = TOTAL_POINTS - (missed * pointsEach);

// Call the inherited setScore function to set
// the numeric score.
setScore(numericScore);
}

Source code for PassFailExam.h:

#ifndef PASSFAILEXAM_H
#define PASSFAILEXAM_H
#include "PassFailActivity.h"

class PassFailExam : public PassFailActivity
{
private:
int numQuestions; // Number of questions
double pointsEach; // Points for each question
int numMissed; // Number of questions missed
public:
// Default constructor
PassFailExam() : PassFailActivity()
{ numQuestions = 0;
pointsEach = 0.0;
numMissed = 0; }
  
// Constructor
PassFailExam(int questions, int missed, double mps) :
PassFailActivity(mps)
{ set(questions, missed); }

// Mutator function
void set(int, int); // Defined in PassFailExam.cpp

// Accessor functions
double getNumQuestions() const
{ return numQuestions; }
  
double getPointsEach() const
{ return pointsEach; }

int getNumMissed() const
{ return numMissed; }
};

#endif

Source code for PassFailActivity.cpp:

#include "PassFailActivity.h"

//******************************************************
// Member function PassFailActivity::getLetterGrade *
// This function returns 'P' if the score is passing, *
// otherwise it returns 'F'. *
//******************************************************

char PassFailActivity::getLetterGrade() const
{
char letterGrade;

if (score >= minPassingScore)
letterGrade = 'P';
else
letterGrade = 'F';
  
return letterGrade;
}

Source code for PassFailActivity.h:

#ifndef PASSFAILACTIVITY_H
#define PASSFAILACTIVITY_H
#include "GradedActivity.h"

class PassFailActivity : public GradedActivity
{
protected:
double minPassingScore; // Minimum passing score.
public:
// Default constructor
PassFailActivity() : GradedActivity()
{ minPassingScore = 0.0; }

// Constructor
PassFailActivity(double mps) : GradedActivity()
{ minPassingScore = mps; }

// Mutator
void setMinPassingScore(double mps)
{ minPassingScore = mps; }

// Accessors
double getMinPassingScore() const
{ return minPassingScore; }

char getLetterGrade() const;
};

#endif

Sample Output Screenshots:

> clang++-7 pthread -std=c++17 -o main courseGrades.cpp Essay.cpp FinalExam.cop GradedActivity.cpp PassFailActivity.cpp PassFailExam.cpp main.cpp > ./main 90 Lab score: 80 Grade: B Pass/Fail Exam score: 90 Grade: A Essay score: 0 Grade: A Final exam score: 90 Grade: A

Hope it helps, if you like the answer give it a thumbs up. Thank you.