Класс Singletone

#include <iostream>
#include <typeinfo>
#include <stdlib.h>
using namespace std;
 
class BasePulse;
class SqrPulse;
class LinearPulse;
class RndPulse;
 
//------------------------- class BasePulse ----------------------
 
class BasePulse
{
protected:
    int Vmax, Vmin;
    static BasePulse *single;
    static bool instanceFlag;
    BasePulse(){}       //private constructor
    virtual ~BasePulse(){ instanceFlag = false; }
public:
    int tickVal;
    virtual BasePulse *getInstance()=0;
    BasePulse* getInstance(BasePulse *type);
    void setType(BasePulse *type);
    void setVmax(int vmx){ single->Vmax=vmx; }
    void setVmin(int vmn){ single->Vmin=vmn; }
    int getVmax(){ return single->Vmax; }
    int getVmin(){ return single->Vmin; }
    virtual void getTickVal()=0;
    virtual void DisplayProperties()=0;
    void finalize();
};
 
BasePulse *BasePulse::getInstance(BasePulse *type)
{
    if( typeid(type)!=typeid(single) ){
        delete single;
        single=NULL;
        single=type;
    }
}
 
 
void BasePulse::setType(BasePulse *type)
{
    if( typeid(single)!=typeid(type) ){
        delete single;
        single=NULL;
        single->getInstance(type);
    }
}
 
void BasePulse::finalize()
{
    delete single;
    single=NULL;
}
 
//------------------------------------
 
bool BasePulse::instanceFlag = false;
BasePulse* BasePulse::single = NULL;
 
//--------------- class SqrPulse ------------------------
 
class SqrPulse : public BasePulse
{
private:
    SqrPulse():BasePulse(){}       //private constructor
    ~SqrPulse()  { instanceFlag = false; }
public:
    BasePulse *getInstance();
    void DisplayProperties();
    void getTickVal();  
};
 
BasePulse *SqrPulse::getInstance()
{
    SqrPulse *temp=new SqrPulse;
 
    if(! instanceFlag){
        single = new SqrPulse;
        instanceFlag=true;
        return single;
    }else{
        cout << "Pulse is exist! Change to new pulse" << endl;
        single->setType(temp);
        instanceFlag=true;
        delete temp;
        temp=NULL;
 
        return single;
    }
}
 
void SqrPulse::DisplayProperties()
{
    cout << "SqrPulse in use, Vmax=" << single->getVmax() << ", Vmin=" << single->getVmin() << endl;
}
 
void SqrPulse::getTickVal()
{
    (single->tickVal==single->getVmax())?(single->tickVal=single->getVmin()):(single->tickVal=single->getVmax());
    cout << "SqrPulse: tickVal=" << single->tickVal << endl;
}
 
//--------------- class LinearPulse ------------------------
 
class LinearPulse : public BasePulse
{
private:
    LinearPulse():BasePulse(){}       //private constructor
    ~LinearPulse()  { instanceFlag = false; }
public:
    BasePulse *getInstance();
    void DisplayProperties();
    void getTickVal();      
};
 
BasePulse *LinearPulse::getInstance()
{
    LinearPulse *temp=new LinearPulse;
 
    if(! instanceFlag){
        single = new LinearPulse;
        instanceFlag=true;
        return single;
    }else{
        cout << "Pulse is exist! Change to new pulse" << endl;
        single->setType(temp);
        instanceFlag=true;
        delete temp;
        temp=NULL;
 
        return single;
    }
}
 
void LinearPulse::DisplayProperties()
{
    cout << "LinearPulse in use, Vmax=" << this->getVmax() << ", Vmin=" << this->getVmin() << endl;
}
 
void LinearPulse::getTickVal()
{
    int choice;
    do{
        for(; single->tickVal<single->getVmax(); single->tickVal++) cout << "LinearPulse: tickVal=" << single->tickVal <<endl;
        cout << "Linear Pulse: tickVal=Vmax=" << single->tickVal << endl;
        single->tickVal=single->getVmin();
        cout << "Linear Pulse: tickVal=Vmin=" << single->tickVal << endl;
        cout << "Enter 999 to exit, other num to continue: ";
        cin >> choice;
    }while( choice!=999 );
}
 
//--------------- class RndPulse ------------------------
 
class RndPulse : public BasePulse
{
public:
    RndPulse(){}       //private constructor
    ~RndPulse()  { instanceFlag = false; }
 
    BasePulse *getInstance();
    void DisplayProperties();
    void getTickVal();          
};
 
BasePulse *RndPulse::getInstance()
{
    if(! instanceFlag){
        single = new RndPulse();
        instanceFlag=true;
        return single;
    }else{
        cout << "Pulse is exist! Change to new pulse" << endl;
        return single;
    }
}
 
void RndPulse::DisplayProperties()
{
    cout << "RndPulse in use, Vmax=" << this->getVmax() << ", Vmin=" << this->getVmin() << endl;
}
 
void RndPulse::getTickVal()
{
    int choice;
    do{
        single->tickVal=rand()%(single->getVmax())+single->getVmin();
        cout << "RndPulse: tickVal=" << single->tickVal << ". Enter 999 to exit, any number to continue: ";
        cin >> choice;
    }while(choice!=999);
}
 
//--------------------------------------------------------
 
 
 
//----------------------- main() -------------------------------
 
int main()
{
    SqrPulse *s1, *s2;
 
    s1->SqrPulse::getInstance();
    s1->setVmax(12);
    s1->SqrPulse::getTickVal();
    s1->SqrPulse::DisplayProperties();
 
    s2->SqrPulse::getInstance();
    s2->SqrPulse::getTickVal();
    s2->SqrPulse::DisplayProperties();
 
    // До сих пор работает отлично. Создается вроде только один объект типа SqrPulse, при попытке создать второй замещает.
    // Проблемы начинаются дальше, если хочу создать объект отличного от первого типа. 
    // LinearPulse не замещает собой SqrPulse и не принимает от него данных. Помогите это решить.
 
    LinearPulse *l1,*l2;
 
    l1->LinearPulse::getInstance();
    l1->setVmax(20);
    l1->LinearPulse::getTickVal();
    l1->LinearPulse::DisplayProperties();
 
    l2->LinearPulse::getInstance();
    l2->LinearPulse::getTickVal();
    l2->LinearPulse::DisplayProperties();
 
    //s1->finalize();
 
    return 0;
}

//Title of this code
//g++  4.9.2
 
#include <iostream>
 
 
class BasePulse;
class SqrPulse;
class LinearPulse;
class RndPulse;
 
struct Factory
{
    template<class T = LinearPulse> static 
    T& Get()
    {
        enum { eCHECK_SUCCESS = 
           std::is_same<T,SqrPulse>::value    ||
           std::is_same<T,LinearPulse>::value ||
           std::is_same<T,RndPulse>::value
        };
        
        static_assert( 
            eCHECK_SUCCESS,
            "ERROR: INVALID TYPE"
        );
        
        static T obj;
        
        auto* cur = GetBase();
        
        if(cur)
            return dynamic_cast<T&>(*cur);
        
        cur = &obj;
        return obj;
    }
    
private:
    static BasePulse* GetBase()
    {
        BasePulse* p = nullptr;
        return p;
    }
    
};
 
class BasePulse
{
protected:
    BasePulse(){}
public:    
    virtual void pulse() = 0;
};
 
class SqrPulse: BasePulse
{
    friend struct Factory;
protected:
    SqrPulse(){}
public:    
    virtual void pulse() { std::cout<<"SqrPulse\n"; };
};
 
class LinearPulse: BasePulse
{
    friend struct Factory;
protected:
    LinearPulse(){}
public:    
    virtual void pulse() { std::cout<<"LinearPulse\n"; };
};
 
class RndPulse: BasePulse
{
    friend struct Factory;
protected:
    RndPulse(){}
public:
    virtual void pulse() { std::cout<<"RndPulse\n"; };
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    auto& obj = Factory::Get<RndPulse>();
    obj.pulse();
    
}