Polymorphism with lambda functions

This is my 100th article and it was celebrated.

 

As I’m a fan of polymorphism, I play with different approaches on this subject. I want to find new ways of dealing with polymorphic objects under constrained scenarios. Not all of them are great, but every time I learn something new that I should or should not apply in real situations.

This time, the self-imposed context is:

• • C++11
  • Using only the standard library
  • Using std::array to have a homogenous list of objects

I want a list of objects where each object behaves differently.

struct Object {
    int id{};
    int value{};
};

std::array<Object, 2> objects;

 

But I cannot simply add a method to Object because I want a different method attached to each Object from the array. I was spinning around attaching lambdas to those objects for a while when it hit me: I could use another object to wrap my original one.

 

The wrapper knows about Object (T) and its corresponding lambda (Function)

template <typename T, typename Function>
struct Callable {
    std::function<Function> func_;
}

and it’s callable for simple use.

template <typename T, typename Function>
struct Callable {
    void operator()() {}
}

 

I use a lambda function with its first parameter being the original object (Object), the equivalent of this (think of self in Python). And any other parameters.

using MyObject = Callable<Object, void(Object&, int)>;

MyObject object{[](Object& object, int i) {
    object.id = i;
    object.value = i;
}};

 

When I call the object’s “behavior”, I pass all the arguments except “this”.

object(1);

 

How does it happen?

Callable is based on CRTP to be an Object and to pass an instance of Object (“this”) to the lambda function. It inherits from Object (template argument T) and safely casts itself to Object, thus obtaining an instance of Object.

template <typename T, typename Function>
struct Callable : T {
    template <typename... Args>
    void operator()(Args&&... args)
    {
        func_(static_cast<T&>(*this), std::forward<Args>(args)...);
    }

    std::function<Function> func_;
};

 

What’s wrong with this approach?

There are two possible deal-breakers depending on your context:

• • std::function prevents Callable to be inlined
  • Callable adds some memory overhead

And that’s it with my learning purpose experiment. Here’s the full source code:

#include <array>
#include <cassert>
#include <functional>
#include <utility>

struct Object {
    int id{};
    int value{};
};

template <typename T, typename Function>
struct Callable : T {
    explicit Callable(Function func) : func_{std::move(func)} {}

    template <typename... Args>
    void operator()(Args&&... args)
    {
        func_(static_cast<T&>(*this), std::forward<Args>(args)...);
    }

   private:
    std::function<Function> func_;
};

int main()
{
    using MyObject = Callable<Object, void(Object&, int)>;

    std::array<MyObject, 2> objects = {
        MyObject{[](Object& object, int i) {
            object.id = i;
            object.value = i;
        }},
        MyObject{[](Object& object, int i) {
            object.id = i;
            object.value = i * 10;
        }},
    };

    int inc = 0;
    for (auto& object : objects) {
        ++inc;
        object(inc);
    }

    assert(objects[0].id == 1);
    assert(objects[0].value == 1);

    assert(objects[1].id == 2);
    assert(objects[1].value == 20);
}