Масштабирование системы при использовании паттерна Singleton

template<class T>
class Sp;//смарт - буквально - пойнтер )))
 
template<class T>//сиглтон (Майерса)//менеджер памяти
class GC
{
friend class Sp<T>;
map< T*, int> mapp;//pointers
map< T*, pair<int /*cnt*/, int /*siz*/>> mapa;//array pointers
GC(){}
 GC( const GC&);  
    GC& operator=( GC& );
public:
void Add(T *rhs);//добавляем в mapp (одиночные) 
void AddNew(T *rhs,int sz);//добавляем в mappa - (дин массивы)
bool remove(T *rhs);
public:
T *GCNEW(const T &rhs)
{
T *ptr = new T(rhs);
AddNew(ptr);
return ptr;
}
 
T *operator()(const T &rhs)
{
T *ptr = new T(rhs);
AddNew(ptr);
return ptr;
}
T *operator[](int rhs)
{
T *ptr = new T[rhs];
AddNew(ptr, rhs);
return ptr;
}
//остальное неважно
};
template<class T>
class Sp
{
    friend class GC<T>;
 
T *ptr;
 
 
public:
    static GC<T> &NEW;
static const T *GCNEW(const T &rhs)
{
T *ptr_new=gc->GCNEW(rhs);
return ptr_new;
}
~Sp()
{
NEW.remove(ptr);
}
 
Sp()
{
ptr=NULL;
}
 
Sp(const T &rhs)
{
if(this!=rhs)
{
ptr = &rhs;
NEW.Add(ptr);
}
}
 
 
Sp(const T *rhs)
{
if(ptr!=rhs)
{
ptr = const_cast<T*>(rhs);
NEW.Add(ptr);
}
}
 
Sp(const Sp &rhs)
{
if(this!=&rhs)
{
ptr = rhs.ptr;
NEW.Add(ptr);
}
}
 
Sp &operator=(const Sp &rhs)
{
if(this==rhs)return *this;
NEW.remove(ptr);
ptr=rhs.ptr;
NEW.Add(ptr);
return *this;
}
 
Sp &operator=(T * rhs)
{
if(this.ptr==rhs)return *this;
NEW.remove(ptr);
ptr=const_cast<T*>(rhs);
NEW.Add(ptr);
return *this;
}
 
const T *operator->()const{return ptr;}
const T &operator*()const{return *ptr;}
//эти перегрузки должны сопровождаться изменениями в базе mapp
//поскольку теряется прежнее значение указателя ptr
 
T &operator[](int ind){return *(ptr+ind);}
size_t get_size()
{
size_t  ret=0;
ret=NEW.get_size(ptr);
return ret;
}
};
 
template<typename T>
GC<T> &Sp<T>::NEW= GC<T>::getInstance();

ValType obj;
Sp<ValType> pobj=Sp<ValType>::NEW(&obj);
//или
Sp<ValType> sp_dynamic_array=Sp<ValType>::NEW[10];

// устаревшее соединением с мускулом
db::connect(params);

db::connect<MYSQL>(params);
db::connect<POSTGRESQL>(params);

db::connect<MYSQL>(params);
db::connect<POSTGRESQL>(params);

class ProductDataProvider
{
    public:
    Product* getProductById(int id)
    {
        //нужно взять продукт либо из  postge либо из mysql в зависимости от запроса юзера программы
    }
};

/////////////////////////////////////////////////////////////////////////////////////////
class IBDType
{
public:
    virtual ~IBDType() = default;
    virtual Product* getProductById() = 0;
};
/////////////////////////////////////////////////////////////////////////////////////////
class PostgreSQL : public IBDType
{
public:
    virtual Product* getProductById(int) override
    {
        //some code
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
class MySQL : public IBDType
{
public:
    virtual Product* getProductById(int) override
    {
        //some code
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
//in singleton
class bd
{
public:
    //...
    static Product* getProductById(int id)
    {
        switch(BDType)
        {
            case MYSQL:
                return dynamic_cast<MySQL*>(bd)->getProductById(id);
            case POSTGRESQL:
                return dynamic_cast<PostgreSQL*>(bd)->getProductById(id);
            //...
        }
    }
    //...
};
/////////////////////////////////////////////////////////////////////////////////////////

#include <iostream>
 
#define SOURCE_MYSQL 0
#define SOURCE_POSTGRE 1
 
class DbAdapter
{
    public:
    virtual bool query(std::string sql) = 0;
};
 
class MySQLAdapter : public DbAdapter
{
    public:
    bool query(std::string sql) override
    {
        //call mysql_specific_query_function(sql);
        return true;
    }
};
 
class PostgreSQLAdapter : public DbAdapter
{
    public:
    bool query(std::string sql) override
    {
        //call mysql_postgre_specific_query_function(sql);
        return true;
    }
};
 
class Product
{
    bool productData;
    public:
    Product(bool data)
    {
        productData = data;
    }
    
};
 
class ProductDataProvider
{
    DbAdapter *adapter;
    public:
    ProductDataProvider(DbAdapter *a)
    {
        setAdapter(a);
    }
    ProductDataProvider* setAdapter(DbAdapter *a)
    {
        adapter = a;
        return this;
    }
    
    Product* getProductById(int id)
    {
        bool result = adapter->query("query using id...");
        return new Product(result);//based on query result
    }
};
 
int main()
{
    ProductDataProvider provider = ProductDataProvider(new MySQLAdapter);
    Product *prodFromMysql = provider.getProductById(1);
    
    //предположим что значение source мы получили от пользователя
    int source = SOURCE_POSTGRE;
    if (source == SOURCE_POSTGRE) {
        Product *prodFromPostgre = provider.setAdapter(new PostgreSQLAdapter)->getProductById(1);
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
class IBDType
{
public:
    virtual ~IBDType() = default();
    virtual Product* getProductById() = 0;
};
/////////////////////////////////////////////////////////////////////////////////////////
class PostgreSQL : public IBDType
{
public:
    virtual Product* getProductById(int) override
    {
        //some code
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
class MySQL : public IBDType
{
public:
    virtual Product* getProductById(int) override
    {
        //some code
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef PostgreSQL POSTGRESQL;
typedef MySQL MYSQL;
/////////////////////////////////////////////////////////////////////////////////////////
//in singleton
class bd
{
public:
    //...
    template<typename BDType, typename... Args>
    static void connect(Args&&... args)
    {
        if (BDBase == nullptr)
            BDBase = new BDType(std::forward<Args>(args));
        else
        {
            delete BDBase;
            BDBase = new BDType(std::forward<Args>(args));
        }
    }
    
    static Product* getProductById(int id)
    {
        return BDBase->getProductById(id);
    }
    
    IBDType* BDBase;
    //...
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    bd::connect<POSTGRESQL>();
    Product* p1 = bd::getProductById(1);
    bd::connect<MYSQL>();
    Product* p2 = bd::getProductById(1);
}