C++ - Struktura "sfiduese"

[Neritan Hyso]

Duke lexuar nje header (*.h) fare te vogel qe shkarkova ne internet, ndesha ne nje konstrukt ne dukje te thjeshte (4 - 5 rreshta C++) ne te cilin perdoren vetem 4 C++ keywords (struct, template, typename dhe typedef), por qe mua me hengri mbi 5 minuta per ta kuptuar (qe duke pasur parasysh se i gjithe kodi rroket me nje shikim, eshte vertete shume)

// If T has a typedef _CreatorClass, Derived would pick it from its base.
// If T does not define _CreatorClass, the definition is picked from the next
// enclosing scope, which is ChooseCreatorClass::_CreatorClass, or Default

template 
struct ChooseCreatorClass
{
    typedef Default _CreatorClass;
    struct Derived : private T
    {
        typedef _CreatorClass CreatorClass;
    };
    typedef typename Derived::CreatorClass CreatorClass;
};

Ne fakt e vetmja gje qe nuk arrija te kuptoja (ne veshtrim te pare) ishte ekzistenca e struktures se brendshme - arsyeja e vetme e ekzistences se saj eshte nje typedef, por perse valle ky typedef kishte nevoje te futej brenda nje strukture?

Une nuk po i jap pergjigje kesaj pyetje qe tani, per t'i lene kohe kujtdo qe ka deshire te jape pergjigjen e tij.

Shenim: Fragmenti qe paraqita eshte i plote, pra i gjithe shpjegimi eshte aty, madje komentet ne Anglisht (te autorit) e "shprehin" qellimin.

[edspace]

Interesant kodi më lart. Më dha mundësinë të freskoja (dhe zgjeroja) njohuritë e C++. Pasi e studiova për disa minuta arrita ta kuptoja se çfarë po mundohet të bëjë programuesi.

Siç e shpjegojnë dhe komentet, qëllimi i ChooseCreatorClass është që të zgjedhë midis tipit _CreatorClass që përmbahet brënda tipit T dhe tipit të parazgjedhur, Default. Pra, nëse tipi T nuk përmban _CreatorClass, atëherë ChooseCreatorClass përdor tipin Default.

Për ata që dinë Java, kjo do ishte e thjeshtë duke përdorur reflektimet (reflection), por C++ nuk ka reflektime, kështu që autori ka shkruajtur kodin e koklavitur më sipër i cili shfrytëzon rregullat e shtrirjeve (scope) për të zgjedhur _CreatorClass e duhur.


Shtrati Global::
Krijojmë një shabllon me dy parametra, tipin T dhe tipin Default (i parazgjedhur).
template
struct ChooseCreatorClass
{

Shtrati Global::ChooseCreatorClass
Riemërtojmë tipin Default si _CreatorClass, i njëjti emër me tipin që përmban parametri T. Pra, krijojmë ChooseCreatorClass::_CreatorClass;
typedef Default _CreatorClass;

Këtu krijojmë një tip që trashëgon nga tipi T me qëllim që të hyjmë në shtratin (scope) të tipit T. Pra, duam të kontrollojmë nësë ekziston T::_CreatorClass.
struct Derived : private T
{

Shtrati Global::ChooseCreatorClass::T::Derived
Riemërtojmë tipin _CreatorClass si CreatorClass. Këtu ndodh e gjithë magjia, sepse si rregull, nëse C++ nuk gjen tipin _CreatorClass në shtratin e brëndshëm, duhet të kërkojë atë në shtratin e jashtëm. Nëse nuk e gjen as aty, duhet të kërkojë në shtratin tjetër më të jashtëm, e kështu me radhë deri sa arrin në shtratin Global. Nëse nuk gjendet as aty, përpiluesi nxjerr gabim. Konkretisht, në këtë rast C++ do kontrollojë më parë shtratin Global::ChooseCreatorClass::T::Derived, pastaj Global::ChooseCreatorClass::T, pastaj Global::ChooseCreatorClass, pastaj Global. Pra, nëse T::_CreatorClass nuk ekziston, atëherë C++ do përdorë ChooseCreatorClass::_CreatorClass të cilin e krijuam më lart si emërtim të tipit Default.
typedef _CreatorClass CreatorClass;

};

Tashmë, Derived:CreatorClass përmban tipin e duhur, por e riemërtojmë vetëm si CreatorClass me qëllim që të fshehim ndihmësin Derived.
typedef typename Derived::CreatorClass CreatorClass;

};

Këtu kemi arritur përsëri në shtratin Global:: dhe mund të përdorim ChooseCreatorClass::CreatorClass ku T dhe Default janë parametrat.


Më poshtë po hedh një shembull që vë në provë shpjegimin më lart.

#include <iostream>
#include <string>

using namespace std;

class KlasaSakte {
public:
  string merrPergjigjen() {
    return "Klasa e sakte";
  }
};

class KlasaMeKlasenSakte {
public:
  typedef KlasaSakte _CreatorClass;
};

class KlasaPaKlasenSakte {};


class KlasaParazgjedhur {
public:
  string merrPergjigjen() {
    return "Klasa e parazgjedhur";
  }
};


template <typename T, typename Default>
struct ChooseCreatorClass
{
    typedef Default _CreatorClass;
    struct Derived : private T
    {
        typedef _CreatorClass CreatorClass;
    };
    typedef typename Derived::CreatorClass CreatorClass;
};


int main(int argc, char *argv[])
{

    // kjo duhet të nxjerrë "Klasa e sakte"
    ChooseCreatorClass<KlasaMeKlasenSakte, KlasaParazgjedhur>::CreatorClass sh1;
    cout << sh1.merrPergjigjen() << endl;

    // kjo duhet të nxjerrë "Klasa e parazgjedhur"
    ChooseCreatorClass<KlasaPaKlasenSakte, KlasaParazgjedhur>::CreatorClass sh2;
    cout << sh2.merrPergjigjen() << endl;
    
    cin.get();
    return EXIT_SUCCESS;
} 

Në Microsoft C++ programi punon siç duhet dhe nxjerr përgjigjen e saktë:

Klasa e sakte
Klasa e parazgjedhur

ndërsa Dev-C++ (gcc 3.4.2) nxjerr përgjigje të gabuar:

Klasa e parazgjedhur
Klasa e parazgjedhur

[edspace]

Sipas Google Code Search, kodi i përket PassThruAppBeta
http://www.google.com/codesearch?hl=...=/ProtocolCF.h

[qoska]

veshtiresia e vetme qe shoh une ketu eshte deklarimi i struktures, me sa shoh une(jo se jam aq ekspert ne C++ per "metadata transaltion dhe factory code") eshte vetem per te evituar "namespace collision" brenda klases(Per te mos ngaterruar kompilatorin ne dy tupe te njejte me emer te ndryshem).

Me thoni ne e kam gabim.

[Neritan Hyso]

Interpretimi i edspace eshte i sakte (madje edhe investigimi i source-code).

Une nuk e njoh Javen, dhe nuk e di se sa e thjeshte eshte kjo gje ne te, gjithesesi per mendimin tim (subjektiv) nuk me duket nje zgjidhje e koklavitur.

int v = 3;

{
float v = 7.5f;
};

Ne fragmentin mesiper, variabli v i tipit float (brenda kllapave gjarperueshe) e "fsheh" variablin e jashtem v (te tipit int). Ky fragment nuk eshte as i gabuar, as i "rrezikshem" per kompilatorin, e aq me pak i veshtire.

Ajo qe ma beri mua te veshtire leximin e struktures, ishte fakti se ndersa rregullat lidhur me "name scope" gjate deklarimit te variablave i kisha ndeshur shpesh here, dhe i mbaja mend, me sa duket me kishte shpetuar fakti qe te njejtat rregulla vlejne edhe per typedef. Si lexova doc mbi typedef ne MSDN, gjithcka u be e thjeshte. Nese tipi T definon tipin _CreatorClass (permes typedef), ky ka per ta "fshehur" definimin e meparshem (te jashtem) typedef Default _CreatorClass - duke ofruar efektivisht "inteligjence permes deklarimeve" - dicka shume simpatike per mendimin tim.
Mesazhi i edspace e shpjegon ne detaje procesin.

[edspace]

Kodi më poshtë në Java bën të njëjtën gjë si kodi më lart në C++.

ProveMeReflektimet.java

public class ProveMeReflektimet {

  class KlasaMeKlasenSakte {
    class KlasaSakte {};
  }
  
  class KlasaPaKlasenSakte{}; 
  class KlasaParazgjedhur{}

  // Kthen T::"nenKlasa" nese ekziston. Ne te kundert kthen parazgjedhur.
  public static Class zgjidhKlasen(String nenKlasa, 
                                   Class T, 
                                   Class parazgjedhur) {
    
    for (Class klasaNenT : T.getDeclaredClasses()) {
      if (nenKlasa.equals(klasaNenT.getSimpleName())) {
        return klasaNenT; 
      }
    } 
    
    return parazgjedhur;
  }
  
  public static void main(String[] args) {
    
    // Kjo zgjedh KlasaMeKlasenSakte::KlasaSakte
    System.out.println(   
        zgjidhKlasen("KlasaSakte", 
                     KlasaMeKlasenSakte.class, 
                     KlasaParazgjedhur.class).getSimpleName() );

    // Kjo zgjedh klasen e parazgjedhur
    System.out.println(   
        zgjidhKlasen("KlasaSakte", 
                     KlasaPaKlasenSakte.class, 
                     KlasaParazgjedhur.class).getSimpleName() );
  }

} 

Rezultati:

KlasaSakte
KlasaParazgjedhur