Composite with smart pointers without dynamic_pointer_cast - c++

Question

I implemented the composite pattern using smart pointers, it works until a point.
The problem is that I just can use the methods that is implemented in the interface and I can not use the methods that is defined in the derived class without using dynamic_pointer_cast and I don't want it.
I want to know if it's possible to do it without using dynamic_pointer_cast.
I heard that I need to implement the visitor pattern, but I really don't know how to and if it fits in that problem.
#include <iostream>
#include <vector>
#include <memory>
class Fruit
{
public:
virtual void getOld() = 0;
};
class Orange : Fruit
{
public:
Orange() {}
void add(std::shared_ptr<Fruit> f)
{
v.push_back(f);
}
std::shared_ptr<Fruit> get(int k)
{
return v[k];
}
void getOld()
{
std::cout << "Orange - I'm old." << std::endl;
}
private:
std::vector<std::shared_ptr<Fruit>> v;
};
class Bitter : public Fruit
{
public:
Bitter() {}
void getOld()
{
std::cout << "Bitter - I'm old." << std::endl;
}
void getNew()
{
std::cout << "Bitter - I'm new." << std::endl;
}
};
int main(int argc, char ** argv)
{
auto orange = new Orange;
orange->add(std::make_shared<Bitter>());
auto bitter = orange->get(0);
bitter->getOld();
return 0;
}
It works as you can see here on the live preview, but when I try to use:
int main(int argc, char ** argv)
{
auto orange = new Orange;
orange->add(std::make_shared<Bitter>());
auto bitter = orange->get(0);
bitter->getOld();
bitter->getNew();
return 0;
}
I got errors:
error: 'class Fruit' has no member named 'getNew'
Thanks in advance.

Answer 1

The problem here I think is that it would work with polymorphism but the method 'getNew' doesn't exist in the mother class so you need to define it and make it virtual. It's the only way to do it without using a cast on the object.
With this line it should work.
virtual void getNew() = 0;

Answer 2

One possible solution is to have the following function in Orange.
template <typename T>
T* get(int k)
{
return dynamic_cast<T*>(v[k].get());
}
And then use:
auto bitter = orange->get<Bitter>(0);
bitter->getOld();
bitter->getNew();
This performs a dynamic_cast but is localized to Orange.

Answer 3

Following information can be found about "composite pattern" from the GOF book. Of course it has been explained based on graphics class.
The key to the Composite pattern is an abstract class that represents both primitives and their containers. For the graphics system, this class is Graphic. Graphic declares operations like Draw that are specific to graphical objects. It also declares operations that all composite objects share, such as operations for accessing and managing its children.
Based on the above explanation,we should ideally declare all possible interfaces of leaf and non-leaf(container) type of node while using composite pattern.I think that this is essential in order to let client treating individual objects and compositions of objects uniformly. So ideally you should declare your classes in the following way while using this particular pattern. Any logic which has been written based on the exact type of object in the client code violates the essence of this pattern.
//Abstract class which should have all the interface common to
// Composite and Leaf class. It may also provide the default
// implementation wherever appropriate.
class Fruit {
public:
virtual void getOld() = 0;
virtual void getNew() = 0;
virtual void add(std::shared_ptr<Fruit> f) { }
virtual std::shared_ptr<Fruit> get(int index ) {return nullptr; }
virtual ~Fruit() { }
};
//Composite Node
class Orange : Fruit {
public:
Orange() {}
void add(std::shared_ptr<Fruit> f) { v.push_back(f); }
std::shared_ptr<Fruit> get(int k) { return v[k]; }
void getOld() { std::cout << "Orange - I'm old." << std::endl; }
void getNew() { std::cout << "Orange - I'm new." << std::endl; }
private:
std::vector<std::shared_ptr<Fruit>> v;
};
//Leaf node
class Bitter : public Fruit {
public:
Bitter() {}
void getOld() { std::cout << "Bitter - I'm old." << std::endl; }
void getNew() { std::cout << "Bitter - I'm new." << std::endl; }
};