home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classes.lha / Classes / DataStructures / GenArray.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-31  |  2.0 KB  |  75 lines
  1. #ifndef CPP_DATASTRUCTURES_GENARRAY_H
  2. #define CPP_DATASTRUCTURES_GENARRAY_H
  3.  
  4. // Eine (sehr) generische Array Klasse für dynamische Arrays und
  5. // ein daraus abgeleitetes template array.
  6. //
  7. // In diesem Array dürfen nur Elemente liegen, die mit memcpy()
  8. // kopiert werden können (d.h. keine Objekte mit einem eigenen
  9. // Kopierkonstruktor).
  10. //
  11. // Die Vergrößerungsstrategie ist simpel:
  12. //   Entweder wird die Arraygröße verdoppelt, oder, falls der
  13. //   benötigte Index größer als die alte doppelte Größe ist,
  14. //   das Array gerade so groß gemacht, daß der Index im Array
  15. //   liegt.
  16. //
  17. // Fehlender Speicher wird komplett über Ausnahmen (MemoryX) behandelt.
  18. //
  19. // Autor: Jochen Becher
  20. //
  21. // Historie:
  22. // Version 1.0, am 25. Juni 94
  23. //
  24.  
  25. #ifndef EXEC_TYPES_H
  26. #include <exec/types.h>
  27. #endif
  28.  
  29. #ifndef CPP_EXCEPTIONS_EXCEPTIONS_H
  30. #include <classes/exceptions/exceptions.h>
  31. #endif
  32.  
  33. class gen_array {
  34. public:
  35.     // 'es' bezeichnet die Größe der Einträge (sizeof())
  36.      // 's' gibt eine Vorgabe für die Größe des Arrays
  37.     gen_array(ULONG es, ULONG s = 16) throw (MemoryX);
  38.     gen_array(const gen_array &) throw (MemoryX);
  39.     gen_array &operator= (const gen_array &) throw (MemoryX);
  40.     ~gen_array();
  41.     operator APTR () const { return (APTR) v; };
  42.     ULONG esize() const { return element_size; };
  43.     ULONG count() const { return size; };
  44.     // die Referenz muß auf den passenden Typ gecastet werden
  45.     VOID & operator[] (ULONG i) throw (MemoryX);
  46.     // die Anzahl der Feldelemente, der größte Index auf den ohne
  47.     // Feldvergrößerung zugegriffen werden kann ist somit count-1
  48. private:
  49.     VOID extend(ULONG) throw (MemoryX);
  50.     UBYTE *v;
  51.     ULONG element_size;
  52.     ULONG size;
  53. };
  54.  
  55. template <class T> class array : private gen_array {
  56. public:
  57.     array(ULONG s = 16) throw (MemoryX);
  58.     ULONG count() const { return gen_array::count(); };
  59.     T &operator[] (ULONG i)  throw (MemoryX);
  60. };
  61.  
  62. // *************************************************************
  63.  
  64. template <class T> array<T>::array(ULONG s)
  65.     : gen_array(sizeof(T),s)
  66. {
  67. }
  68.  
  69. template <class T> T &array<T>::operator[] (ULONG i)
  70. {
  71.     return (T &) gen_array::operator[] (i);
  72. }
  73.  
  74. #endif
  75.