class1 {
public:
enum Action {stay,run};
}

class2:public class1 {
public:
enum Action {stay,run,jump};
}

struct base
{
    typedef boost::mpl::vector<run, stay> actions;
};

struct child : public base
{
    typedef boost::mpl::push_back<base::actions, jump> actions;
};

class1 {
public:
static const int stay = 0;
static const int run = 1;
};
class2:public class1 {
public:
static const int jump = 2;
};

class class1 {
public:
  enum Action {stay,run};
  static const int LastAction = run;
};

class class2:public class1 {
public:
  enum Action {jump=LastAction+1,sit};
};

K>class1 {
K>public:
K>enum Action {stay,run};
K>}
K>

K>class2:public class1 {
K>public:
K>enum Action {stay,run,jump};
K>}
K>

class base {
  enum EAction { super = 0 };
  static const stay = super+1;
  // etc...
  virtual some_method(EAction act) =0;
};

#include <boost/current_function.hpp>
#include <boost/function.hpp>
#include <boost/bind/apply.hpp>
#include <boost/bind.hpp>
#include <algorithm>
#include <iostream>
#include <vector>

struct car
{
    void start() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void stop() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};
struct human
{
    void eat() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void shit() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};
struct tiger
{
    void jump() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void eat() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};

int main()
{
    car c;
    human h;
    tiger t;

    typedef std::vector<boost::function<void()> > actions;
    actions a;
    a.push_back(boost::bind(&car::start, c));
    a.push_back(boost::bind(&human::eat, h));
    a.push_back(boost::bind(&tiger::jump, t));
    a.push_back(boost::bind(&human::shit, h));
    a.push_back(boost::bind(&car::stop, c));
    a.push_back(boost::bind(&tiger::eat, t));

    std::for_each(a.begin(), a.end(), boost::bind(boost::apply<void>(), _1));
    return 0;
}