1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright (C) 2004 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_MEMORY_MANAGER_KERNEl_ABSTRACT_
#ifdef DLIB_MEMORY_MANAGER_KERNEl_ABSTRACT_
#include "../algs.h"
namespace dlib
{
template <
typename T
>
class memory_manager
{
/*!
REQUIREMENTS ON T
T must have a default constructor.
INITIAL VALUE
get_number_of_allocations() == 0
WHAT THIS OBJECT REPRESENTS
This object represents some kind of memory manager or memory pool.
!*/
public:
typedef T type;
template <typename U>
struct rebind {
typedef memory_manager<U> other;
};
memory_manager(
);
/*!
ensures
- #*this is properly initialized
throws
- std::bad_alloc
!*/
virtual ~memory_manager(
);
/*!
ensures
- if (get_number_of_allocations() == 0) then
- all resources associated with *this have been released.
- else
- The memory still allocated will not be deleted and this
causes a memory leak.
!*/
size_t get_number_of_allocations (
) const;
/*!
ensures
- returns the current number of outstanding allocations
!*/
T* allocate (
);
/*!
ensures
- allocates a new object of type T and returns a pointer to it.
- #get_number_of_allocations() == get_number_of_allocations() + 1
throws
- std::bad_alloc or any exception thrown by T's constructor.
If this exception is thrown then the call to allocate()
has no effect on #*this.
!*/
void deallocate (
T* item
);
/*!
requires
- item == is a pointer to memory that was obtained from a call to
this->allocate(). (i.e. you can't deallocate a pointer you
got from a different memory_manager instance.)
- the memory pointed to by item hasn't already been deallocated.
ensures
- deallocates the object pointed to by item
- #get_number_of_allocations() == get_number_of_allocations() - 1
!*/
T* allocate_array (
size_t size
);
/*!
ensures
- allocates a new array of size objects of type T and returns a
pointer to it.
- #get_number_of_allocations() == get_number_of_allocations() + 1
throws
- std::bad_alloc or any exception thrown by T's constructor.
If this exception is thrown then the call to allocate()
has no effect on #*this.
!*/
void deallocate_array (
T* item
);
/*!
requires
- item == is a pointer to memory that was obtained from a call to
this->allocate_array(). (i.e. you can't deallocate a pointer you
got from a different memory_manager instance and it must be an
array.)
- the memory pointed to by item hasn't already been deallocated.
ensures
- deallocates the array pointed to by item
- #get_number_of_allocations() == get_number_of_allocations() - 1
!*/
void swap (
memory_manager& item
);
/*!
ensures
- swaps *this and item
!*/
private:
// restricted functions
memory_manager(memory_manager&); // copy constructor
memory_manager& operator=(memory_manager&); // assignment operator
};
template <
typename T
>
inline void swap (
memory_manager<T>& a,
memory_manager<T>& b
) { a.swap(b); }
/*!
provides a global swap function
!*/
}
#endif // DLIB_MEMORY_MANAGER_KERNEl_ABSTRACT_
|
