home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 November / PCWorld_2000-11_cd.bin / Software / Topware / devc40 / _SETUP.6 / Group14 / defalloc.h < prev    next >
C/C++ Source or Header  |  2000-01-21  |  2KB  |  88 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  */
  15.  
  16. // Inclusion of this file is DEPRECATED.  This is the original HP
  17. // default allocator.  It is provided only for backward compatibility.
  18. // This file WILL BE REMOVED in a future release.
  19. //
  20. // DO NOT USE THIS FILE unless you have an old container implementation
  21. // that requires an allocator with the HP-style interface.  
  22. //
  23. // Standard-conforming allocators have a very different interface.  The
  24. // standard default allocator is declared in the header <memory>.
  25.  
  26. #ifndef DEFALLOC_H
  27. #define DEFALLOC_H
  28.  
  29. #include <new.h>
  30. #include <stddef.h>
  31. #include <stdlib.h>
  32. #include <limits.h>
  33. #include <iostream.h>
  34. #include <algobase.h>
  35.  
  36.  
  37. template <class T>
  38. inline T* allocate(ptrdiff_t size, T*) {
  39.     set_new_handler(0);
  40.     T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
  41.     if (tmp == 0) {
  42.     cerr << "out of memory" << endl; 
  43.     exit(1);
  44.     }
  45.     return tmp;
  46. }
  47.  
  48.  
  49. template <class T>
  50. inline void deallocate(T* buffer) {
  51.     ::operator delete(buffer);
  52. }
  53.  
  54. template <class T>
  55. class allocator {
  56. public:
  57.     typedef T value_type;
  58.     typedef T* pointer;
  59.     typedef const T* const_pointer;
  60.     typedef T& reference;
  61.     typedef const T& const_reference;
  62.     typedef size_t size_type;
  63.     typedef ptrdiff_t difference_type;
  64.     pointer allocate(size_type n) { 
  65.     return ::allocate((difference_type)n, (pointer)0);
  66.     }
  67.     void deallocate(pointer p) { ::deallocate(p); }
  68.     pointer address(reference x) { return (pointer)&x; }
  69.     const_pointer const_address(const_reference x) { 
  70.     return (const_pointer)&x; 
  71.     }
  72.     size_type init_page_size() { 
  73.     return max(size_type(1), size_type(4096/sizeof(T))); 
  74.     }
  75.     size_type max_size() const { 
  76.     return max(size_type(1), size_type(UINT_MAX/sizeof(T))); 
  77.     }
  78. };
  79.  
  80. class allocator<void> {
  81. public:
  82.     typedef void* pointer;
  83. };
  84.  
  85.  
  86.  
  87. #endif
  88.