需要关于我应该在哪里调用虚拟函数的帮助

Question

Sorry for the long ass code, let me explain briefly. I made a main class - Worker and two derived classes - hourlyworker, salaried worker. I made a virtual function that calculates a salary, no need to explain it, that's not my question.

I read an input, here's an example:

3 //first digit i read determines how many workers i'm going to have

dave sal

steve hou

chris sal //those 3 lines show names of workers and if they are paid with salary or hourly

10 20 10 //the working hours of those 3 workers, in that order.

---

Here's what i want to do: Depending on the type of payment each worker gets (hou or sal) i calculate his salary, calling the virtual function compute_pay. Example output:

dave 400

steve 200

chris 400. Here's my code:

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

class Worker {
public:
    void print();
protected:
    string name;
    string type;
};

class HourlyWorker : public  Worker {
public:
    HourlyWorker(string n) {
        name = n;
    }
    virtual double compute_pay(int hours) {
        double payment = 10;
        if (hours <= 40) {
            return hours * payment;
        }
        else {
            return (40 * payment) + ((hours - 40) * payment * 1.5);
        }
    }
    void print(int a) {
        cout << name << "  " << a << "\n";
    }
private:
    string name;
    string type;
}

class SalariedWorker : public Worker{
public:
    SalariedWorker(string n) {
        name = n;
    }
    virtual double compute_pay(int hours) {
        hours = 40;
        int payment = 10;
        return payment * hours;
    }
    void print(int a) {
        cout << name << "  " << a << "\n";
    }
private:
    string name;
    string type;
};

void print(vector<SalariedWorker*> sal, int a)
{
    for (int i = 0; i < sal.size(); i++)
        sal[i]->print(a);
}
void print(vector<HourlyWorker*> sal, int a)
{
    for (int i = 0; i < sal.size(); i++)
        sal[i]->print(a);
}

int main()
{
    vector<SalariedWorker*> sal;
    vector<HourlyWorker*> hour;
    int first; //first digit
    int hours; //hours of each worker
    string name; //name or worker
    string type; //sal or hou
    cout << "go" << "\n";
    cin >> first;
    for (int i = 0; i < first+1; i++) {
        if (i < first) {
            cin >> name >> type;
            if (type == "sal") {
                SalariedWorker* sall = new SalariedWorker(name);
                sal.push_back(sall); //If a worker is "sal" i write into the HourlyWorker vector
            }
            else if (type == "hou") {
                HourlyWorker* hourr = new HourlyWorker(name);
                hour.push_back(hourr);
            } //If a worker is "hou" i write into the HourlyWorker vector
            else {
                cout << "Wrong input" << "\n";
                return 1;
            }
        }
        else { //This triggers when we reach the last line. It triggers only once
            for (int z = 0; z < first; z++) {
                cin >> hours; //reading the last line
            }
        }
    }
}

Again, sorry for the long code, you don't have to go trough all of it, just the main class, and more importantly - the loop. Here's my question: where exactly should i call my compute_pay function so that it goes thorugh all the lines, assuming the int variable it requiers is the int hours variable i read at the last line? Also, where should i call my print function afterwards so i can see my output? I know it's a stupid or complicated question, but i honestly tried my best and I cannot figure it out :/.

Answer 1

In your example, you have different derivations of Worker with their own implementation of compute_pay . What having a virtual compute_pay does, is let you use the base class generically, without needing to have separate lists of each type.

To generically use virtual methods, you need an abstract base class. This means that the base class needs a virtual method declaration (as well as a virtual destructor):

class Worker {
public:
    virtual double compute_pay(int hours) = 0;
    virtual ~Worker() = default;
    /* all the other members go here */
};

The virtual destructor is an important part of this - it means that the correct destructor will be called no matter what type of pointer you're using. The = 0 means it's a pure virtual method, which is not implemented and will break if you try and declare a base Worker instead of a derived one.

Derived classes must override that base virtual method with the logic unique to that class:

class WorkerA {
public:
    double compute_pay(int hours) override { /* whatever */ return 42.0; }
};
class WorkerB {
public:
    double compute_pay(int hours) override { /* whatever */ return 25.0; }
};

Note that the derived classes don't use virtual , but instead add override to communicate that they're supposed to override a virtual base method.

Then, you can have one vector of workers:

std::vector<std::unique_ptr<Worker>> workers;

if (use_worker_a) {
    workers.emplace_back(new WorkerA());
} else {
    workers.emplace_back(new WorkerB());
}

Note: use a smart pointer such as unique_ptr instead of raw pointers whenever you can so you don't have to worry about explicitly deleting them.

The base virtual methods can then be used from that vector, without caring which pointer is which derived type:

double sum = 0;
for (auto& worker : workers) {
    sum += worker->compute_pay(40);
}

All the stuff about computing the number of hours, reading from a file, etc, I'll leave that to you. But that's how you use virtual methods for dynamic dispatch effectively.