Can late-binding in C++ be done without the need for heap-memory when using composition?

Question

late-binding or runtime-polymorphism needs 2 things: a base pointer and a virtual method.

class FrameWorkClassBase {
  public:
    virtual void method() = 0;
};

class FrameWorkClassDerived: public FrameWorkClassBase {
public:
    virtual void method() override { ... }
}

class ProductionConsumerClass { // uses composition
  public:
    void method() {
        this->m_sptr->method(); // dynamic dispatch
    }
  
  private:
    // ptr to base class, composition at work
    std::shared_ptr<FrameWorkClassBase> m_sptr =
                              std::make_shared<FrameWorkClassDerived>();
}

there seems to be a bias towards using heap memory for polymorphic object creation rather than stack allocated objects, especially when it comes to using "polymorphic object" as component objects. Is this a requirement: is it the nature of the C++ language as a whole that forces the use of heap memory for "polymorphic component objects" ? Are there any design patterns that overcome the need for using heap memory for "polymorphic component objects" ?

Note: I do not want to use base class l-value reference(FrameWorkClassBase&) as a data member in ProductionConsumerClass as i do not have life-time-guarantee/ownership of the referred object.

References exhibit late binding behavior without heap allocation — Taekahn
– Taekahn, Commented Jun 25, 2022 at 5:15
I have written entire C++ applications with plenty of late binding and zero heap usage. — user207421
– user207421, Commented Jun 25, 2022 at 5:50
Read also books on garbage collection (e.g. the GC handbook....) — Basile Starynkevitch
– Basile Starynkevitch, Commented Jun 25, 2022 at 7:22
Why do you need m_sptr to be a pointer to FrameWorkClassBase? And a pointer in the first place? Why not FrameWorkClassDerived m_frameworkObject;? — n. m. could be an AI
– n. m. could be an AI, Commented Jun 25, 2022 at 8:30
because you loose "type substitution", you have essentially tied yourself to an implementation value type rather than a generic base type that would allow you to swap an implementation(derived class) for another implementation. your code is becomes tightly coupled with an implementation. — Self
– Self, Commented Jun 25, 2022 at 8:48

Andrej Podzimek · Accepted Answer · 2022-06-25 07:08:55Z

2

There is no need to use heap allocation for late binding to work:

#include <iostream>

struct Base {
  virtual void print() { std::cout << "Base\n"; }
};

struct Derived : public Base {
  void print() override { std::cout << "Derived\n"; }
};

struct Composed {
  Base b;
  Derived d;
};

int main() {
  Base b;
  Derived d;
  Composed c;

  Base &bb{b}, &bd{d}, &cbb{c.b}, &cbd{c.d};

  bb.print();   // Base
  bd.print();   // Derived
  cbb.print();  // Base
  cbd.print();  // Derived
}

In the example above, no heap allocation takes place and all reference variables are of type Base&. Late binding works just fine.

answered Jun 25, 2022 at 7:08

Andrej Podzimek

2,87213 silver badges15 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Can late-binding in C++ be done without the need for heap-memory when using composition?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related