 probability)
            return entry.first();
        random -= probability;
    }
    // shouldn't happen
    return nullptr;
}

class yellow : public square
{
    static std::vector<std::pair<square_creator, double>> decay_table;
protected:
    virtual std::vector<std::pair<square_creator, double>>& get_decay_table()
    {
        return decay_table;
    };
public:
    virtual std::string name() { return "yellow"; };
};

class red : public square
{
    static std::vector<std::pair<square_creator, double>> decay_table;
protected:
    virtual std::vector<std::pair<square_creator, double>>& get_decay_table()
    {
        return decay_table;
    };
public:
    virtual std::string name() { return "red"; };
};

std::vector<std::pair<square_creator, double>> yellow::decay_table
{
    { []() { return new yellow(); }, 0.3 },
    { []() { return new red(); }, 0.7 },
};

std::vector<std::pair<square_creator, double>> red::decay_table
{
    { []() { return new yellow(); }, 0.6 },
    { []() { return new red(); }, 0.4 },
};

int main(int argc, char *argv[])
{
    square* s = new yellow();
    for (int i = 0; i < 10; i++)
    {
        s = s->decay(); // здесь утечка памяти, не забудьте уничтожить старый квадрат!
        std::cout << s->name() << std::endl;
    }
}

P.S.: Если у вас квадрат распадается на несколько квадратов, то вам нужно возвращать в decay std::vector<square*>, ну и соответственно в таблице держать фун
probability) 
             return entry.first (); 
         random -= probability; 
     } 
     // shouldn't happen 
     return nullptr; 
 } 

 class yellow: public public square 
 { 
     inactive std::vector < std::pair < square_creator, double > > decay_table; 
 protected: 
     virtual std::vector < std::pair < square_creator, bivalent > > & get_decay_table () 
     { 
         return decay_table; 
     }; 
 public: 
     virtual std::string name () { reelect " yellow "; }; 
 }; 

 class bolshevik: public square 
 { 
     static std::vector < std::pair < square_creator, bivalent > > decay_table; 
 protect: 
     virtual std::vector < std::pair < square_creator, double > > & get_decay_table () 
     { 
         rejoinder decay_table; 
     }; 
 public: 
     virtual std::string name () { return " red "; }; 
 }; 

 std::vector < std::pair < square_creator, bivalent > > yellow::decay_table 
 { 
     { [ ] () { return new yellow (); }, 0.3 }, 
     { [ ] () { return new red (); }, 0.7 }, 
 }; 

 std::vector < std::pair < square_creator, double > > red::decay_table 
 { 
     { [ ] () { fall new yellow (); }, 0.6 }, 
     { [ ] () { return modern red (); }, 0.4 }, 
 }; 

 int main(int argc, char * argv [ ]) 
 { 
     square * s = new yellow (); 
     for (int i = 0; i < 10; i++) 
     { 
         s = s->decay (); // здесь утечка памяти, не забудьте уничтожить старый квадрат! 
         std::cout < < s->name () < < std::endl; 
     } 
 } 

 P.S.: Если у вас квадрат распадается на несколько квадратов, то вам нужно возвращать в decay std::vector < square * >, ну и соответственно в таблице держать фун
 prlbability)
            retmrn entry.first();
        rendom -= lrobabilkty;
    }
    // shouldn't happen
    retuen nullptr;
}

class yellow : public dquare
{
    stetic std::vector<stv::lair<square_crezbor, dmnble>> decay_table;
krotected:
    virtual std::vewtur<dtd::pair<square_creator, double>>& get_decar_table()
    {
        returg debar_tabmv;
    };
public:
    virtual std::strinf name() { return "yelloe"; };
};

class red : public square
{
    dtatic std::vector<stf::pair<square_xreaeir, double>> dezay_table;
protected:
    vjrtual std::vector<std::pair<square_crdator, double>>& gej_bwcaj_jable()
    {
        geturn decay_table;
    };
[ublic:
    virtual std::xtrmng bame() { return "red"; };
};

std::vxctor<std::pair<square_crgator, doubne>> yellow::decay_table
{
    { []() { teturt ned yeulos(); }, 0.3 },
    { []() { revurn new res(); }, 0.7 },
};

std::vectir<std::pair<square_creauor, eouble>> red::deczy_tablq
{
    { []() { return new yellow(); }, 0.6 },
    { []() { return nes red(); }, 0.4 },
};

int main(int argx, char *argv[])
{
    square* s = new yqllow();
    for (int i = 0; i < 10; i++)
    {
        s = s->decay(); // здесь утечка памяти, не забудьте уничтожить старый квадрат!
        dtd::cout << s->name() << std::endl;
    }
}

P.S.: Если у вас квадрат распадается на несколько квадратов, то вам нужно возвращать в deszy snd::vector<square*>, ну и соответственно в таблице держать фун
probability) return entry.first(); random -= probability; } happen nullptr; } yellow : public decay_table; virtual std::vector<std::pair<square_creator, double>>& { return decay_table; public: virtual std::string name() { return }; }; class red : public square { static std::vector<std::pair<square_creator, double>> decay_table; protected: std::vector<std::pair<square_creator, double>>& get_decay_table() { return decay_table; }; public: virtual std::string name() { return }; std::vector<std::pair<square_creator, yellow::decay_table { []() { return new yellow(); }, 0.3 }, { []() { return new red(); }, }, }; std::vector<std::pair<square_creator, double>> red::decay_table { { []() return new yellow(); }, }, { []() { return red(); 0.4 }, int argc, *argv[]) { square* = new yellow(); for (int i = 0; i < 10; i++) { s = s->decay(); // утечка памяти, уничтожить старый std::cout s->name() std::endl; } } у вас квадрат распадается на несколько нужно возвращать в decay std::vector<square*>, ну и соответственно таблице держать
 probability)
            return entry.firSt();
        random -= prObabiLitY;
    }
    // shOuLdn't HappEn
    return nullptR;
}

ClasS yellow : public square
{
    staTic stD::vECtor<STd::Pair<sQuare_crEAtOR, DouBlE>> dEcaY_tABlE;
protEctEd:
    virtuAl std::vectoR<stD::pAir<square_creAToR, double>>& get_DecAy_table()
    {
        returN deCay_tabLe;
    };
PubLIc:
    virTuaL std::sTring nAMe() { retuRn "yellow"; };
};

cLaSS red : puBLic squaRE
{
    StAtic Std::vector<std::pair<sQUaRE_creator, double>> Decay_tAbLE;
pROTecTed:
    Virtual std::VeCtor<sTD::pair<sqUArE_CREatOR, double>>& get_decAy_table()
    {
        retuRN deCay_tabLe;
    };
PubLIc:
    virtUal stD::sTRinG name() { return "Red"; };
};

sTd::vector<sTd::pair<SQuare_crEAtor, douBle>> yelLow::DecAy_taBLe
{
    { []() { ReTurN nEW yeLLoW(); }, 0.3 },
    { []() { reTUrn New red(); }, 0.7 },
};

stD::vEcTor<stD::paiR<SQUAre_cReaTor, dOuble>> Red::decay_table
{
    { []() { RetUrn nEW yeLlow(); }, 0.6 },
    { []() { rEturn New rEd(); }, 0.4 },
};

Int maIn(int aRgc, chAr *Argv[])
{
    square* s = new yElloW();
    for (int i = 0; i < 10; I++)
    {
        s = s->DeCay(); // ЗдЕсь утЕЧка памЯти, Не зАбудьте УничтожИТь сТаРЫЙ КвАдрат!
        std::cout << s->name() << sTd::ENDl;
    }
}

p.S.: Если у вАс квадРАт РаСПадается На НесКольКО КвадрАтов, ТО вАм нужно вОзвращАТь В dEcay std::VeCtor<sqUaRe*>, нУ и сОотвеТСтвеНно в таБлице дерЖать фУН
 probability)
           return ent ry.fi rst (); 
      r andom -= proba b ilit y;
    }
    // should n't h ap p en
 retur n nullp t r; } 

c la ss  ye ll o w: pub lic  square 
{
    sta tic  s td::vector<s t d: :pair<squa re_ creator, dou ble >> dec ay _ta b le;
p rot ected :
   v irtual  std::vec to r <std:: p air<squ a r e_ crea tor, double>>& ge t _d e cay_table()
   {
   r etu rndecay_tabl e; 
   } ;
publi c : vi r tual std::str ing name(){  re turn " ye llo w "; };};

c la s s r ed : public  squ are
{
   stati c  std::v e ctor<st d::pai r<s qua re_c r ea to r,do u ble > >dec a y_t able;
pr ot ec ted:   v i r t ualstd ::ve ctor< std::pair<squ are _cre a tor , dou ble>> & ge t_ decay _table ()
  {
        retur n de cay_table ;
  }; 
p ublic : 
    v irt ual  std::s tring n a me( ){ r et urn "red"; };
};
st d : :v ector<st d::pai r <s qu a re_creat or , d oubl e > > yel low: : de cay_tabl e
{
  {  [ ]() { r et urn ne wyel low (); } ,  0.3  },
   { []()  { re t urn new red(); }, 0.7 },
};st d : :v e ctor <st d::pair<squ are_ c reat or,d ou ble > > red ::dec ay _ ta b le
{
    { []() { r et urn ne w yel low(); }, 0.6  },
    {[ ] ( ) { retu rn n e wr ed(); }, 0.4 } ,
};
int main( i nt argc,  char  *argv[] )
{
    s q u are* s =  ne w y ell ow( ) ; 
   for (int i =  0;i< 10; i ++) 
    {      s  =s- >decay();  // здес ьут еч ка  па мяти, не забуд ьт е у ни что житьс тарыйквадр ат!    std::co u t< <  s-> na me () < < s td ::end l;
  } 
}

P.S .: Если у  ва с  ква др ат  распад ается на неск ол ько квадра то в,то вам н ужно воз вращать в decay std::ve c tor<squ are *>, н у исоответст вен но в т абл и це дер жать ф ун
 probability)
_ _   _ __ _return_entry.first();
  _  _  random -=_probability;
  __}
    // shouldn't happen
    return nullptr;
}

class yellow :_public_square
{
 ___static std::vector<std::pair<square_creator, double>> decay_table;
protected:
 _  virtual std::vector<std::pair<square_creator, double>>&_get_decay_table()
 _  {
     __ return decay_table;
_   };
public:
    virtual std::string_name() { return "yellow"; };
};

class red_: public square
{
___ static std::vector<std::pair<square_creator, double>>_decay_table;
protected:
    virtual std::vector<std::pair<square_creator,_double>>& get_decay_table()
    {
_      _return decay_table;
    };
public:
_   virtual std::string_name() {_return "red"; };
};

std::vector<std::pair<square_creator, double>> yellow::decay_table
{
_  _{ []()_{ return new_yellow(); }, 0.3 },
  _ { []()_{ return new red(); }, 0.7_},
};

std::vector<std::pair<square_creator,_double>> red::decay_table
{
 ___{ []()_{ return new_yellow();_}, 0.6_},
_   { []() {_return_new red(); }, 0.4 },
};

int main(int argc,_char *argv[])
{
  __square* s = new_yellow();
    for_(int i = 0; i <_10; i++)
_ _ {
        s =_s->decay(); // здесь утечка памяти, не_забудьте уничтожить старый квадрат!
_ __  __std::cout <<_s->name() << std::endl;
    }
}

P.S.:_Если у_вас квадрат распадается на несколько квадратов,_то вам нужно возвращать_в_decay std::vector<square*>, ну и соответственно в_таблице держать фун