Dnes sa podelím s návrhom vzoru, ktorý som navrhol pre univerzálne používanie funkcií, čo mi pri tvorbe projektov chýbalo.
 

Návrhový vzor som pomenoval ako INIT Pattern a ako je už z názvu očividné, pôjde o modul zavádzania funkcií a prácou s nimi.
U modulu budene používať explicitné konštruktory a volanie objektov cez referencie.

V teoretickej rovine si predstavte inicializáciu 10 funkcií rôzných vydavateľov s rôznými parametrami ktorých výsledky potrebujeme medzi sebov posúvať.

Ďalej si predstavte množinu funkcií, ktorá obsahuje 1500 prvkov. Hovoríme napríklad o neuronových sietiach. Ako vymyslíme modul, ktorý by jednotlivé výsledky x inicializovaných funkcií ukladal pre použitie iných funkcií, zároveň by umožňoval ich inicializovanie, detekciu a podobne?

Tú istú otázku som si položil aj ja pri tvorbe komunikácie medzi jednotlivými množinami funkcií a rozhodol som sa vytvoriť inicializačný vzor.


Návrhový vzor vypadá následovne:

   #ifndef _IntPtrn_H
       #define _IntPtrn_H
   #endif

   #ifdef MAX_VALUE_NAME
       #define MAX_BUFFER MAX_VALUE_NAME
   #else
       #define MAX_BUFFER 16383
   #endif


   class InitPaternW {

   public:
       bool isinitstatus;

   private:
       ::UINT tmpresult;
       ::UINT *result_array[MAX_BUFFER];
       bool instanceflag;
       static InitPaternW instance;
       bool (*startadress)(...);
       bool (*startadress_ptr[MAX_BUFFER])(::UINT,...);
       bool initstatus;
       int size;

   public:
       explicit InitPaternW(bool(*func_ptr[])(::UINT,...), int size)
       {
           *this->startadress_ptr = *func_ptr;
           this->size = size;

            /*
           Deklaracia moznych premennych pre masovu 
            inicializaciu funkcii v poli.
           Vyhodou je moznost nastavit prenasanie vysledku 
            inicializacie medzi jednotlivymi inicializovanymi 
            funkciami, a to od prvej po poslednu. 
           Pri inite funkcie A, ktora skonci neuspechom sa napr. 
            init funkcie B nevykona a preskoci sa na init funkcie C.
           */

           if(this->initstatus == true)
           {   
               this->isinitstatus = true;
           }
       };

       explicit InitPaternW(bool(*functionadress)(...))
       {
           this->startadress = functionadress;
           this->size = 0;
       };

       explicit InitPaternW(void)
       {
           this->instanceflag = true;
           this->initstatus = false;
           this->isinitstatus = false;
           this->tmpresult = 0;
           this->size = 0;
       };

       bool Start(InitPaternW & init)
       {
           return init.InitMe();
       };

   private:
       bool InitMe(void)
       {
           if(this->instanceflag != true)
           {
               if(this->size>0)
               {
                   for(int i=0; i<this->size; í++)
                   {
                       this->tmpresult = this->startadress_ptr[i](this->result_array[i] = this->tmpresult;
               } else {
                          this->startadress();
                      }
               return true;
           }
           return false;
       };

   };

   InitPaternW * InitPatern = new InitPaternW();
 

Príklad vyvolávania funkcií:

   #include "init_pattern.h" 


   bool Function_A(...)
   {
       ::std::cout << "Im Here _A";
       return 0;
   }

   bool Function_B(...)
   {
       ::std::cout << "Im Here _B";
       return 0;
   }



   int main(void)
   {

      /* Spustanie #1 : */

       InitPatern->Start(InitPaternW(Function_A));

       InitPatern->Start(InitPaternW(Function_B));


        /* Spustanie #2 : */

        bool (*func_ptr[])(...) = {Funkcia_A, Funkcia_B}
;
        InitPatern->Start(InitPaternW(func_ptr, sizeof(func_ptr)/sizeof(bool)));


   return 0 

   }

​