Using a vector of std::function to insert std::function

Question

I would like to use polymorphism to have a vector of std::function<void(Base&)> that take in a base class as a parameter, and fill the vector with std::function with a similar signature that instead take in a derived class as a parameter.

#include <functional>
#include <vector>
#include <stdio.h>

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

class Derived : public Base
{
public:
    Derived(int x, int y) : a(x), b(y) {}
    int a, b;
};

void DerivedFunction(Derived& d)
{
    printf("A: %d, B: %d\n", d.a, d.b);
}

using FunctionSignature = std::function<void(Base&)>; // Changing Base& to Derived& compiles fine.
static std::vector<FunctionSignature> myVector;

int main()
{
    FunctionSignature fn = [](Derived& d){ printf("A: %d, B: %d\n", d.a, d.b); };
    
    myVector.push_back(fn); // error
    myVector.push_back(std::forward<FunctionSignature>(fn)); // error
    myVector.push_back(std::bind(&DerivedFunction, std::placeholders::_1)); // error
    return 0;
}

What would be the correct way to push_back DerivedFunction into the vector?

Godbolt link: https://godbolt.org/z/b6Taqoqs8

There isn't one. Because you might do `Base b; myVector[0](b);` — user253751, Feb 07 '23 at 12:43
in other words: any intstance of `Derived` is-a `Base` but not the other way around — 463035818_is_not_an_ai, Feb 07 '23 at 12:47
The vector is a pointless distraction; even without it, you have an error on the first line of `main`. (What would you expect `fn(Base());` to do?) — molbdnilo, Feb 07 '23 at 12:55
compiler errors should be in the quesiton. It holds valuable information, and it is essential when the question is how to fix the error — 463035818_is_not_an_ai, Feb 07 '23 at 12:56

463035818_is_not_an_ai · Accepted Answer · 2023-02-07T13:18:59.583

A Derived& can be implicitly converted to a Base&. Inheritance models a is-a relation: Every Derived instance is-a Base. This relation is not mutual. You cannot implicitly convert a Base& to a Derived& (not every Base is-a Derived).

You can use a dynamic_cast. It will throw an exception when the dynamic type of the object is not Derived:

template <typename F>
auto wrap(F f) {
    return [f](Base& b) { 
        f(dynamic_cast<Derived&>(b));
    };
}

int main() {
    FunctionSignature fn = wrap([](Derived& d){ printf("A: %d, B: %d\n", d.a, d.b); });
}

Live Demo

You could catch the exception in the wrapper, or cast between pointers to get a nullptr rather than an exception (for details see here).

As mentioned in a comment, the vector is a distraction. If the first line in main is fixed you can use the same with the vector.

Using a vector of std::function to insert std::function

1 Answers1