How to use virtual functions in derived objects without new?

Question

I would like to use virtual functions of objects of different classes (derived from the same base class) without a) constructing all the objects or b) using new. Please see the code example:

#include <iostream>
class A{
    public:
    virtual void p(void){std::cout << "Im A" << std::endl;};
};
class B : public A{
    public:
    virtual void p(void) override {std::cout << "Im B" << std::endl;};
};
class C : public A{
    public:
    virtual void p(void) override {std::cout << "Im C" << std::endl;};
};

int main(){
    bool cond = true;   // some condition
    A* o1;
    if (cond) o1 = new B(); else o1 = new C();
    o1->p();    // will call correct p(), i.e. either B::p or C::p but not A::p

    A o2 = B();
    o2.p();     // will call A::p

    A* o3;
    B tmp1; C tmp2; // construct both objects altough only one is needed
    if (cond) o3 = &tmp1; else o3 = &tmp2;
    o3->p();    // will call correct p(), i.e. either B::p or C::p but not A::p

    A* o4;
    if (cond) {B tmp; o4 = &tmp;} else {C tmp; o4 = &tmp;}  // uses address of local variable
    o4->p();    // will call correct p(), i.e. either B::p or C::p but not A::p

    return 0;
}

I want the behavior of o1 but without calling new. o2 doesnt work (calls function of base class and if base class is abstract it doesnt work at all). o3 works but constructs all the different objects although only one is needed. o4 kinda "works" but uses a reference to a local variable outside of its scope.

What would be the correct / best / modern C++ way to do it?

Answer 1

How to use virtual functions in derived objects without new

Like this:

B b;
C c;

A& a = cond ? b : c;
a.p();

without a) constructing all the objects

You can also do this:

if (cond) {
    B b;
    b.p();
} else {
    C c;
    c.p();
}

At this point it doesn't really matter that the function is virtual though since we are using static dispatch. Which is better than dynamic dispatch.

---

o4 kinda "works" but uses a reference to a local variable outside of its scope.

I.e. the behaviour of the program is undefind i.e. it doesn't work at all.

Answer 2

It will be better to use a helper function when you want to avoid using new but be able to use different derived types based on some condition.

void do_stuff(A& obj)
{
}

int main()
{
    bool cond = true;   // some condition

    if (cond)
    {
       B tmp;
       do_stuff(tmp);
    }
    else
    {
       C tmp;
       do_stuff(tmp);
    }

    return 0;
}

Answer 3

If using placement new is acceptable, you can use a union to hold the storage, then construct the proper member based on the condition:

union U {
    U() { }
    B b;
    C c;
};

int test(bool cond) {
    U u;
    A *a2;
    if (cond)
        a2 = new (&u.b) B;
    else
        a2 = new (&u.c) C;

    a2->p();
    return 0;
}

The constructor in the union is necessary since the default constructor will be implicitly deleted due to the presence of non-trivial default constructors for the members of the union.

You'll also have to manually destroy your objects when you're done.

Answer 4

For starters this code snippet

A* o4;
if (cond) {B tmp; o4 = &tmp;} else {C tmp; o4 = &tmp;}  // uses address of local variable
o4->p();    // will call correct p(), i.e. either B::p or C::p but not A::p

has undefined behavior because outside the if statement the pointer o4 is invalid due to the fact that the local object tmp is not alive outside the scopes of the if sub-statement.

As for this code snippet

A o2 = B();
o2.p();     // will call A::p

then you should use a reference to an object of the type B. For example

B b;
A &o2 = b;
o2.p();

As for the code snippet with the pointer o1 then in any case pointed objects must exists. Either they will be created dynamically as in your example or you can create the both locally and then depending on the condition set the pointer to one of them.

Answer 5

If you're worried about using new because of memory management, just use a std::shared_ptr instead:

int main(){
    bool cond = true;   // some condition
    std::shared_ptr<A> o1;

    if(cond) {
        o1 = std::make_shared<B>();
    } else {
        o1 = std::make_shared<C>();
    }

    o1->p();    

    return 0;
}

Prints:

Im B

Working example

---

Note: I was originally going to suggest an std::unique_ptr instead, however I didn't think they were copyable. But I was wrong. std::unique_ptrs will work too.

---

Note 2: you will need C++14 or later to use std::make_shared() or std::make_unique, but new will work in C++11. That violates your rule of not using new, but at least it does manage memory for you.

Answer 6

If you want to avoid new mainly to avoid the extra cleanup code and potential bugs from dangling pointers, double deletes, etc., just use std::unique_ptr:

std::unique_ptr<A> o1;
if (cond)
    o1 = std::make_unique<B>();
else
    o1 = std::make_unique<C>();
o1->p();

This will do essentially the same as the code using new, but behind the scenes, and also does the delete for you when o1 goes out of scope.

If you have a performance-critical code bottleneck and want to avoid the overhead of the heap memory allocation and deallocations used by new, things get trickier, but you could do it with something like:

using B_or_C_type = std::variant<B,C>;
auto o5 = cond ? B_or_C_type{B{}} : B_or_C_type{C{}};;
std::visit(std::mem_fn(&A::p), o5);

On typical systems, this code will avoid using any heap memory at all, instead using stack memory large enough to hold the larger of B or C. std::variant has the logic to act like a union but making sure only the correct type actually gets used. std::visit applies any functor to a variant, as long as the functor can be called with every type in the variant. Note if you define a variant variable with no initializer, it creates an object with the first type, though it can be reassigned to a different-typed object later. (If creating that default object isn't possible or should be avoided, you could use std::monostate as the first dummy type - but then using std::visit gets trickier.)