#include<iostream>
using namespace std;

template<class T>
class Stat
{
public:
	virtual void apply(T &) = 0;
};

template<class T>
class Printer : public Stat<T>
{
public:
	virtual void apply(T & v)
	{
		cout << v << ' ';
	}
};

template<class T>
class Counter : public Stat<T>
{
	int l;
public:
	Counter() : l(0) {}
	virtual void apply(T & v)
	{
		l++;
	}
	int getL()const
	{
		return l;
	}
};

template<class T>
struct Elem
{
	T inf;
	Elem * next;
};

template <class T>
class List
{
public:
	List();
	~List();

	void add(const T &);
	void removeFirst();

	void iterate(Stat<T> &);
	bool isEmpty() const;
private:
	Elem<T> * start;

	List(const List&);
	List& operator=(const List<T> &);
};

template<class T>
List<T>::List()
{
	start = NULL;
}

template<class T>
void List<T>::add(const T & v)
{
	Elem<T> * n = new Elem<T>;
	n->inf = v;
	n->next = start;
	start = n;
}

template<class T>
void List<T>::removeFirst()
{
	Elem<T> * n = start;
	start = n->next;
	delete n;
}

template<class T>
bool List<T>::isEmpty() const
{
	return start == NULL;
}

template<class T>
void List<T>::iterate(Stat<T> & s)
{
	Elem<T> * t = start;
	while(t != NULL)
	{
		s.apply(t->inf);
		t = t->next;
	}
}

template<class T>
List<T>::~List(){
	while( !isEmpty() )
	{
		removeFirst();
	}
}

template <class T>
class Applier : public Stat<  Stat<T> * >
{
	T v;
public:
	Applier(const T & _v) : v(_v) {}
	virtual void apply( Stat<T> * & s)
	{
		s->apply(v);
	}
};

template <class T>
class CompositStat : public Stat<T>
{
	List< Stat<T> * > l;
public:
	void apply(T & v)
	{
		Applier<T> a(v);
		l.iterate(a);
	}
	void add(Stat<T> * s)
	{
		l.add(s);
	}
};

int main()
{
	List<int> a;
	a.add(5);
	for ( int i = 0; i < 10; ++i )
	{
		a.add(i);
	}

	Printer<int> p;
	Counter<int> c;

	CompositStat<int> cs;
	cs.add(&c);
	cs.add(&p);

	a.iterate(cs);

	cout << endl;
	cout << c.getL() << endl;

	return 0;
}