Why it intends to call templated copy constructor instead explicit with parameter?

[icegood]

// set::insert
#include <iostream> 
#include <set>
#include <vector>
#include <memory>
#include <functional>

//using namespace std;
  ///////////////////////1
  class TInternalPool
  {
  public:
    TInternalPool()
    {
      buf=NULL;
      mem_cnt=0;
    }
    
    //  I don't want objects of this class to be copied or assigned
    TInternalPool(const TInternalPool&) = delete;
    TInternalPool& operator=(const TInternalPool&) = delete;
    
    ~TInternalPool()
    {
      FreeBuf();
    }
    
    void FreeBuf()
    {
      if (buf)
      {
        delete [] buf;
        buf=NULL;
      }
    }
    
    void BufReserve(size_t count, size_t align)
    {
      count+=align-1; // to make available satisfy alignment for elements in future
      if (mem_cnt<count)
      {
        FreeBuf();
        mem_cnt=count;
        buf = new char[count]; //>=count bytes, not aligned, aligning will be later
        if (!buf)
          throw std::bad_alloc();
        last=buf+count;
      }
      curr=last;
    }
    
    inline char* allocate(size_t sz, size_t align)
    {
      curr-=sz;
      curr=reinterpret_cast<char*>(reinterpret_cast<size_t>(curr) & (-align));
      if (curr<buf)
        throw("Space supposed to be pre-allocated!");
      return curr;
    }
    
    inline void deallocate(size_t n)
    {
      // curr+=n; // no align control analysis so it's not invert to "allocate"
    }
    
    void Clear()
    {
      curr=last; // allocate from back as in stack
    }
  private:
    char *buf, *last, *curr;
    size_t mem_cnt;
  };
  ///////////////////////2
  template <class T> 
  class TBufferedAllocator: public std::allocator<T>
  {
  public:
    typedef T* pointer;
    typedef size_t size_type;
    
    template<class _Other>
    struct rebind
    {
      typedef TBufferedAllocator<_Other> other; 
    };
    
    explicit TBufferedAllocator(TInternalPool &Apool): std::allocator<T>(), pool(Apool)
    {
      
    }
    
    TBufferedAllocator(const TBufferedAllocator& copy_from_me) : pool(copy_from_me.pool)
    {
    }
    
    template <typename A> 
    TBufferedAllocator(const A& copy_from_me) : pool(copy_from_me.pool)
    {
    }
    
    virtual ~TBufferedAllocator()
    {
    }
    
    virtual pointer allocate(size_type n, const void * hint=0)
    {
      std::cout << "TBufferedAllocator::allocate called, size="<<n <<std::endl;
      std::cout << "size="<<sizeof(T) <<", name=" << 123 << std::endl;
      pool.allocate(n*sizeof(T), alignof(T));
    }
    
    virtual void deallocate(pointer p, size_type n)
    {
      std::cout << "TBufferedAllocator::deallocate called, size="<<n <<std::endl;
      pool.deallocate(n*sizeof(T));
      // no implementation, shouldn't actually be. Memory REALLY deallocates only in destructor or via mem change
    }
    
    void reserve(size_t n_bytes)
    {
      pool.BufReserve(n_bytes, alignof(T));
    }
  protected:
    TInternalPool &pool;
  private:
    // no default constructor accessable:
    TBufferedAllocator();
    
    template <typename U>
    friend class TBufferedAllocator;
  };
  ///////////////////////3
  template <class T> 
  class TBufferedStdSetAllocator : public TBufferedAllocator<T>
  {
  public:
    typedef T* pointer;
    typedef size_t size_type;
    
    template<class _Other>
    struct rebind
    {
      typedef TBufferedStdSetAllocator<_Other> other; 
    };
    
    explicit TBufferedStdSetAllocator(TInternalPool &Apool): TBufferedAllocator<T>(Apool)
    {
      
    }
    
    TBufferedStdSetAllocator(const TBufferedStdSetAllocator& copy_from_me) : TBufferedAllocator<T>(copy_from_me)
    {
    }
    
    template <typename A> 
    TBufferedStdSetAllocator(const A& copy_from_me) : TBufferedAllocator<T>(copy_from_me)
    {
    }
    
  private:
    template <class U>
    class TBufferedStdSetAllocatorHelper : public TBufferedAllocator<U>
    {
    public:
      size_t node_type_size;
      typedef U* pointer;
      typedef size_t size_type;
      
      template<class _Other>
      struct rebind
      {
        typedef TBufferedStdSetAllocatorHelper<_Other> other; 
      };
      
      explicit TBufferedStdSetAllocatorHelper(TInternalPool &Apool): TBufferedAllocator<T>(Apool)
      {
      }
      
      TBufferedStdSetAllocatorHelper(const TBufferedStdSetAllocatorHelper& copy_from_me) : TBufferedAllocator<T>(copy_from_me)
      {
      }
      
      template <typename A> 
      TBufferedStdSetAllocatorHelper(const A& copy_from_me) : TBufferedAllocator<T>(copy_from_me)
      {
      }
      
      virtual pointer allocate(size_type n, const void * hint=0)
      {
        node_type_size=sizeof(U);
        return NULL;
      }
    };
  public:
    void reserve_set_items_cnt(size_t n_items)
    {
      // hack to get node size in std::set :
      TBufferedStdSetAllocatorHelper<T> hlpAlloc(this->pool);
      std::set<T, std::less<T>, TBufferedStdSetAllocatorHelper<T>> help_set(std::less<T>(), hlpAlloc);
      //
      try
      {
        help_set.insert(T(1, 2)); // could be exception there, just ignore it
      }
      catch (...)
      {
      }
      this->pool.BufReserve(n_items*hlpAlloc.node_type_size, alignof(T));
    }
  };
  
  class foo 
  {
    int a;
    double b;
    void *c;
    const char *d;
    int *e();
    int g;
    
  public: 
    foo(int Aa, int Ag)
    {
      a=Aa;
      g=Ag;
      b=2012.0;
      c=NULL;
      d="Hello world";
      //e=NULL;
    }
    
    inline bool operator <(const foo &other) const
    {
      return a>other.a;
    }
  } ;//__attribute__((aligned(64)));
  
int main ()
{
  TInternalPool pool();
  TBufferedStdSetAllocator<foo> MyAlloc(pool);
  std::set<foo, std::less<foo>, TBufferedStdSetAllocator<foo> > v_foo(std::less<foo>(), MyAlloc);
  //
  MyAlloc.reserve_set_items_cnt(10);
  for (int i=0;i<10;i++)
    v_foo.insert(foo(i, i*i));
  return 0;
}

test_set.cpp: In instantiation of ‘TBufferedAllocator<T>::TBufferedAllocator(const A&) [with A = TInternalPool(); T = foo]’:
test_set.cpp:157:89: required from ‘TBufferedStdSetAllocator<T>::TBufferedStdSetAllocator(const A&) [with A = TInternalPool(); T = foo]’
test_set.cpp:242:45: required from here
test_set.cpp:98:71: error: request for member ‘pool’ in ‘copy_from_me’, which is of non-class type ‘TInternalPool()’

[Cubbi]

TInternalPool pool();

This is a function declaration