
-info- -----------------------------------------------------------------------------------------------
-info- Dit document is automatisch gegenereerd uit source 'harray.hxx' met 
-info- behulp van de documentatietool 'doc', versie 3.01.
-info- -----------------------------------------------------------------------------------------------



-doc-Algemeen
   library : libeasy.a
   module  : harray
   include : harray.hxx
   link    : -leasy
  
   Versie Wie              Datum       Wijziging/Opdracht/Omschrijving
   --------------------------------------------------------------------------
   1.00   HNM Dijkema      27-12-1999  Algemeen bruikbare library ten behoeve
                                       van C++ projecten.
-h2- Revisies
   Versie Revisieinformatie
   --------------------------------------------------------------------------
   1.00   Initiele versie
  

-h1- Classes en functies

-h2- template <class T> class harray
  
   class harray implementeert een generieke array class, welke
   als een normale array benaderd kan worden, maar zichzelf automatisch
   aanpast aan de indexering. Met andere woorden, van te voren hoeft
   de grootte van de array niet aangegeven te worden. Tijdens het
   gebruik groeit de array vanzelf.
  
   Verder is er extra functionaliteit in de vorm van een insert
   en een remove functie (zie verderop).
  
   hsarray<T> doet hetzelfde als harray<T>, maar is efficienter met
   simple types, zoals pointers, integers en doubles. Gebruik hsarray<T>
   altijd, indien T <- {t *,int,double,long,float,enum...,char,char *}.
   Bij structures/classes moet worden afgewogen in hoeverre dit nodig is.
  

-mem-Public members
-def-
    harray() 
  
      pre : -
      post: er is een lege array geconstrueerd.

-def-
   ~harray() 
  
      pre : 
      post: de array is opgeruimd.
      opm.:
  
      Indien er een array wordt geconstrueerd van pointers, dan
      dienen de array elementen (indien nodig) voor het opruimen
      van de array opgeruimd te worden. Bijvoorbeeld:
  
      int main()
      { harray<char *> A;
        char *s,num[10];
        int i,N;
           for(i=0;i<20;i++) {
             sprintf(num,"%d",i);
             s=strdup(num);
             A[i]=s;		// of A[i]=strdup(num);
           }
           ...
           for(i=0,N=A.len();i<N;i++) { delete A[i]; }
      }

-mem-Public members
-def-
    int len(void) 	
    int length(void) 	
  
      pre : -
      post: =huidige lengte van de array

-mem-Public members
-def-
    void operator =(harray<T> & A) 
  
      pre : A is een bestaande array.
      post: A is gekopieerd in deze array; d.w.z.
            for(i=0;i<A.len();i++) { (*this)[i]=A[i]; }
      opm.:
  
         Indien A[i] pointers bevat, zoals boven beschreven,
         dan wordt daarvan dus geen kopie gemaakt! Wel van de
         pointers zelf, maar niet van het geheugen waar ze naar
         wijzen.

-mem-Public members
-def-
    void insert(int I,T & v) 
  
      pre: I>=0 en v is een valide variabele T
      post: op positie I is v geinsert. Alle elementen van positie
            I t/m len() zijn 1 plaats opgeschoven en len() is len()
            +1.

-mem-Public members
-def-
    T & operator [](int i) 
  
      pre:  i>=0
      post: Element i van de array is gealloceerd en 
            een reference naar het element is teruggegeven.
      opm.: Het teruggeven van een reference maakt zowel de constructie 
            A[i]=10 als de constructie S=A[i] mogelijk.

-mem-Public members
-def-
    void initialize(void)   
    void reinitialize(void) 
  
      pre : -
      post: de array is opgeruimd.
      opm.: Hiervoor geldt dezelfde opmerking als bij ~harray().

-h2- template <class T> class hsarray
   class hsarray, doet hetzelfde als harray, maar moet gebruikt
   worden voor eenvoudige types, zoals kleine structs, int's, double's,
   en pointers. Daarvoor is deze class veel efficienter dan harray.

-mem-Public members
-def-
    hsarray() 
  
      pre : -
      post: er is een lege array geconstrueerd.

-def-
   ~hsarray() 
  
      pre : 
      post: de array is opgeruimd.
      opm.:
  
      Indien er een array wordt geconstrueerd van pointers, dan
      dienen de array elementen (indien nodig) voor het opruimen
      van de array opgeruimd te worden. Bijvoorbeeld:
  
      int main()
      { hsarray<char *> A;
        char *s,num[10];
        int i,N;
           for(i=0;i<20;i++) {
             sprintf(num,"%d",i);
             s=strdup(num);
             A[i]=s;		// of A[i]=strdup(num);
           }
           ...
           for(i=0,N=A.len();i<N;i++) { delete A[i]; }
      }

-mem-Public members
-def-
    int len(void) 	
    int length(void) 	
  
      pre : -
      post: =huidige lengte van de array

-mem-Public members
-def-
    void operator =(hsarray<T> & A) 
  
      pre : A is een bestaande array.
      post: A is gekopieerd in deze array; d.w.z.
            for(i=0;i<A.len();i++) { (*this)[i]=A[i]; }
      opm.:
  
         Indien A[i] pointers bevat, zoals boven beschreven,
         dan wordt daarvan dus geen kopie gemaakt! Wel van de
         pointers zelf, maar niet van het geheugen waar ze naar
         wijzen.

-def-
    void operator =(harray<T> & A) 
  
      pre : A is een bestaande array.
      post: A is gekopieerd in deze array; d.w.z.
            for(i=0;i<A.len();i++) { (*this)[i]=A[i]; }
      opm.:
  
         Indien A[i] pointers bevat, zoals boven beschreven,
         dan wordt daarvan dus geen kopie gemaakt! Wel van de
         pointers zelf, maar niet van het geheugen waar ze naar
         wijzen.

-mem-Public members
-def-
    void insert(int I,T & v) 
  
      pre: I>=0 en v is een valide variabele T
      post: op positie I is v geinsert. Alle elementen van positie
            I t/m len() zijn 1 plaats opgeschoven en len() is len()
            +1.

-mem-Public members
-def-
    T & operator [](int i) 
  
      pre:  i>=0
      post: Element i van de array is gealloceerd en 
            een reference naar het element is teruggegeven.
      opm.: Het teruggeven van een reference maakt zowel de constructie 
            A[i]=10 als de constructie S=A[i] mogelijk.

-mem-Public members
-def-
    void initialize(void)   
    void reinitialize(void) 
  
      pre : -
      post: de array is opgeruimd.
      opm.: Hiervoor geldt dezelfde opmerking als bij ~harray().

-h2- template <class T> class hstack : protected harray<T>
   class hstack implementeert een stapel met gebruik van harray.
  
-h3- Voorbeelden van gebruik:
     int main()
     { hstack<int> S;
       int i;
          for(i=0;i<10;i++) { S.push(i); }
          while(S.depth()!=0) {
            for(i=0;i<S.depth();i++) { printf("%d\n",S[i]); }
            S.pop(i);
          }
     }
  

-mem-Public members
-def-
    void pop(T & e) 
  
     pre:  er is een element op de stapel gepushed.
     post: e=het 1e element van de stapel en de stapel is
           1 element kleiner.

-def-
    void push(T & e) 
  
      pre:  -
      post: element e is op de stapel gepushed.

-mem-Public members
-def-
    T & operator [](int i) 
  
      pre:  er zijn elementen op de stapel en 0<=i<depth()
      post: =het i'de element van de stapel.
      opm.: Deze functie maakt het mogelijk om elementen van
            de stapel op te vragen en evt. te veranderen, zonder
            ze van de stapel af te halen.

-mem-Public members
-def-
    int depth(void) 
  
      pre:  -
      post: =het aantal elementen op de stapel.

-h1- Verwijzingen
      n.v.t.

-h1- Gegevensbenadering
      n.v.t.

-h1- Voorbeeld programma(s)
-h2- harray/hsarray
  
     #include <harray.hxx>
     #include <stdio.h>
     #include <string.hxx>
     
     void f(void);
  
     int main()
     {
      hsarray<int> int_array;  // simple typed array
      int i;
         for(i=0;i<100;i++) { int_array[i]=i*i; }
         for(i=0;i<100;i++) { printf("%d %d\n",i,int_array[i]); }
         f();
     }
  
     void f(void)
     {
      string w="A";
      harray<string> A;
      int i;
         for(i=0;i<10;i++) { 
           A[i]=w;
           w=w+w;
         }
     }


