home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / DynArray.h < prev    next >
C/C++ Source or Header  |  1998-08-01  |  4KB  |  167 lines
  1. // $Id: DynArray.h,v 1.9 1998/08/01 13:13:42 zeller Exp $  -*- C++ -*-
  2. // Dynamic array -- generates the referenced entries
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of the ICE Library.
  8. // 
  9. // The ICE Library is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU Library General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // The ICE Library is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU Library General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU Library General Public
  20. // License along with the ICE Library -- see the file COPYING.LIB.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // ICE is the incremental configuration environment.
  25. // For details, see the ICE World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ice/',
  27. // or send a mail to the ICE developers <ice@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _ICE_DynArray_h
  30. #define _ICE_DynArray_h
  31.  
  32. #if defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 5)
  33. #pragma interface
  34. #endif
  35.  
  36. #include "assert.h"
  37. #include "bool.h"
  38.  
  39. // A DynArray acts like an ordinary array,
  40. // but it automatically expands to hold the referenced entry.
  41. // Thus, if you say DynArray<int> d; d[100] = 10,
  42. // it automatically expands to 100 elements.
  43. // Note that a const DynArray will not grow.
  44.  
  45. // If you prefer sparse storage, see the Assoc template.
  46.  
  47. template<class T>
  48. class DynArray {
  49. private:
  50.     int _allocated_size;        // size of _values
  51.     T *_values;            // values
  52.  
  53.     static int max(int a, int b) { return (a > b) ? a : b; }
  54.  
  55.     // Grow by half the current size, at least to new_size_min
  56.     void grow(int new_size_min = 0)
  57.     {
  58.     int new_size = max(_allocated_size + _allocated_size / 2 + 1, 
  59.                new_size_min);
  60.     T *new_values = new T [new_size];
  61.         for (int i = 0; i < _allocated_size; i++)
  62.             new_values[i] = _values[i];
  63.  
  64.         delete[] _values;
  65.         _values         = new_values;
  66.         _allocated_size = new_size;
  67.     }
  68.  
  69. protected:
  70.     T& value(int i)
  71.     {
  72.     assert(i >= 0);
  73.     if (i >= _allocated_size)
  74.         grow(i + 1);
  75.     return _values[i];
  76.     }
  77.     T& _value(int i) const  
  78.     { 
  79.     assert(i >= 0 && i < size());
  80.     return _values[i]; 
  81.     }
  82.  
  83. public:
  84.     // Resources
  85.     virtual int size() const   { return _allocated_size; }
  86.     T& operator[](int i) const { return _value(i); }
  87.     T& operator[](int i)       { return value(i); }
  88.     T* values() const          { return _values; }
  89.     operator const T*() const  { return values(); }
  90.     operator       T*() const  { return values(); }
  91.  
  92.     // Constructors
  93.     DynArray(int initial_size = 0):
  94.         _allocated_size(initial_size),
  95.         _values(new T [initial_size])
  96.     {}
  97.  
  98.     DynArray(T *v, int n):
  99.         _allocated_size(n),
  100.         _values(new T [n])
  101.     {
  102.         for (int i = 0; i < n; i++)
  103.             _values[i] = v[i];
  104.     }
  105.  
  106.     // Copy constructor
  107.     DynArray(const DynArray<T>& m):
  108.         _allocated_size(m.size()),
  109.         _values(new T [m.size()])
  110.     {
  111.         for (int i = 0; i < _allocated_size; i++)
  112.             _values[i] = m._values[i];
  113.     }
  114.  
  115.     // Destructor
  116.     virtual ~DynArray()
  117.     {
  118.     delete[] _values;
  119.     }
  120.  
  121.     // Assignment
  122.     DynArray<T>& operator = (const DynArray<T>& m)
  123.     {
  124.         // Make sure self-assignment A = A works
  125.     if (this != &m)
  126.     {
  127.         T *old_values = _values;
  128.  
  129.         _allocated_size = m.size();
  130.         _values = new T [_allocated_size];
  131.         
  132.         for (int i = 0; i < m.size(); i++)
  133.         _values[i] = m._values[i];
  134.  
  135.         delete[] old_values;
  136.     }
  137.  
  138.     return *this;
  139.     }
  140.  
  141.     // Comparison
  142.     bool operator == (const DynArray<T>& m)
  143.     {
  144.     if (this == &m)
  145.         return true;    // THIS == THIS
  146.  
  147.     if (size() != m.size())
  148.         return false;
  149.  
  150.     for (int i = size() - 1; i >= 0; i--)
  151.     {
  152.         if (!(_values[i] == m._values[i]))
  153.         return false;
  154.     }
  155.  
  156.     return true;
  157.     }
  158.  
  159.     bool operator != (const DynArray<T>& m)
  160.     {
  161.     return !(operator == (m));
  162.     }
  163. };    
  164.  
  165. #endif // _ICE_DynArray_h
  166. // DON'T ADD ANYTHING BEHIND THIS #endif
  167.