Függvénytömb, feltételtömb c++

C/C++

Sziasztok!

Van egy

while(1)
{
if(feltetel_1){
fv_1();
}else if(feltetel_2){
fv_2();
}else if(feltetel_3){
...
}
else{
fv_n();
}
}

vagy ha tetszik, akkor case elagazas, amelyeben a felteteleket es
a fuggvenyeket dinamikusan cserelgetni kellene.
Mindig mast kellene hogy kiprobaljon minden iteracioban.

Meg a fveket meg tudnam csinalni, ugye fvekre mutato pointereket
tartalmazo tomb.

De a felteteleket hogyan cserelgessem?
Azokat hogy rakjam tombbe?

Tamas

  • 1871 megtekintés

( tr3w v | 2007. 04. 06., p – 18:05 )

Minden feltételt rakj külön fv-be.
Ha C++, akkor: bool felt_1();
Ha C, akkor: int felt_1();

Ezeket már tömbbe rakhatod, és cserélgetheted.
Jobb ötletem (ennyi infó alapján) nincs.

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee."
-- Ted Ts'o

függvény objektum?

csinálsz egy

class func
{
public:
func();
~func();
virtual void fn();
virtual bool felt();
}; -t és ebből származtatod az egyes függvényeknek megfelelő osztályokat, ahol megvalósítod az fn() és felt()
függvényeket, ezekből tudsz az ősosztály miatt tömböt csinálni, és minden tömb beli elemnek lesz fn() és felt() függvénye, és mindegyik mást csinál

Ezzel annyi a gond, hogy nem tudjuk, hogy C, vagy C++-ban kell.

Illetve, én úgy értelmeztem a leírást, hogy a feltételeket és a fv-eket egymástól függetlenül lehet keverni.

Egyébként a függvény objektum kifejezés már foglalt, ezt tehát nevezzük máshogy. :)

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee."
-- Ted Ts'o

class Condition {
virtual bool operator() = 0;
virtual ~Condition() {};
}

class Function {
virtual void operator() = 0;
virtual ~Condition() {};
}

Ezekből származtatsz, pl.

Condition *felt = ...
Function * fv = ...

if (felt()) {
fv()
}

stb.

Ezáltal teljesen független lesz a kettő egymástól :)

( apal v | 2007. 04. 06., p – 23:24 )

Hm, hat nem latom hogy tul specifikalt lenne a problema, de c-ben igy csinalnam: 


typedef struct
{
 int    n;
 int    (*funct)(void *param);
} idfunct;

...
int fv_1(void *param)
{
...
}


idfunct functlist[] =
 {  { 1 , fv_1 } ,
    { 2,  fv_2 } ,
    { 3,  fv_3 } ,
    ...
   { -1, NULL }
 }

...

idfunct *w;
for ( w=functlist ; w->funct != NULL ; w++ )
 {   if ( w->id == N )
      {     ret=w->funct(param); 
            break;
      }
 }
if ( w->funct==NULL )
     default_case();

marmint akkor, ha a "feltetel" tenyleg helyettesitheto" egy ege'sz sza'mmal valo' osszehasonlitassal. ha nem, akkor 


typedef struct
{
 int    (*condition)(void *param);
 int    (*funct)(void *param);
} condfunct;

idfunct functlist[] =
 {  { cnd_1 , fv_1 } ,
    { cnd_2,  fv_2 } ,
    { cnd_3,  fv_3 } ,
    ...
   {  NULL, NULL }
 }

...

condfunct *w;
for ( w=functlist ; w->condition != NULL ; w++ )
 {   if ( w->condition(param) )
      {     ret=w->funct(param); 
            break;
      }
 }
if ( w->condition==NULL )
     default_case();

Az elso" esetet persze lehet optimalizalni, hogy a functlist[] eleve rendezett (az id-k szerint), e's a megfelelo" id-t egy bina'ris kerese'ssel keresed meg, akkor log(N) ido"ben megtalalja a kivant fv-t (vagy hash-tablaval, vagy btree-vel, vagy barmi egyebbel is lehet persze csinalni, csak az ma'r elegge bonya). Ilymodon a masodik esetet viszont nem lehet optimalizalni.

A.

( ngy_tms | 2007. 04. 29., v – 15:48 )

Sziasztok!

A következőt sikerült összehoznom: 


for(int k=0; k < szabalyhalmaz.size(); k++)
{        
      // feltetel        
      if(szabalyhalmaz[k].second.first(pp,sp))
      {
          for(int i=0; i < szabalyhalmaz[k].second.second.size(); i++ )
          {
                // cselekves
                szabalyhalmaz[k].second.second[i](pp,sp);
          }                    
      }                        
}

Egyetlen probléma van: ez
if()
if()
if()
alakú, nekem:
if()
else if()
else if()
else

alakú kellene.

Tamás

Az elágazás eleve úgy néz ki, hogy
if feltétel then valami
if feltétel2 then valami2
stb.

A programozási nyelvek általában ezt nem így oldják meg, hanem biztosítanak egy olyan szerkezetet, amelyik úgy működik, hogy ha az első nem teljesül, akkor megvizsgálja a második feltételt, stb.

Tehát az
if A then S1
else if B then S2
else if C then S3
else S4

valójában:
if A then S1
if not A and B then S2
stb. (bár ezt épp nem determinsztikus, a szokásos elágazás meg igen).

Akkor már inkább inkább: 


      if not A then goto :b
      S1
      goto :end
:b    if not B then goto :c
      S2
      goto :end
:c    if not C then goto :else
      S3
      goto :end
:else S4
:end

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee."
-- Ted Ts'o


for(int k=0; k < szabalyhalmaz.size(); k++)
{        
      // feltetel        
      if(szabalyhalmaz[k].second.first(pp,sp))
      {
          for(int i=0; i < szabalyhalmaz[k].second.second.size(); i++ )
          {
                // cselekves
                szabalyhalmaz[k].second.second[ i](pp,sp);
          }                    
          break;
      }                        
}

Így nem jó?
(Fogalmam nincs mi ez a rakás first/second cuccos, de te tudod. :) Esetleg bevezethetsz pár structot (vagy tuple esetleg).)

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee."
-- Ted Ts'o