The C++ method is not getting overridden?

Question

class People {
    public:
        People(string name);
        void setName(string name);
        string getName();
        void setAge(int age);
        int getAge();
        virtual void do_work(int x);
        void setScore(double score);
        double getScore();
    protected:
        string name;
        int age;
        double score;
};

class Student: public People {
    public:
        Student(string name);
        virtual void do_work(int x);
};

class Instructor: public People {
    public:
        Instructor(string name);
        virtual void do_work(int x);
};

People::People(string name) {
    this->name = name;
    this->age = rand()%100;
}

void People::setName(string name) {
    this->name = name;
}

string People::getName() {
    return this->name;
}


void People::setAge(int age) {
    this->age = age;
}

int People::getAge() {
    return this->age;
}

void People::setScore(double score) {
    this->score = score;
}

double People::getScore() {
    return this->score;
}

void People::do_work(int x) {

}

Student::Student(string name):People(name){
    this->score = 4 * ( (double)rand() / (double)RAND_MAX );
}

void Student::do_work(int x) {
    srand(x);
    int hours = rand()%13;
    cout << getName() << " did " << hours << " hours of homework" << endl;
}

Instructor::Instructor(string name): People(name) {
   this->score = 5 * ( (double)rand() / (double)RAND_MAX );
}

void Instructor::do_work(int x) {
    srand(x);
    int hours = rand()%13;
    cout << "Instructor " << getName() << " graded papers for " << hours << " hours " << endl;
}

int main() {
    Student student1("Don");
    Instructor instructor1("Mike");
    People t(student1);
    t.do_work(2);
}

Why the do_work class is not getting overridden ? There is a people class and the Instructor and Student class are inheriting those classes. There is a virtual method in People class, which is implemented in Student and Instructor. But it is not getting overridden ? Thanks in advance !

It seems that you may be a victim of [object slicing](http://stackoverflow.com/questions/274626/what-is-object-slicing). — François Andrieux, Apr 27 '17 at 19:07
He meant that you should use the [override keyword](http://en.cppreference.com/w/cpp/language/override). — François Andrieux, Apr 27 '17 at 19:08
The behavior is correct. The only `do_work` that I see called, is called on `t` which is a `Person` object. your implementation for `Person::do_work` doesn't do anything... I think you wanted create `t` as a reference or pointer to a derived object. — WhiZTiM, Apr 27 '17 at 19:09
why do you think they are not overriden ? can you make the example a bit more minimal? — 463035818_is_not_an_ai, Apr 27 '17 at 19:10
@PriyeshKumar thats not the problem, it doesnt matter if a derived class declares the method as virtual, if it is virtual in the base class it is also virtual in the derived — 463035818_is_not_an_ai, Apr 27 '17 at 19:11
You should pass your parameters by *constant reference* if you are not modifying them. Otherwise, the compiler is making a copy of the the objects (which wastes memory and execution time). — Thomas Matthews, Apr 27 '17 at 19:14

Roberto · Accepted Answer · 2017-04-27T19:56:16.217

3

You need to have pointers or references to objects to make overriding work:

Student* student1 = new Student("Don");
Instructor* instructor1 = new Instructor("Mike");
People* t = student1;
t->do_work(2);

And please don't forget to delete your allocated memory:

delete student1;
delete instructor1;

That would be just enough to make it work, but for the sake of safety and avoiding memory leaks, you can just go:

#include <memory>

...

int main() {
    auto student1 = std::make_unique<Student>("Don");
    auto instructor1 = std::make_unique<Instructor>("Mike");
    People* t = student1.get();
    t->do_work(2);
}

Also please consider declaring a virtual destructor in your base class, that would be a must if you inherit from People and add a member field in the inherited class:

class People {
    public:
        ...
        virtual ~People() {}
    protected:
        ...
}

edited Apr 27 '17 at 19:56

answered Apr 27 '17 at 19:09

Roberto

2,115
24
32

4

Please do not encourage the use of `new` for basic cases like this, specially if you are omitting the use of `delete`. Use `std::make_unique` or something similar. – François Andrieux Apr 27 '17 at 19:11
3

`auto student1 = std::make_unique("Don");` – François Andrieux Apr 27 '17 at 19:14
Yeah sure Andrieux, I will take care of that. – Shubham Jain Apr 27 '17 at 19:14
1

"You need to have pointers to objects" is strictly speaking wrong. Often references are prefereable – 463035818_is_not_an_ai Apr 27 '17 at 19:15
Thanks @tobi303, reworded that – Roberto Apr 27 '17 at 19:19
@Roberto Usage of `delete` invokes undefined behavior since the base class `People` lacks a virtual destructor. Thus the current answer you gave is incomplete. – PaulMcKenzie Apr 27 '17 at 19:24
Yeah @PaulMcKenzie, but I'm deleting Student, not People – Roberto Apr 27 '17 at 19:29
You are also deleting `Instructor`. In any event, why not edit your answer once you were made aware of it? – PaulMcKenzie Apr 27 '17 at 19:32
Hey @PaulMcKenzie, I've updated my answer, correct me if I'm wrong, but I think we don't need a virtual destructor in this specific program because no inherited class has new member fields declared. – Roberto Apr 27 '17 at 19:52
I didn't know you can get raw ptr out of std::unique_ptr without calling get() method – Marek Chocholáček Apr 27 '17 at 19:54
Neither did I @MarekChocholáček – Roberto Apr 27 '17 at 19:57

The C++ method is not getting overridden?

1 Answers1