#include <list>
#include <vector>
#include <iostream>

template <typename T_type>
class echo_allocator : public std::allocator<T_type> {

  typedef std::allocator<T_type> T_allocator;

public:
  typedef size_t        size_type;
  typedef ptrdiff_t     difference_type;
  typedef T_type*       pointer;
  typedef const T_type* const_pointer;
  typedef T_type&       reference;
  typedef const T_type& const_reference;
  typedef T_type        value_type;
  
  template<typename U_type> struct rebind
  { typedef echo_allocator<U_type> other; };

  echo_allocator() throw() {
    std::cerr << "*** Allocator created.\n";
  }

  echo_allocator(const echo_allocator&) throw() {
    std::cerr << "*** Allocator cloned.\n";
  }

  template<typename U_type>
  echo_allocator(const echo_allocator<U_type>&) throw() {
    std::cerr << "*** Allocator cloned with rebind.\n";
  }

  ~echo_allocator() throw() {
    std::cerr << "*** Allocator destroyed.\n";
  }

  pointer
  address(reference __x) const { return &__x; }

  const_pointer
  address(const_reference __x) const { return &__x; }

  // NB: __n is permitted to be 0.  The C++ standard says nothing
  // about what the return value is when __n == 0.
  T_type* allocate(size_type __n, const void* __p = 0) { 
    std::cerr << "+++ Allocated object.\n";
    T_type *o = T_allocator::allocate(__n,__p); 
  }
  
  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n) { 
    std::cerr << "+++ Delocated object.\n";
    T_allocator::deallocate(__p,__n); 
  }

  size_type max_size() const throw() 
  { return(T_allocator::max_size()); }

  void construct(pointer __p, const T_type& __val) { 
    T_allocator::construct(__p,__val);
    std::cerr << "+++ Constructed object.\n";
  }
  
  void destroy(pointer __p) {
    std::cerr << "+++ Destroyed object.\n";
    T_allocator::destroy(__p);
  }

};


template <typename T>
class echo_list : public std::list<T,echo_allocator<T> > {};

template <typename T>
class echo_vector : public std::vector<T,echo_allocator<T> > {};

class A {

public:

	A() { 
	
		std::cerr << "--- New default A.\n";
		_v = 0;
	
	};
	
	A(int v) {
	
		std::cerr << "--- New A " << v << ".\n";
		_v = v;
		
	};
	
	A(const A& a) {
	
		*this = a;
		std::cerr << "--- Clone A " << _v << ".\n";
		
	};

	~A() {
	
		std::cerr << "--- Del A " << _v << ".\n";
		
	};
	
	int _v;	

};

int main(int argc,char **argv) {

  echo_list<A> E;

  E.push_back(A(4));
  E.push_back(A(5));
  E.push_back(A(6));

  E.pop_front();
  
  echo_vector<A> V;
  
  V.resize(5);
    
  V[3] = A(7);

}