Upcast to abstract base class

Question

I try to have an abstract base class act like an interface and instantiate a derived class based on user input. I tried to implement it like this

class A 
{
    public:
        virtual void print() = 0;   
};

class B : A
{
    public:
        void print() override { cout << "foo"; }
};

class C : A
{
    public:
        void print() override { cout << "bar"; }
};

int main()
{   
    bool q = getUserInput();
    A a = q ? B() : C();
    a.print();  
}

But that does not work. I’m coming from c# and that would be valid c# so I’m looking for an equivalent way of implement it in c++. Could someone please give me a hint? Thanks!

Answer 1

There are two problems with the code in its current state.

1. By default in C++, a class that inherits from a class or struct will be private inheritance. E.g. when you say class B : A, it's the same as writing class B : private A -- which in C++ restricts the visibility of this relationship only to B and A.

   This is important because it means that you simply cannot upcast to an A from outside the context of these classes.

2. You are trying to upcast an object rather than a pointer or reference to an object. This fundamentally cannot work with abstract classes and will yield a compile-error even if the code was well formed.

   If the base class weren't abstract, then this would succeed -- but would perform object slicing which prevents the virtual dispatch that you would expect (e.g. it won't behave polymorphically, and any data from the derived class is not present in the base class).

To fix this, you need to change the inheritance to explicitly be public, and you should be using either pointers or references for the dynamic dispatch. For example:

class A 
{
public:
    virtual void print() = 0;   
};

class B : public A
//        ^~~~~~
{
public:
    void print() override { cout << "foo"; }
};

class C : public A
//        ^~~~~~
{
public:
    void print() override { cout << "bar"; }
};

---

To model something closer to the likes of C#, you will want to construct a new object. With the change above to public, it should be possible to use std::unique_ptr (for unique ownership) or std::shared_ptr (for shared ownership).

After this, you can simply do:

int main() {
    auto a = std::unique_ptr<A>{nullptr};
    
    auto q = getUserInput();
    
    if (q) { // Note: ternary doesn't work here
        a = std::make_unique<B>();
    } else {
        a = std::make_unique<C>();
    }
}

However, note that when owning pointers from an abstract base class, you will always want to have a virtual destructor -- otherwise you may incur a memory leak:

class A {
public:
    ...
    virtual ~A() = default;
};

---

You can also do something similar with references if you don't want to use heap memory -- at which point the semantics will change a little bit.

References in C++ can only refer to an object that already has a lifetime (e.g. has been constructed), and can't refer to a temporary. This means that you'd have to have instances of B and C to choose from, such as:

int main() {
    auto b = B{};
    auto c = C{};
    bool q = getUserInput();

    A& a = q ? b : c;
    a.print(); // A& references either 'b' or 'c'
}

Answer 2

You need to use pointers :

A* a = q ? static_cast<A*>(new B) : new C;
... 
delete a;

A ternary is also a special case here, as it takes the type of the first expression.

If C inherited from B here it would not be a problem.