void* is not a pointer object / casting implementation - c++

Question

From my code below I'm trying to create a Course grading system. So, it will store the type of assignment, its weightage and the achieved grade. I'm trying to get it to print the raw score (which is the grade entered for example: "B-" or 85.50; depending on whether it is an exam or quiz).
I have read about "casting" which should resolve the issue of using void* as a pointer but I am still unclear as to how I can implement it. I tried static_cast<struct Grading*>(c.gs[0])(commented out in code) but it still returned the address of the value, instead of the value itself. Any help will be appreciated. Thanks in advance!
#include <iostream>
#include <vector>
using namespace std;
struct Grading{
string name;
int percentage;
virtual ~Grading(){}
virtual void* get_raw_score(){return 0;}
void* get_adj_score(){return 0;}
};
struct Quiz:public Grading{
string letter_grade;
Quiz(const string title, const int weight, const string grade){
name=title;
percentage=weight;
letter_grade=grade;
}
virtual void* get_raw_score(){return &letter_grade;}
};
struct Exam:public Grading{
double *score = new double;
Exam(const string title, const int weight, const double grade){
name=title;
percentage=weight;
*score=grade;
}
virtual void* get_raw_score(){return &score;}
};
struct Project:public Grading{
string letter_grade;
Project(const string title, const int weight, const string grade){
name=title;
percentage=weight;
letter_grade=grade;
}
virtual void* get_raw_score(){return &letter_grade;}
};
struct CourseWork{
vector<Grading*> gs;
void push_back(Grading* g){
gs.push_back(g);
}
void sort_name(){}
void sort_score(){}
};
ostream& operator<<(ostream& o,const CourseWork c){ //output the raw score here.
//static_cast<struct Grading*>(c.gs[0]);
o<<c.gs[0]->name<<endl<<c.gs[0]->percentage<<c.gs[0]->get_raw_score()<<endl;
return o;
}
int main() {
CourseWork c;
c.push_back(new Quiz("Quiz", 5, "B-"));
c.push_back(new Quiz("Quiz", 5, "C+"));
c.push_back(new Quiz("Quiz", 5, "A"));
c.push_back(new Exam("Midterm", 10, 50));
c.push_back(new Exam("Final", 30, 85.5));
c.push_back(new Project("Project", 5, "A-"));
c.push_back(new Project("Project", 15, "B-"));
c.push_back(new Project("Project", 15, "B-"));
c.push_back(new Project("Demo", 10, "C"));
cout << "** Showing populated data..." << endl;
cout << c << endl << endl;;
c.sort_name();
cout << "** Showing sorted by name..." << endl;
cout << c << endl << endl;
c.sort_score();
cout << "** Showing sorted by score..." << endl;
cout << c << endl;
return 0;
}

Answer 1

Instead of writing a function that returns a void* and trying to figure out what it actually returns you can make the function return a string in all cases but when it is a number just convert the number to a string. You could use:
struct Grading{
string name;
int percentage;
virtual ~Grading(){}
virtual std::string get_raw_score() = 0; //make pure virtual since we only use Grading as a base class
void* get_adj_score(){return 0;}
};
struct Quiz:public Grading{
string letter_grade;
Quiz(const string title, const int weight, const string grade){
name=title;
percentage=weight;
letter_grade=grade;
}
virtual std::string get_raw_score(){return letter_grade;}
};
struct Exam:public Grading{
double score; // this does not need to be a pointer
Exam(const string title, const int weight, const double grade){
name=title;
percentage=weight;
score=grade; // no more dereference
}
virtual std::string get_raw_score(){return std::stod(score);} // now the score is represented as a string
};
struct Project:public Grading{
string letter_grade;
Project(const string title, const int weight, const string grade){
name=title;
percentage=weight;
letter_grade=grade;
}
virtual std::string get_raw_score(){return letter_grade;}
};
struct CourseWork{
vector<Grading*> gs;
void push_back(Grading* g){
gs.push_back(g);
}
void sort_name(){}
void sort_score(){}
};
ostream& operator<<(ostream& o,const CourseWork c){ //output the raw score here.
//static_cast<struct Grading*>(c.gs[0]);
o<<c.gs[0]->name<<endl<<c.gs[0]->percentage<<c.gs[0]->get_raw_score()<<endl;
return o;
}

Answer 2

You can make your base class abstract and use a template parameter instead of using a void* pointer:
struct IGrading {
virtual const std::string get_raw_score() const = 0;
};
template<typename T>
class Grading : public IGrading {
public:
virtual ~Grading() {}
};
std::ostream& operator<<(std::ostream& os, const IGrading& g) {
os << g.get_raw_score();
return os;
}
and derive your implementations as needed to implement the interface contract
class Quiz : public Grading<std::string> {
public:
Quiz(std::string title, int weight, std::string rawScore)
: title_(title)
, weight_(weight).
, rawScore_(rawScore) {}
virtual const std::string& get_raw_score() const {
return rawScore_;
}
private:
std::string title_;
int weight_;
std::string rawScore_;
};
... and analogous implementations:
class Exam : public Grading<double> {
public:
Exam(std::string title, int weight, double rawScore)
: title_(title)
, weight_(weight)
, rawScore_(rawScore) {}
virtual const std::string& get_raw_score() const {
return std::to_string(rawScore_);
}
private:
double rawScore_;
};
Or have a generic base class implementation for numeric template parameters:
template<typename T>
class NumericGrading : public Grading<T> {
protected:
NumericGrading(T rawScore) : rawScore_(rawScore) {}
public:
virtual const std::string& get_raw_score() const {
return std::to_string(rawScore_);
}
protected:
T rawScore_;
};
and let Exam derive that:
class Exam : public NumericGrading<double> {
public:
Exam(std::string title, int weight, double rawScore)
: NumericGrading<double>(rawScore)
, title_(title)
, weight_(weight) {}
};
This will keep your code type safe and avoid any weird and error prone casting operations.
The CourseWork container can use the abstract interface:
struct CourseWork{
vector<IGrading*> gs;
void push_back(IGrading* g){
gs.push_back(g);
}
void sort_name(){}
void sort_score(){}
};