typedef Ptr<IDatabase> Database;

class DatabaseImpl : public IDatabase

Database DatabaseFactory (...всякая шняга...) {
   return new DatabaseImpl(...тоже шняга...);
}

	template <class T>
	class Ptr
	{
	private:
		T* mObject;

	public:
		void clear()
		{
			if (mObject !=  0 ) { mObject->Release(); mObject =  0 ; }
		}

		T* intf() const						{ return mObject; }
		T* operator->() const				{ return mObject; }

		bool operator==(const T* p) const	{ return mObject == p; }
		bool operator==(const Ptr& r) const	{ return mObject == r.mObject; }
		bool operator!=(const T* p) const	{ return mObject != p; }
		bool operator!=(const Ptr& r) const	{ return mObject != r.mObject; }

		Ptr& operator=(T* p)
		{
			// AddRef _before_ Release gives correct behaviour on self-assigns
			T* tmp = (p ==  0  ?  0  : p->AddRef());	// Take care of 0
			if (mObject !=  0 ) mObject->Release();
			mObject = tmp; return *this;
		}

		Ptr& operator=(const Ptr& r)
		{
			// AddRef _before_ Release gives correct behaviour on self-assigns
			T* tmp = (r.intf() ==  0  ?  0  : r->AddRef());// Take care of 0
			if (mObject !=  0 ) mObject->Release();
			mObject = tmp; return *this;
		}

		Ptr(T* p) : mObject(p ==  0  ?  0  : p->AddRef()) { }
		Ptr(const Ptr& r) : mObject(r.intf() ==  0  ?  0  : r->AddRef()) {  }

		Ptr() : mObject( 0 ) { }
		~Ptr() { clear(); }
	};

	Database DatabaseFactory(const std::string& ServerName,
		const std::string& DatabaseName, const std::string& UserName,
		const std::string& UserPassword, const std::string& RoleName,
		const std::string& CharSet, const std::string& CreateParams)
	{
		(void)gds.Call();			// Triggers the initialization, if needed
		return new DatabaseImpl(ServerName, DatabaseName, UserName,
								UserPassword, RoleName, CharSet, CreateParams);
	}

#include <stdio.h>

class AI {
    public:
	AI(){};
};

class Aimpl : public AI {
    public:
	Aimpl() {printf("cons\n");};
	~Aimpl() {printf("des\n");};
};

template <class T>
class Ptr {
    public:
	Ptr(){};
	Ptr& operator=(T* p)
		{
		return *this;
		}
};

typedef Ptr<AI> A;

int main () {
    A a = new Aimpl();

    return  0 ;
}

Ptr(T *p) {...}

//на

Ptr() {...}
Ptr operator=(T*p) {...}