Serialize Lambda Functions with Cereal - c++

Question

I want to serialize a function and send it to a different process running the same code (dynamic library). My original approach was to use the library cereal and std::function but the type is not supported and there are plenty reasons why.
Now I think about using lambda's converted to function pointers instead but I'm not quite sure if my understanding of their behavior is correct. With the following code, what does the function pointer point to? If it's a static function, I'd assume that I can move the pointer safely to the other process and call it from there.
#include <iostream>
// Nice name for function type
using Foo = int(*)();
int main()
{
auto func = []() -> int
{
return 1;
};
// convert lambda to function pointer w/o captures
Foo fo = func;
// move (serialized) 'Foo fo' to different process
// ...
// calling function pointer in different process
std::cout << fo();
}
Is this safe? If not, how could I achieve the same goal? I could fall back to plain old static functions and skip the lambda but I like the organization the lambda's bring to the use case I have in mind.
UPDATE
What might happen when I use templates to add the function as a template argument and then serialize the type.
#include <iostream>
template<void(*F)()>
class SerializableObj
{
public:
void execute()
{
F();
}
};
void foo()
{
std::cout << "HI!";
}
int main()
{
// calling function pointer in different process
SerializableObj<foo> obj;
// serialize and move obj
// ...
// in other thread / process
obj.execute();
}
In godbolt, execute() now calls the function via symbol, and not via function address. (As far as I understand)

Answer 1

The binary value of a pointer in one processes address space is random bits in another processes address space.
Dynamic libraries are often loaded at literally random addresses (called address space randomization), and even when they are not they are loaded at dynamic addresses (which may by chance be the same address, until they are not because there was another library loaded there first).
Static functions are no better than lambdas.
You need an explicit table of functions guaranteed to be in the same order in both processes, and pass an index into that table.

Answer 2

As it was said in the other answers - it's a very dangerous option to serialize std::function to a binary code to serialize an arbitrary function.
If you want to send some function via the net to another application instance I would suggest you to represent a function not via lambda or std::function, but to use some kind of a syntax tree. This representation can be serialized on one side, deserialized on the other and executed.

Answer 3

You might as well make callable objects and serialize them:
struct Callable {
virtual void execute() = 0;
};
class MyCallable : public Callable {
public:
void execute() override { std::cout << "HI! my data is " << x << std::end; }
// Some data to send along with your Callable
int x;
// Cereal serialization function.
template <class Archive>
void serialize( Archive & ar )
{
ar( x );
}
};
// Register your Callable type.
CEREAL_REGISTER_TYPE(MyCallable);
You might not need the polymorphism.