Re: What is the name of this pattern?

Hi,
I'm just documenting some of my code and I cannot remember the name of
a pattern I have used. It allows a class to hold a collection of
objects of undefined types as long as they provide the correct
interface, and performs actions on those objects. However, the code
that performs the actions is template free and hence can be in a
separately compilable implementation file. Here is the code in the
simplest form I could get it:

#include <iostream>
#include <list>

class Processor
{
public:
    void process()
    {
        for(Clients::iterator i = clients_.begin(); i != clients_.end
(); ++i)
            (*i)->foo();
    }

    template <class T>
    void addClient(T& t)
    {
        clients_.push_back(new ClientHolder<T>(t));
    }

private:
    struct ClientBase
    {
        // The interface clients must provide
        virtual void foo() = 0;
    };

    template <class T>
    struct ClientHolder : public ClientBase
    {
        ClientHolder(T& t) : t_(t) {}
        void foo()
        {
            t_.foo();
        }
        T& t_;
    };

    typedef std::list<ClientBase*> Clients;
    Clients clients_;

};

struct X {void foo() { std::cout << "X\n"; }};
struct Y {void foo() { std::cout << "Y\n"; }};
struct Z {void foo() { std::cout << "Z\n"; }};

int
main()
{
    Processor p;
    X x;
    Y y;
    Z z;
    p.addClient(x);
    p.addClient(y);
    p.addClient(z);
    p.process();

    return 0;

}

Note the Processor::process() is not templated and so can go in a
separate implementation file. I can't remember where in my memory I
got this pattern from. Does it have a name?