Base class's functions aren't being overridden in C++ - c++

Question

[The code below is runnable so feel free to run it to see what I am talking about]
I am following along with a tutorial from a book that is Java-based. The code below is essentially a bunch of classes that can be used to accurately get the description and price of a beverage ordered (no matter how many additional condiments are added on to the base Beverage). The issue is the getDescription() and cost() functions in the Beverage class are not being overridden by the CondimentDecorator class, or any of the various condiment classes (Mocha, Milk, Whip, etc.).
When I run it, "Unknown Beverage" prints out as the description.
How can I figure out where the inheritance bug is at?
#include <iostream>
#include <string>
using namespace std;
class Beverage {
string description = "Unknown Description";
public:
string getDescription(){
return description;
}
int cost(); // just declare it - don't do anything
};
class HouseBlend : public Beverage {
string description = "House Blend";
string getDescription(){
return description;
}
int count(){
return .89;
}
};
class DarkRoast : public Beverage {
string description = "Dark Roast";
string getDescription(){
return description;
}
int count(){
return .99;
}
};
class Decaf : public Beverage {
string description = "Decaf";
string getDescription(){
return description;
}
int count(){
return 1.05;
}
};
class Espresso : public Beverage {
string description = "Espresso";
string getDescription(){
return description;
}
int count(){
return 1.99;
}
};
class CondimentDecorator : public Beverage {
string getDescription();
};
class Soy : public CondimentDecorator {
Beverage *beverage;
public:
Soy(Beverage *beverage){
this->beverage = beverage;
}
string getDescription(){
return beverage->getDescription() + " , Soy ";
}
int cost(){
return beverage->cost() + .15;
}
};
class Milk : public CondimentDecorator{
Beverage *beverage;
public:
Milk(Beverage *beverage){
this->beverage = beverage;
}
string getDescription(){
return beverage->getDescription() + " , Milk ";
}
int cost(){
return beverage->cost() + .10;
}
};
class Mocha : public CondimentDecorator{
Beverage *beverage;
public:
Mocha(Beverage *beverage){
this->beverage = beverage;
}
string getDescription(){
return beverage->getDescription() + " , Mocha ";
}
int cost(){
return beverage->cost() + .20;
}
};
class Whip : public CondimentDecorator{
Beverage *beverage;
public:
Whip(Beverage *beverage){
this->beverage = beverage;
}
string getDescription(){
return beverage->getDescription() + " , Whip ";
}
int count(){
return beverage->cost() + .10;
}
};
//class StarbuzzCoffeeRun {
int main(){
Beverage *beverage = new Espresso;
cout << beverage->getDescription(); // << "$" << beverage->cost() << endl ;
Beverage *beverage2 = new DarkRoast;
beverage2 = new Mocha(beverage2);
cout << beverage2->getDescription();
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);
cout << beverage2->getDescription(); // << "$" << beverage2->cost() << endl ;
Beverage *beverage3 = new HouseBlend;
beverage3 = new Soy(beverage3);
beverage3 = new Mocha(beverage3);
beverage3 = new Whip(beverage3);
cout << beverage3->getDescription(); // << "$" << beverage3->cost() << endl ;
return 0;
}

Answer 1

Couple of things wrong here.
The biggest one (causing the problem you're seeing) is that by doing something like this:
class HouseBlend : public Beverage {
string description = "House Blend";
// ...
};
What you're actually doing here is declaring a new member description, not setting Beverage's description.
To actually set Beverage's variable description, you will need to set it in a constructor or something:
class HouseBlend : public Beverage {
public:
HouseBlend () {
description = "House Blend";
}
};
Of course, if you want to access a parent's variable inside the child, it will have to be public or protected:
class Beverage {
protected:
string description = "Unknown Description";
public:
string getDescription(){
return description;
}
int cost(); // just declare it - don't do anything
};
Of course, you could set it in a setter too, but you you get the idea.
The other thing wrong here is with your count() function:
int cost(); // just declare it - don't do anything
There are 2 things wrong with this:
It needs to be virtual. If it's not, it will just end calling the base function and not the overloaded one when you create a pointer to it.
virtual int cost(); // so the compiler knows it will get overloaded at runtime
It needs to have an implementation. Even if the function does nothing, it still needs to have an "implementation" or else the compiler will complain.
virtual int cost() {return 0;} // Return some value that we know shouldn't exist
If you have a virtual function, you have the option of a pure virtual function which allows you to have no implementation, but override it in the child class:
virtual int cost() = 0; // This function has no implementation, but derived classes will give it one.
Note that this makes Beverage into a abstract class, and that comes with some restrictions for how you can use it. However, you seem to use it like an abstract class, so I'm guessing that this is what you were expecting anyway.
Edit
So, after I hit "post," I realized that technically I didn't answer your question which seems to be why getDescription() doesn't get overridden. The answer is similar to cost(), in that it needs to be virtual as well:
class Beverage {
string description = "Unknown Description";
public:
virtual string getDescription(){
return description;
}
virtual int cost() = 0;
};
This will technically allow getDescription() to get overridden when you use it in a pointer context. However, this isn't the best solution. It is probably better in the long run to make description protected instead.
Otherwise you're making a bunch of extra description variables you don't need. That will ultimately waste memory. And it makes your design clunkier. So just use protected instead.