如何在不直接继承的情况下访问基类容器中的派生对象

Question

I know I can cast pointer to base class in a container to pointer to derived class with the help of static_cast<derived_class*>(base_class_ptr) .

However what can I do if they are not directly related, but only have a common child. Look at the following example:

#include <iostream>
#include <string>
#include <vector>
#include <memory>

class Item
{
public:
    Item(std::string name): _name(name) { /* */ };

private:
    std::string _name;
};
class Readable
{
public:
    Readable(std::string content): _content(content) { /* */ };
    virtual auto content(void) const -> std::string
    {
        return this->_content;
    }

private:
    std::string _content;
};
class Book: public Item, public Readable
{
public:
    Book(std::string name, std::string content): Item(name), Readable(content) { /* */ };
};

class Person
{
public:
    auto read(const Readable& readable) const  noexcept
    {
        std::cout << readable.content() << '\n';
    }
};

int main(void)
{
    auto i0 = std::make_unique<Item>("Pot");
    auto i1 = std::make_unique<Item>("Shoe");
    auto b0 = std::make_unique<Book>("Death of a Salesman", "Blablablabla...");

    std::vector<std::unique_ptr<Item>> container;
    container.emplace_back(std::move(i0)); 
    container.emplace_back(std::move(i1)); 
    container.emplace_back(std::move(b0)); 

    Person jonnie{};
    jonnie.read(static_cast<Readable*>(container[2].get())) // Error!
}

I want to read a Book from the Item s container, and that should be ok, because it is inherits from Readable , but I can't, because the compiler complains:

static_cast from 'pointer' (aka 'Item *') to 'Readable *', which are not related by inheritance, is not allowed   

What can I do in such a case? Is there a clean solution?

Answer 1

You are looking to cast objects around that are required to be polymorphic ; they require a virtual method. The easiest (and I think in this case the best) is to make the destructor virtual for all the base classes, eg;

class Item
{
public:
    virtual ~Item() { /* */ };
    // .. the rest of the class
};

This allows dynamic_cast<> to work at runtime (it works with polymorphic types), it will check for and cast the object appropriately. One caveat here (given the sample use in the OP) is that you will almost certainly have to check the return value against nullptr to check the cast succeeded.

Answer 2

If you want to read a Book , you should cast it to a Book (which is derived from Item ).

The Book can then be used as a Readable , beacuse it is . But the Item is not.