#include <iostream>
#include <list>
#include <algorithm>
#include <string>

using namespace std;

struct print
{
    void operator()(const string& _str)
    {
        cout << _str << endl;
    }
};

int main()
{
    list<string> str_list;
    str_list.push_front("hello");
    str_list.push_front("world");
   
    list<string> another_list;
    another_list.push_back("hello");
    another_list.push_back("world");
   
    for_each(str_list.begin(), str_list.end(), print());
    for_each(another_list.begin(), another_list.end(), print());
}

运行结果：

world
hello
hello
world

简单的东西往往能说明深刻的道理，在这个程序里，我们遇到的本质问题是什么？首先，我们有一个容器；其次，我们可以往容器里面放东西，最后，我们可以通过算法把一个操作施加于这个容器中的每一个（也可以是部分）元素中。这就是上面程序中凝结的本质问题。

MPL 可以看成是 STL 的编译期版本，或者说元编程版本。它同样也提供了各种容器，只不过容纳的对象不是数据，而是类型。它们的构造方式语法上比较类似，或者甚至，我以为，更有趣一点：

#include <string>
#include <iostream>
#include <boost/mpl/at.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/push_front.hpp>

using namespace boost;

int main()
{
    typedef mpl::list<> type_list1;
    typedef mpl::push_front<type_list1, int>::type type_list2;
    typedef mpl::push_front<type_list2, std::string>::type type_list;
   
    // 或者这样更好
    typedef mpl::list<int, std::string> another_list;
   
    std::cout << typeid(mpl::at_c<type_list, 0>::type).name() << std::endl;
    std::cout << typeid(mpl::at_c<type_list, 1>::type).name() << std::endl;
   
    std::cout << typeid(mpl::at_c<another_list, 0>::type).name() << std::endl;
    std::cout << typeid(mpl::at_c<another_list, 1>::type).name() << std::endl;
}

稍微解释一下。mpl::list 就是 std::list 的元编程版本，而 mpl::push_front 是什么就不用我说了。mpl::at_c 是一个元编程算法，作用相当于运行期的 [ ] 运算符，也就是得到一个容器中在某个位置上的元素。在 VC7.1 下面，执行结果是

class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
int
int
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >

这跟运行期的 list 的行为几乎完全一致。

当然，mpl 也有 for_each ，而且我们也可以为 for_each 提供一个元编程 functor 。什么是元编程 functor ？运行时的 functor 是一个提供了 operator() 重载的 struct ，而元编程 functor 就是一个提供了 operator() 模板的 struct ：

#include <string>
#include <iostream>
#include <boost/mpl/at.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/for_each.hpp>

using namespace boost;

struct print
{
    template <class T>
    void operator()(const T&)
    {
        std::cout << typeid(T).name() << std::endl;
    }
};

int main()
{
    typedef mpl::list<> type_list1;
    typedef mpl::push_front<type_list1, int>::type type_list2;
    typedef mpl::push_front<type_list2, std::string>::type type_list;
   
    typedef mpl::list<int, std::string> another_list;
   
    mpl::for_each<type_list>(print());
    mpl::for_each<another_list>(print());
}

输出与上面使用 mpl::at_c 的程序完全相同。

当然，到现在为止，这些程序都还是只停留在纯粹的玩具程序上，能不能做点稍微有用的事情呢？当然可以。假定我们有这样一个继承体系：根是一个抽象类 Product ，它有一些派生类，例如 PC ， Printer 等等，它们的公共方法 SerialNo 会返回自己的产品序列号，而这个序列号是在构造的时候决定的：

class Product
{
public:
    virtual std::string SerialNo()const = 0;
};

class PC : public Product
{
public:
    PC(const std::string& _sn)
        : sn_(_sn)
    {}

    std::string SerialNo()const
    {
        return sn_;
    }
private:
    std::string sn_;
};

class Printer : public Product
{
public:
    Printer(const std::string& _sn)
        : sn_(_sn)
    {}
   
    std::string SerialNo()const
    {
        return sn_;
    }
private:
    std::string sn_;
};

用 mpl::list 把这些类型放在同一个 list 里面当然不在话下，但是我们希望有一个类似 factory 模式的实现，让我们可以自由创建它们。下面的程序用 mpl::for_each 为 list 中的每一个类型创建一个实例，它当然可以被扩展来做些很有用的事情。

#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <list>
#include <boost/shared_ptr.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/for_each.hpp>

using namespace boost;

class Product
{
public:
    virtual std::string SerialNo()const = 0;
};

class PC : public Product
{
public:
    PC(const std::string& _sn)
        : sn_(_sn)
    {}

    std::string SerialNo()const
    {
        return sn_;
    }
private:
    std::string sn_;
};

class Printer : public Product
{
public:
    Printer(const std::string& _sn)
        : sn_(_sn)
    {}
   
    std::string SerialNo()const
    {
        return sn_;
    }
private:
    std::string sn_;
};

struct print
{
    template <class T>
    void operator()(const T& product)
    {
        std::cout << "Type: " << typeid(T).name()
                  << " SerialNo: " << product.SerialNo() << std::endl;
    }
};

// 由于 PC 和 Print 都没有默认的 constructor ，必须加上这个
template <class T>
struct wrap {};

struct Create
{
    Create(const std::string& _line)
        : line_(_line)
        , serial_(0)
    {}
   
    template <class T>
    void operator()(wrap<T>)
    {
        std::stringstream ss;
        ss << line_ << '_' << serial_++;
        shared_ptr<T> product(new T(ss.str()));
       
        print()(*product);
    }
   
    std::string line_;
    unsigned long serial_;
};

int main()
{  
    typedef mpl::list<Printer, PC> product_list;
   
    mpl::for_each<product_list, wrap<mpl::_1> >(Create("line1"));
}

输出：

Type: class Printer SerialNo: line1_0
Type: class PC SerialNo: line1_1

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ralph623/archive/2005/10/15/504369.aspx

来自:http://www.cppblog.com/shanoa/archive/2009/05/30/86143.html
接触了boost的状态机，发现不是想象中的那么好用，在一些地方还得用上mpl库里的东西，由于对模板元编程不是很熟练，搞了好些天才算弄明白这该死的mpl::list的原理和用法。
boost的状态机是属于静态链接的状态机，也就是说，它的图结构是编译期间就确定了的，在运行时不可以动态配置。所以，它的用途是有一定局限性的，但在一般情况下，它不仅很通用，而且在你会用并熟练地情况下，还会很好用，用起来很舒服，逻辑也很合理。下面就是一段代码，当然也是借鉴了别人的东西，自己修改了一下，在MainState中添加了一个Transition做了测试，因为此前我还不知道一个状态如何包含多个Transition，呵呵，原来是用mpl::list来做。至于这个状态机的入门教程，网上随处可见的三部曲：《boost 状态机入门教程》说得很清楚。

1 基础主题：秒表
    下面我们要为一个机械秒表建模一个状态机。这样一个秒表通常会有两个按钮。
     * Start/Stop
     * Reset
     同时有两种状态：
     * Stoped: 表针停留在上次停止时的位置：
        o 按下Reset按钮，表针回退到0的位置。秒表保持在Stoped状态不变。
        o 按下Start/Stop按钮，秒表转到Running状态。
     * Running: 表针在移动，并持续显示过去的时间：
        o 按下Reset按钮，表针回退到0的位置，秒表转到停止状态。
        o 按下Start/Stop按钮，转到Stoped状态。
    下面是其UML图：



1.1 定义状态和事件
两个按钮可以建模为两个事件。进而，定义出必要的状态和初始状态。我们从下面的代码开始，以前的代码片段会陆续加入其中：

#include <boost/statechart/event.hpp>
#include <boost/statechart/state_machine.hpp>
#include <boost/statechart/simple_state.hpp>

namespace sc = boost::statechart;

struct EvStartStop : sc::event< EvStartStop > {};
struct EvReset : sc::event< EvReset > {};

struct Active;
struct StopWatch : sc::state_machine< StopWatch, Active > {};

struct Stopped;

// 这里的simple_state类模板可以接受4个参数：
// - 第3个参数指定内部的初始状态，如果有一个这样的状态的话。
//   在这里，Active有一个内部状态（Stoped）， 所以将这个内部
//   初始状态传给它的基类。
// - 第4个参数指定是否保留和保留什么类型历史

// Active是最外层的状态，因此要把它所属的状态机类传给它
struct Active : sc::simple_state<
  Active, StopWatch, Stopped > {};

// Stopped 和 Running 都把Active作为它们的上下文，这使他们嵌入到了Active状态中。
struct Running : sc::simple_state< Running, Active > {};
struct Stopped : sc::simple_state< Stopped, Active > {};

// 因为状态的上下文必须是一个完整的类型（不能单单是声明），
// 所以状态机必须要在“外层状态”之间先定义。
// 也就是说，我们需要从状态机开始，然后是最外层的状态，然后是其内部的状态，如此反复。
// 我们可以用广度或深度方式，再或是以两都混合的方式来进行定义。

int main()
{
  StopWatch myWatch;
  myWatch.initiate();
  return 0;
}

这个代码已经可以编译了，但不会发生任何可察觉的事件。

如何开始使用boost的跨平台thread库(Windows)