Шаблонный оператор не шаблонного класса

    template<
        typename T
    > T* _new(
    )
    {
        T* t=_I::_mem_alloc<T>();
        return new(t) T(
            );
    }
 
    template<
        typename T,
        typename P00
    > T* _new(
    P00 p00
    )
    {
        T* t=_I::_mem_alloc<T>();
        return new(t) T(
            p00
            );
    }

class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
    TestClass* test_class=_new<TestClass>(7);
    TestClass* test_class0=_new<TestClass>();
    _dlt(test_class);
    _dlt(test_class0);
 
    system("pause");
    return 0;
}

    class ©new
    {
    public:
        template<typename T> T* operator()()
        {
            return new T();
        }
        ©new& operator[](int size)
        {
            std::cout<<"My mem dispatcher getting array size ="<<size<<std::endl;
            return _new_new;
        }
    }_new_new;

class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
 
    TestClass* tc=_new_new<TestClass>()[5];//ERROR!!!!
 
    system("pause");
    return 0;
}

#include <iostream>
#include <tuple>
#include <memory>
#include <cstring>
 
class TestClass
{
public:
    TestClass(int x)
    {
        std::cout << "TestClass(" << x << ")" << std::endl;
    }
    TestClass()
    {
        std::cout << "TestClass()" << std::endl;
    }
    ~TestClass()
    {
        std::cout << "~TestClass()" << std::endl;
    }
};
 
template <size_t... Indexes>
struct indexes {};
 
template <size_t N, size_t... Indexes>
struct make_indexes
    : make_indexes<N - 1, N - 1, Indexes...>
{};
 
template <size_t... Indexes>
struct make_indexes<0, Indexes...>
    : indexes<Indexes...>
{};
 
template <typename T, typename TupleT, size_t... Indexes>
T * create(TupleT && t, indexes<Indexes...>)
{
    return new T(std::get<Indexes>(std::forward<TupleT>(t))...);
}
 
template <typename T, typename TupleT, size_t... Indexes>
T * create(size_t size, TupleT && t, indexes<Indexes...>)
{
    //Warning!!! It is not legal code if it used with standard delete[],
    //but it works on most implementations
    void * raw = ::operator new(sizeof(T) * size + sizeof(size));
    std::memcpy(raw, &size, sizeof(size));
    void * mem = static_cast<uint8_t *>(raw) + sizeof(size);
    T * elems = static_cast<T *>(mem);
    for(size_t i = 0; i < size; ++i)
    {
        ::new(elems + i) T(std::get<Indexes>(std::forward<TupleT>(t))...);
    }
    return elems;
}
 
template <typename T, typename ...Args>
struct constructor
    : std::tuple<Args...>
{
    constructor(Args const & ...args)
        : std::tuple<Args...>(args...)
    { }
 
    operator std::unique_ptr<T>() const
    {
        return std::unique_ptr<T>(create<T>(*this, make_indexes<sizeof...(Args)>()));
    }
 
    std::unique_ptr<T[]> operator[](size_t size) const
    {
        return std::unique_ptr<T[]>(create<T>(size, *this, make_indexes<sizeof...(Args)>()));
    }
};
 
template <typename T, typename ...Args>
constructor<T, Args...> construct(Args const & ...args)
{
    return constructor<T, Args...>(args...);
}
 
int main()
{
    std::unique_ptr<TestClass> tc1 = construct<TestClass>(5);
    std::unique_ptr<TestClass> tc2 = construct<TestClass>();
    std::unique_ptr<TestClass[]> tc3 = construct<TestClass>()[5];
    std::unique_ptr<TestClass[]> tc4 = construct<TestClass>(10)[5];
}

    template<typename T, typename P0=void> class _new_for_index;
 
    template<typename T, typename P0> _new_for_index<T,P0> _new(P0);
 
    template<typename T> class _new_for_index<T>
    {
    public:
        T* operator[](int size)
        {
            std::cout<<"Creation aray of T, size = "<<size<<std::endl;
            T* temp=(T*)::operator new(size*sizeof(T));
            for (int i=0; i<size; i++)
            {
                new(&temp[i]) T();
            }
            return temp;
        }
        operator T*()
        {
            std::cout<<"Creation T"<<std::endl;
            return new T();
        }
    private:
        template<typename T> friend _new_for_index<T> _new();
        _new_for_index(){}
    };
 
    template<typename T, typename P0> class _new_for_index
    {
    public:
        T* operator[](int size)
        {
            std::cout<<"Creation aray of T, size = "<<size<<std::endl;
            T* temp=(T*)::operator new(size*sizeof(T));
            for (int i=0; i<size; i++)
            {
                new(&temp[i]) T(p0);
            }
            return temp;
        }
        operator T*()
        {
            std::cout<<"Creation T"<<std::endl;
            return new T(p0);
        }
    private:
        template<typename T, typename P0> friend _new_for_index<T,P0> _new(P0);
        _new_for_index(P0 p0™)
        {
            p0=p0™;
        }
        P0 p0;
    };
 
    template<typename T> _new_for_index<T> _new()
    {
        return _new_for_index<T>();
    }
 
    template<typename T, typename P0> _new_for_index<T,P0> _new(P0 p0)
    {
        return _new_for_index<T,P0>(p0);
    }

class TestClass
{
public:
    TestClass(int x)
    {
        std::cout<<x<<std::endl;
    }
    TestClass()
    {
        std::cout<<"null"<<std::endl;
    }
};
 
int main()
{
    TestClass* test_class=_new<TestClass>(7);
    TestClass* test_class0=_new<TestClass>();
    
    TestClass* tc=_new<TestClass>()[5];
    TestClass* tc2=_new<TestClass>(2)[5];
 
    system("pause");
    return 0;
}