More C++ Idioms/Fake Vtable

Intent

To try to avoid dynamic allocation and avoid inheritance and intrusion in polymorphism.

Motivation

Someone might want non-intrusive polymorphism in C++.

Solution and Sample Code

Below is an implementation of a class that can refer to any object whose type satisfies the shape concept, as well as code that uses it:

#include <format>
#include <iostream>
#include <utility>

using point = std::pair<double, double>;

// 4 below types were written without knowledge of the interface
struct circle{
    public:
        explicit constexpr circle(
            point center,
            double radius
        ) noexcept
            : center_(center)
            , radius_(std::max(radius, 0.)){}
        
        constexpr point center() const noexcept{return center_;}

        constexpr double radius() const noexcept{return radius_;}

        friend bool operator==(circle const&, circle const&) = default;
    private:
        point center_{};
        double radius_{};
};

struct ellipse{
    public:
        explicit constexpr ellipse(
            point center,
            double a,
            double b
        ) noexcept
            : center_(center)
            , a_(std::max(a, 0.))
            , b_(std::max(b, 0.)){}
        constexpr ellipse(circle circle) noexcept : ellipse(
            circle.center(),
            circle.radius(),
            circle.radius()
        ){}
        
        constexpr point center() const noexcept{return center_;}

        constexpr double a() const noexcept{return a_;}

        constexpr double b() const noexcept{return b_;}

        friend bool operator==(ellipse const&, ellipse const&) = default;
    private:
        point center_{};
        double a_{};
        double b_{};
};

struct square{
    public:
        explicit constexpr square(
            point center,
            double side_length
        ) noexcept
            : center_(center)
            , side_length_(std::max(side_length, 0.)){}
        
        constexpr point center() const noexcept{return center_;}

        constexpr double side_length() const noexcept{return side_length_;}

        friend bool operator==(square const&, square const&) = default;
    private:
        point center_{};
        double side_length_{};
};

struct rectangle{
    public:
        explicit constexpr rectangle(
            point center,
            double width,
            double height
        ) noexcept
            : center_(center)
            , width_(std::max(width, 0.))
            , height_(std::max(height, 0.)){}
        constexpr rectangle(square square) noexcept : rectangle(
            square.center(),
            square.side_length(),
            square.side_length()
        ){}

        constexpr point center() const noexcept{return center_;}

        constexpr double width() const noexcept{return width_;}

        constexpr double height() const noexcept{return height_;}

        friend bool operator==(rectangle const&, rectangle const&) = default;
    private:
        point center_{};
        double width_{};
        double height_{};
};

template <class T>
concept shape = requires (T const& shape, std::ostream& os){
    {center(shape)} -> std::convertible_to<point>;
    {area(shape)} -> std::convertible_to<double>;
    {bounding_box(shape)} -> std::convertible_to<rectangle>;
    {draw(shape, os)} -> std::convertible_to<void>;
};

class shape_ref{
    public:
        // Take advantage of the fact we still know the actual type by using
        // this opportunity to pass an appropriate vtable
        template <shape T>
        explicit constexpr shape_ref(T const& shape) noexcept
            : shape_ptr_(std::addressof(shape)) // T can overload operator&
            , vtable_(&shape_vtable_for<T>){}
        
        // constexpr cast from void* since C++26
        // Provide a consistent interface with wrapped types
        friend constexpr point center(shape_ref ref){
            return ref.vtable_->do_center(ref.shape_ptr_);
        }

        friend constexpr double area(shape_ref ref){
            return ref.vtable_->do_area(ref.shape_ptr_);
        }

        friend constexpr rectangle bounding_box(shape_ref ref){
            return ref.vtable_->do_bounding_box(ref.shape_ptr_);
        }

        friend constexpr void draw(shape_ref ref, std::ostream& os){
            return ref.vtable_->do_draw(ref.shape_ptr_, os);
        }
    private:
        template <class R, class... Args>
        using function = R(Args...);

        // This is the fake vtable
        struct shape_vtable{
            function<point, void const*>* do_center{};
            function<double, void const*>* do_area{};
            function<rectangle, void const*>* do_bounding_box{};
            function<void, void const*, std::ostream&>* do_draw{};
        };

        // Requires knowledge of actual type pointed to by void const*
        template <shape T>
        static constexpr shape_vtable shape_vtable_for{
            .do_center = +[](void const* shape_ptr) -> point {
                return center(*static_cast<T const*>(shape_ptr));
            },
            .do_area = +[](void const* shape_ptr) -> double {
                return area(*static_cast<T const*>(shape_ptr));
            },
            .do_bounding_box = +[](void const* shape_ptr) -> rectangle {
                return bounding_box(*static_cast<T const*>(shape_ptr));
            },
            .do_draw = +[](void const* shape_ptr, std::ostream& os) -> void {
                return draw(*static_cast<T const*>(shape_ptr), os);
            }
        };

        void const* shape_ptr_{};
        shape_vtable const* vtable_{};
};

// Circles convert to ellipses and squares convert to rectangles, so not all
// function overloads need to be written
constexpr point center(ellipse e) noexcept{
    return e.center();
}
constexpr point center(rectangle r) noexcept{
    return r.center();
}

constexpr double area(ellipse e) noexcept{
    return std::numbers::pi * e.a() * e.b();
}
constexpr double area(rectangle r) noexcept{
    return r.width() * r.height();
}

constexpr square bounding_box(circle c) noexcept{
    return square(c.center(), c.radius());
}
constexpr rectangle bounding_box(ellipse e) noexcept{
    return rectangle(e.center(), e.a(), e.b());
}
constexpr square bounding_box(square s) noexcept{
    return s;
}
constexpr rectangle bounding_box(rectangle r) noexcept{
    return r;
}

void draw(circle c, std::ostream& os){
    auto const [x, y] = c.center();
    os << std::format(
        "circle({{{}, {}}}, {})",
        x, y, c.radius()
    );
}
void draw(ellipse e, std::ostream& os){
    auto const [x, y] = e.center();
    os << std::format(
        "ellipse({{{}, {}}}, {}, {})",
        x, y, e.a(), e.b()
    );
}
void draw(square s, std::ostream& os){
    auto const [x, y] = s.center();
    os << std::format(
        "square({{{}, {}}}, {})",
        x, y, s.side_length()
    );
}
void draw(rectangle r, std::ostream& os){
    auto const [x, y] = r.center();
    os << std::format(
        "rectangle({{{}, {}}}, {}, {})",
        x, y, r.width(), r.height()
    );
}

int main(){
    circle const c({1, 2}, 3);
    ellipse const e({4, 5}, 6, 7);
    square const s({8, 9}, 10);
    rectangle const r({11, 12}, 13, 14);
    // Be careful not to let the shape_ref outlive the referent. However, this
    // restriction is not so bad because Base* pointers are also restricted in
    // the exact same way.
    shape_ref c_ref(c);
    shape_ref e_ref(e);
    shape_ref s_ref(s);
    shape_ref r_ref(r);
    auto const show_values = [](shape auto const& s, std::string_view name){
        std::cout << "----------\n";
        auto const [cx, cy] = center(s);
        rectangle const bb = bounding_box(s);
        auto const [bbcx, bbcy] = bb.center();
        std::cout << std::format(
            "center({}) = {{{}, {}}}\n",
            name, cx, cy
        );
        std::cout << std::format(
            "area({}) = {}\n",
            name, area(s)
        );
        std::cout << std::format(
            "bounding_box({}) = rectangle({{{}, {}}}, {}, {})\n",
            name, bbcx, bbcy, bb.width(), bb.height()
        );
        std::cout << std::format(
            "Drawn by draw({}): ",
            name
        );
        draw(s, std::cout);
        std::cout << "\n----------\n";
    };
    std::cout << "Static function calls:\n";
    show_values(c, "c");
    show_values(e, "e");
    show_values(s, "s");
    show_values(r, "r");
    std::cout << "Dynamic function calls:\n";
    show_values(c_ref, "c_ref");
    show_values(e_ref, "e_ref");
    show_values(s_ref, "s_ref");
    show_values(r_ref, "r_ref");
    // Because the references are of the same type, same-type operations are now
    // possible. (Note that same-type operations are also possible with Base*).
    std::swap(c_ref, s_ref);
    std::swap(e_ref, r_ref);
    std::swap(c_ref, e_ref);
    std::swap(s_ref, r_ref);
}

Output:

Static function calls:
----------
center(c) = {1, 2}
area(c) = 28.274333882308138
bounding_box(c) = rectangle({1, 2}, 3, 3)
Drawn by draw(c): circle({1, 2}, 3)
----------
----------
center(e) = {4, 5}
area(e) = 131.94689145077132
bounding_box(e) = rectangle({4, 5}, 6, 7)
Drawn by draw(e): ellipse({4, 5}, 6, 7)
----------
----------
center(s) = {8, 9}
area(s) = 100
bounding_box(s) = rectangle({8, 9}, 10, 10)
Drawn by draw(s): square({8, 9}, 10)
----------
----------
center(r) = {11, 12}
area(r) = 182
bounding_box(r) = rectangle({11, 12}, 13, 14)
Drawn by draw(r): rectangle({11, 12}, 13, 14)
----------
Dynamic function calls:
----------
center(c_ref) = {1, 2}
area(c_ref) = 28.274333882308138
bounding_box(c_ref) = rectangle({1, 2}, 3, 3)
Drawn by draw(c_ref): circle({1, 2}, 3)
----------
----------
center(e_ref) = {4, 5}
area(e_ref) = 131.94689145077132
bounding_box(e_ref) = rectangle({4, 5}, 6, 7)
Drawn by draw(e_ref): ellipse({4, 5}, 6, 7)
----------
----------
center(s_ref) = {8, 9}
area(s_ref) = 100
bounding_box(s_ref) = rectangle({8, 9}, 10, 10)
Drawn by draw(s_ref): square({8, 9}, 10)
----------
----------
center(r_ref) = {11, 12}
area(r_ref) = 182
bounding_box(r_ref) = rectangle({11, 12}, 13, 14)
Drawn by draw(r_ref): rectangle({11, 12}, 13, 14)
----------

Not how one did not need to change any of the concrete shape classes in order to make them referenceable. They were not designed with a common interface in mind, but one can still use all 4 in a common way. One can also create a value class for storing any shape using this same technique, just with a few slight modifications like:

• Adding a do_clone method and using a unique_ptr<void, SomeDeleter> for storage where the deleter also stores a vtable
• Using shared_ptr<void> for storage and constructing one by using make_shared<T> in the constructor

This is a superior way of writing polymorphic code, and it still captures some of the properties that a traditional OO method would use:

• Circles, ellipses, squares, and rectangles are shapes. (they all implement the shape concept)
• Circles are ellipses. (implicit conversion from circle to ellipse)
• Squares are rectangles. (implicit conversion from square to rectangle)

This implementation of polymorphic references is very similar to Rust's implementation of &dyn, both using a data pointer and a vtable pointer.

Known Uses

• std::function on certain ABIs (you may have to set an ABI flag)
• std::move_only_function
• std::function_ref
• std::any

Related Idioms

• Type Erasure
• Polymorphic Value Types