struct MyStruct
{
   std::function<void ()> func;
   MyStruct() = default;
   MyStruct(const std::function<void ()>& func):func(func) { }
};

// ...

std::vector<MyStruct> funcs;
funcs.push_back(&myBla);
funcs.push_back(&myBlub);
for (const auto& f : funcs)
   f.func();

#include <iostream>

struct my_struct {
	void (*my_func)(); // The syntax here is important! You are not declaring a function. You're declaring a pointer to a function.
};

void test_func()
{
	std::cout << "test function" << std::endl;
}

int main()
{
	my_struct	test;

	test.my_func = &test_func; // Assign the address of test_func to test.my_func.

	test.my_func();

	while (1);
}

test.my_func = test_func(); // The return value of test_func is being assigned to test.my_func instead of the address of test_func.

struct MyStruct
{
  virtual void onClick() = 0; //function that will be executed
};
 
std::vector<unique_ptr<MyStruct>> ahue;
 
 
void Button4_OnClick()
{
}
 
struct Button4: public MyStruct{
  void onClick()
  {
     Button4_OnClick()
  }
};

void main()
{  
  ahue.emplace_back(new Button4()); 
}

Another way to do this is to use polymorphism. This isn't necessarily superior to the above, but I thought I'd mention it for completeness. It is used in some libraries.

The code equivalent to the example is:

struct MyStruct
{
  virtual void onClick() = 0; //function that will be executed
};

Another way to do this is to use polymorphism. This isn't necessarily superior to the above, but I thought I'd mention it for completeness. It is used in some libraries.

The code equivalent to the example is:

struct MyStruct
{
  virtual void onClick() = 0; //function that will be executed
};

Two nitpicks with that: first, anything with a virtual function really should get a virtual destructor as well. I once ran into really annoying leaks because someone else did not stick to that rule. Thankfully, many modern compilers will warn you about it.

Second, that's an implementation of the observer pattern. While it can be useful if you need more than one function to be called in response to different types of events but for just a single function I find it more like an anti-pattern imported from languages such as Java where you have no other choice.