Abstract class accessing its child class functions - c++

Question

Is it possible to access the child's function members from a pointer of an abstract class as the parent?
This is the abstract class
class Item {
public:
virtual double getTotalPrice() = 0;
};
This is the child class
class Product : public Item {
protected:
string name;
public:
Product() {}
string getName() {}
double getTotalPrice() {}
};
Is it possible in the main driver to access this getName() function from an instance of the Item class, as I want to display the total price and the name of the product also?

Answer 1

You need your base class to have a virtual destructor if you should be able to delete objects through a base class pointer.
Make getName virtual too.
class Item {
public:
virtual ~Item() = default;
virtual const string& getName() /* const */ = 0;
virtual double getTotalPrice() /* const */ = 0;
};
Note that the Product class that you aren't allowed to change is slightly flawed.
It doesn't return values where it should.
The getter member functions are not const.
Suggest some changes if you can't do it yourself:
class Product : public Item {
private: // prefer private member variables
string name;
public:
Product() = default;
const string& getName() const override { return name; }
double getTotalPrice() const override {
// why is this implemented here when there's no price to return?
return {};
}
};

Answer 2

You cannot have an instance of the abstract Item class (because it's abstract) but you can have an Item pointer (or reference) to a derived (and non-abstract) Product class.
But because Item declares no getName() , you'd probably need to do a dynamic_cast to check if the pointee is really a Product, for ex.
Item* item = new Product();
...
// at same later time or some ooter function:
// use dynamic_cast to check if the pointee is the type you expect it to be
Product* p = dynamic_cast<Product>(item);
if (p) p->getName();
Though, not directly targeting your question I think there is also a design issue here. Something like Product conists of many items so it's rather 1:N composition relationship. For getting total price a concept (for ex. Billable ) would be mnore appropriate.
So I would probably advise something like following for the class hierarhy:
class Billable
{
public:
virtual double getTotalPrice() const = 0;
virtual ~Billable() {}
};
class Item : public Billable
{
string name;
public:
string getName() const { return name; }
double getTotalPrice() const override { ... impl .. }
// ... rest
}
class Product : public Billable
{
string name;
vector<Items> items;
public:
string getName() const { return name; }
double getTotalPrice() const override
{
return accumulate(begin(items), end(items), 0, [](auto i) { return i->getTotalPrice(); });
}
// ... rest ...
}

Answer 3

You can static cast if you're sure that the pointer points to an actual object of type Product or dynamic cast if you're not sure and want to check it first. This doesn't work if the pointer doesn't point to an object of the derived class.
class Item {
public:
virtual double getTotalPrice() = 0;
};
class Product : public Item {
protected:
string name;
public:
Product() {}
string getName() {return {};}
double getTotalPrice() {return {};}
};
int main() {
Product p;
Item *i = &p;
static_cast<Product *>(i)->getName();
auto *ptr = dynamic_cast<Product *>(i);
if (ptr) ptr->getName();
}
dynamic_cast requires runtime type information (RTTP) and comes with some extra costs.
Usually it's better to redesign the architecture instead of downcast.