Problem Overloading operator new in a template class

[JKallen]

I am over-riding operator new [] so that when an array of "Objects" is created they contain information about adjacent items in the array. I am getting the following error.... c:\Visual Studio Projects\JLib\main.cpp(149): error C2661: 'Object::operator new[]' : no overloaded function takes 3 arguments The following code results in the above comilation error. Object* objects; objects = new Object[5]; // <- error occurrs here delete [] objects; If anyone knows what is going on I would very much appreciate an explanation. Here is the relevant declarations and definitions... #pragma once #include using namespace std; template class Object{ public: //CONSTRUCTORS ETC ETC ETC void* operator new[](size_t size) throw(bad_alloc); void* operator new[](size_t size,const nothrow_t&) throw(); void operator delete[](void* ptr) throw(); void operator delete[](void* ptr,const nothrow_t&) throw(); //OTHER STUF }; template void* Object::operator new[](size_t size) throw(bad_alloc){ Object* data = 0; if ( (data = ::operator new[](size){ //ommitted for brevity } return data; } template void* Object::operator new[](size_t size,const nothrow_t&) throw(){ Object* data = 0; if ( (data = ::operator new[](size,const nothrow_t&)) ){ //ommitted for brevity } return data; } template void Object::operator delete[](void* ptr) throw(){ ::operator delete [] (ptr); ptr = 0; } template void Object::operator delete[](void* ptr,const nothrow_t&) throw(){ ::operator delete [] (ptr,const nothrow_t&); ptr = 0; }

[Zac Howland]

With GCC, the only error I get in your code is caused by the following (in bold):

template <typename T> class Object{
    public:
    //CONSTRUCTORS ETC ETC ETC

        void* operator new[](size_t size) throw(bad_alloc);
        void* operator new[](size_t size,const nothrow_t& nt) throw();
        void operator delete[](void* ptr) throw();
        void operator delete[](void* ptr,const nothrow_t& nt) throw();

    //OTHER STUF

};

template <typename T> void* Object<T>::operator new[](size_t size) throw(bad_alloc){
    Object<T>* data = 0;
    if ( (data = ::operator new[](size){
             //ommitted for brevity
    }
    return data;
}

template <typename T> void* Object<T>::operator new[](size_t size,const nothrow_t& nt) throw(){
    Object<T>* data = 0;
    if ( (data = ::operator new[](size, nt)) ){
             //ommitted for brevity
    }
    return data;
}
        
template <typename T> void Object<T>::operator delete[](void* ptr) throw(){
    ::operator delete [] (ptr);
    ptr = 0;
}

template <typename T> void Object<T>::operator delete[](void* ptr,const nothrow_t& nt) throw(){
    ::operator delete [] (ptr, nt);
    ptr = 0;
}

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac