Pros/Cons of using operator overloading (new/delete) to implement Singleton - c++

Question

I was brushing up my C++ knowledge and I chose implementing singleton to be starting point. Just I didn't want to implement the classic private constructor & static getInstance method way of doing it.
So here is a Rube Goldberg way,
class Singleton : public IDestroy {
static Singleton* iS; // Singleton instance
static int count; // number of undeleted objects
int a;
public:
Singleton(int A = 0) {
if (!iS) {
a = A;
iS = this;
}
count++;
}
void destroy() {delete this;} // way to destroy HeapOnly
int get() {
return a;
}
static void* operator new(std::size_t size);
static void operator delete(void* ptr);
protected:
// Ensuring construction of HeapOnly objects
// If object created on stack, there is no control of new operator
~Singleton() {
count--;
std::cout << "Destroyed, remaining :" << count << std::endl;
}
};
void* Singleton::operator new(std::size_t size)
{
if (iS)
return iS;
else
return ::operator new(size);
}
void Singleton::operator delete(void* ptr)
{
if (!count)
{
::operator delete(ptr);
iS = 0;
std::cout << "Cleared memory" << std::endl;
}
}
Singleton* Singleton::iS = 0;
int Singleton::count = 0;
And to work well with shared_ptr:
class IDestroy
{
public:
virtual void destroy() = 0;
};
class HeapOnlyDestroyer {
public:
void operator()(IDestroy* s) {
s->destroy();
}
};
Now, I can use the same object like:
a = new Singleton(1);
..
a->destroy();
or
shared_ptr<Singleton> s(new Singleton(1), HeapOnlyDestroyer());
I wanted to know if there are any problems in this approach, also its pros/cons over the classic way of using static getInstance method.
Cons:
It is confusing that object is not actually being created with new
Inheritance is possible that will create mess to maintain singleton functionality (could this be turned into a feature?)

Answer 1

First of all, what is the pro of this implementation?
Just I didn't want to implement the classic private constructor[...]
Why not?
Why not following the least surprise rule and using the Meyers Singleton?
e.g:
http://www.devarticles.com/c/a/Cplusplus/C-plus-plus-In-Theory-The-Singleton-Pattern-Part-I/4/
class Log {
public:
static Log& Instance() {
static Log theLog;
return theLog;
}
void Write(char const *logline);
bool SaveTo(char const *filename);
private:
Log(); // ctor is hidden
Log(Log const&); // copy ctor is hidden
Log& operator=(Log const&); // assign op is hidden
static std::list<std::string> m_data;
};
P.S.: Off the records, my first implementation of "singleton" was like this. After explaining the code to a college for half an hour, suddenly he asked: "Is it a singleton what you are trying to achieve?" I had to confess, I had no idea at that time, what a singleton was.