Generic pipe and filters I made a template pipe and filters to replace an old pipe and filters implementation that used inheritance and had a very heavy base class.

#include &lt;iostream&gt;
#include &lt;boost/bind.hpp&gt;
#include &lt;boost/function.hpp&gt;
#include &lt;list&gt;

template &lt;typename Data&gt;
class pipeline {
    typedef boost::function&lt;Data(Data)&gt; filter_function;
    typedef std::list&lt;filter_function&gt; filter_list;
    filter_list m_list;

public:
    template&lt;typename T&gt;
    void add(T t) {
        m_list.push_back(boost::bind(&amp;T::filter, t, _1));
    }

    Data run(Data data) {
        typedef typename filter_list::iterator iter;
        iter end = m_list.end();

        for(iter it = m_list.begin(); it != end; ++it) {
            data = (*it)(data);
        }

        return data;
    }
};

struct foo {
    int filter(int i) {
        return i + 1;
    }
};

int main(int argc, _TCHAR* argv[])
{
    pipeline&lt;int&gt; pipe;
    foo f;
    pipe.add(f);
    std::cout &lt;&lt; pipe.run(0);
    char c;
    std::cin &gt;&gt; c;
}


Except the fact that add() is a template, are there any issues anyone sees with this approach?
As run() is several lines long, it should be defined outside the class.  Anything defined inside is automatically inlined.
Depending on the size of data when passing by value, it may be best to pass it to run() by const&amp;, modify a local copy, and return that.  RVO should still kick in.
Is there a significance to the name foo here?  If not, it should be more accurate and start with a capital letter as it's a user-defined type.  The capitalization also applies to pipeline.
iter end = m_list.end(); seems pointless here.  You can just use m_list.end() inside the loop statement.

As m_list is not being modified inside the loop, you can instead use cbegin() and cend() for const-correctness.

If you have C++11, you can use auto to replace the defined iterator inside the loop statement.
Your "pause" is okay, but you can also use std::cin.get() to do the same thing.