41 #if !defined(__CAPtr_h__)
48 inline void* CA_malloc(
size_t size)
50 void* p = malloc(size);
51 if (!p && size)
throw std::bad_alloc();
55 inline void* CA_realloc(
void* old,
size_t size)
58 void* p = realloc(old, size);
60 void* p = reallocf(old, size);
62 if (!p && size)
throw std::bad_alloc();
68 #define UINTPTR_MAX 18446744073709551615ULL
70 #define UINTPTR_MAX 4294967295U
74 inline void* CA_calloc(
size_t n,
size_t size)
77 if (n && UINTPTR_MAX / n < size)
throw std::bad_alloc();
79 size_t nsize = n*size;
80 void* p = malloc(nsize);
81 if (!p && nsize)
throw std::bad_alloc();
94 explicit CAPtrRef(T* ptr) : ptr_(ptr) {}
105 CAAutoFree() : ptr_(0) {}
107 explicit CAAutoFree(T* ptr) : ptr_(ptr) {}
110 CAAutoFree(CAAutoFree<U>& that) : ptr_(that.release()) {}
113 CAAutoFree(CAAutoFree<T>& that) : ptr_(that.release()) {}
115 CAAutoFree(
size_t n,
bool clear =
false)
119 size_t maxItems = ~size_t(0) /
sizeof(T);
121 throw std::bad_alloc();
123 ptr_ =
static_cast<T*
>(clear ? CA_calloc(n,
sizeof(T)) : CA_malloc(n * sizeof(T)));
126 ~CAAutoFree() { free(); }
128 void alloc(
size_t numItems,
bool clear =
false)
130 size_t maxItems = ~size_t(0) /
sizeof(T);
131 if (numItems > maxItems)
throw std::bad_alloc();
134 ptr_ =
static_cast<T*
>(clear ? CA_calloc(numItems,
sizeof(T)) : CA_malloc(numItems * sizeof(T)));
137 void allocBytes(
size_t numBytes,
bool clear =
false)
140 ptr_ =
static_cast<T*
>(clear ? CA_calloc(1, numBytes) : CA_malloc(numBytes));
143 void reallocBytes(
size_t numBytes)
145 ptr_ =
static_cast<T*
>(CA_realloc(ptr_, numBytes));
148 void reallocItems(
size_t numItems)
150 size_t maxItems = ~size_t(0) /
sizeof(T);
151 if (numItems > maxItems)
throw std::bad_alloc();
153 ptr_ =
static_cast<T*
>(CA_realloc(ptr_, numItems *
sizeof(T)));
156 template <
typename U>
157 CAAutoFree& operator=(CAAutoFree<U>& that)
163 CAAutoFree& operator=(CAAutoFree& that)
169 CAAutoFree& operator=(T* ptr)
175 template <
typename U>
176 CAAutoFree& operator=(U* ptr)
182 T& operator*()
const {
return *ptr_; }
183 T* operator->()
const {
return ptr_; }
185 T* operator()()
const {
return ptr_; }
186 T*
get()
const {
return ptr_; }
187 operator T*()
const {
return ptr_; }
189 bool operator==(CAAutoFree
const& that)
const {
return ptr_ == that.ptr_; }
190 bool operator!=(CAAutoFree
const& that)
const {
return ptr_ != that.ptr_; }
191 bool operator==(T* ptr)
const {
return ptr_ == ptr; }
192 bool operator!=(T* ptr)
const {
return ptr_ != ptr; }
219 CAAutoFree(CAPtrRef<T> ref) : ptr_(ref.ptr_) { }
221 CAAutoFree& operator=(CAPtrRef<T> ref)
228 operator CAPtrRef<U>()
229 {
return CAPtrRef<U>(release()); }
232 operator CAAutoFree<U>()
233 {
return CAAutoFree<U>(release()); }
238 template <
typename T>
245 CAAutoDelete() : ptr_(0) {}
247 explicit CAAutoDelete(T* ptr) : ptr_(ptr) {}
250 CAAutoDelete(CAAutoDelete<U>& that) : ptr_(that.release()) {}
253 CAAutoDelete(CAAutoDelete<T>& that) : ptr_(that.release()) {}
255 ~CAAutoDelete() { free(); }
257 template <
typename U>
258 CAAutoDelete& operator=(CAAutoDelete<U>& that)
264 CAAutoDelete& operator=(CAAutoDelete& that)
270 CAAutoDelete& operator=(T* ptr)
276 template <
typename U>
277 CAAutoDelete& operator=(U* ptr)
283 T& operator*()
const {
return *ptr_; }
284 T* operator->()
const {
return ptr_; }
286 T* operator()()
const {
return ptr_; }
287 T*
get()
const {
return ptr_; }
288 operator T*()
const {
return ptr_; }
290 bool operator==(CAAutoDelete
const& that)
const {
return ptr_ == that.ptr_; }
291 bool operator!=(CAAutoDelete
const& that)
const {
return ptr_ != that.ptr_; }
292 bool operator==(T* ptr)
const {
return ptr_ == ptr; }
293 bool operator!=(T* ptr)
const {
return ptr_ != ptr; }
320 CAAutoDelete(CAPtrRef<T> ref) : ptr_(ref.ptr_) { }
322 CAAutoDelete& operator=(CAPtrRef<T> ref)
329 operator CAPtrRef<U>()
330 {
return CAPtrRef<U>(release()); }
333 operator CAAutoFree<U>()
334 {
return CAAutoFree<U>(release()); }
339 template <
typename T>
340 class CAAutoArrayDelete
346 CAAutoArrayDelete() : ptr_(0) {}
348 explicit CAAutoArrayDelete(T* ptr) : ptr_(ptr) {}
351 CAAutoArrayDelete(CAAutoArrayDelete<U>& that) : ptr_(that.release()) {}
354 CAAutoArrayDelete(CAAutoArrayDelete<T>& that) : ptr_(that.release()) {}
357 CAAutoArrayDelete(
size_t n) : ptr_(new T[n]) {}
359 ~CAAutoArrayDelete() { free(); }
361 void alloc(
size_t numItems)
364 ptr_ =
new T [numItems];
367 template <
typename U>
368 CAAutoArrayDelete& operator=(CAAutoArrayDelete<U>& that)
374 CAAutoArrayDelete& operator=(CAAutoArrayDelete& that)
380 CAAutoArrayDelete& operator=(T* ptr)
386 template <
typename U>
387 CAAutoArrayDelete& operator=(U* ptr)
393 T& operator*()
const {
return *ptr_; }
394 T* operator->()
const {
return ptr_; }
396 T* operator()()
const {
return ptr_; }
397 T*
get()
const {
return ptr_; }
398 operator T*()
const {
return ptr_; }
400 bool operator==(CAAutoArrayDelete
const& that)
const {
return ptr_ == that.ptr_; }
401 bool operator!=(CAAutoArrayDelete
const& that)
const {
return ptr_ != that.ptr_; }
402 bool operator==(T* ptr)
const {
return ptr_ == ptr; }
403 bool operator!=(T* ptr)
const {
return ptr_ != ptr; }
430 CAAutoArrayDelete(CAPtrRef<T> ref) : ptr_(ref.ptr_) { }
432 CAAutoArrayDelete& operator=(CAPtrRef<T> ref)
439 operator CAPtrRef<U>()
440 {
return CAPtrRef<U>(release()); }
443 operator CAAutoArrayDelete<U>()
444 {
return CAAutoFree<U>(release()); }
453 template <
typename T>
454 void free(CAAutoFree<T>& p)
466 CAAutoFree<char> source()
469 const char* str =
"this is a test";
470 size_t size = strlen(str) + 1;
471 CAAutoFree<char> captr(size,
false);
472 strlcpy(captr(), str, size);
473 printf(
"source %08X %08X '%s'\n", &captr, captr(), captr());
477 void user(CAAutoFree<char>
const& captr)
480 printf(
"user: %08X %08X '%s'\n", &captr, captr(), captr());
483 void sink(CAAutoFree<char> captr)
486 printf(
"sink: %08X %08X '%s'\n", &captr, captr(), captr());
490 int main (
int argc,
char *
const argv[])
493 CAAutoFree<char> captr(source());
494 printf(
"main captr A %08X %08X\n", &captr, captr());
497 printf(
"main captr B %08X %08X\n", &captr, captr());
bool TTFOUNDATION_EXPORT operator!=(const TTObject &anObject, const TTObject &anotherObject)
Compare two objects for inequality.
bool TTFOUNDATION_EXPORT operator==(const TTObject &anObject, const TTObject &anotherObject)
Compare two objects for equality.