Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Namespace Members | Data Fields | Globals | Examples

sample6.cpp

Go to the documentation of this file.
00001 /*
00002 Copyright(c) 2002-2005 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
00003 
00004 Permission is hereby granted, free of charge, to any person 
00005 obtaining a copy of this software and associated documentation 
00006 files (the "Software"), to deal in the Software without restriction, 
00007 including without limitation the rights to use, copy, modify, merge, 
00008 publish, distribute, sublicense, and/or sell copies of the Software, 
00009 and to permit persons to whom the Software is furnished to do so, 
00010 subject to the following conditions:
00011 
00012 The above copyright notice and this permission notice shall be included 
00013 in all copies or substantial portions of the Software.
00014 
00015 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
00016 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
00017 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
00018 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
00019 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
00020 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
00021 OTHER DEALINGS IN THE SOFTWARE.
00022 */
00023 
00024 /** \example sample6.cpp
00025  This example demonstrates using of custom memory allocators.
00026  In this case allocator works as a memory checker, counts number of 
00027  allocations and deallocations to make sure that there is no memory leaks. 
00028 
00029 For more information please visit:  http://bmagic.sourceforge.net
00030 */
00031 
00032 #include <iostream>
00033 #include <assert.h>
00034 #include "bm.h"
00035 
00036 using namespace std;
00037 
00038 
00039 // Custom allocator keeps number of all alloc/free calls.
00040 // It also reservs the front word of the allocated block and saves
00041 // number of elements allocated. On deallocation it makes sure
00042 // it deallocates the same size as allocated
00043 
00044 class dbg_block_allocator
00045 {
00046 public:
00047 static unsigned na_;
00048 static unsigned nf_;
00049 
00050     static bm::word_t* allocate(size_t n, const void *)
00051     {
00052         ++na_;
00053         assert(n);
00054         bm::word_t* p =
00055             (bm::word_t*) ::malloc((n+1) * sizeof(bm::word_t));
00056         *p = n;
00057         return ++p;
00058     }
00059 
00060     static void deallocate(bm::word_t* p, size_t n)
00061     {
00062         ++nf_;
00063         --p;
00064         assert(*p == n);
00065         ::free(p);
00066     }
00067 
00068     static int balance()
00069     {
00070         return nf_ - na_;
00071     }
00072 };
00073 
00074 unsigned dbg_block_allocator::na_ = 0;
00075 unsigned dbg_block_allocator::nf_ = 0;
00076 
00077 class dbg_ptr_allocator
00078 {
00079 public:
00080 static unsigned na_;
00081 static unsigned nf_;
00082 
00083     static void* allocate(size_t n, const void *)
00084     {
00085         ++na_;
00086         assert(sizeof(size_t) == sizeof(void*));
00087         void* p = ::malloc((n+1) * sizeof(void*));
00088         size_t* s = (size_t*) p;
00089         *s = n;
00090         return (void*)++s;
00091     }
00092 
00093     static void deallocate(void* p, size_t n)
00094     {
00095         ++nf_;
00096         size_t* s = (size_t*) p;
00097         --s;
00098         assert(*s == n);
00099         ::free(s);
00100     }
00101 
00102     static int balance()
00103     {
00104         return nf_ - na_;
00105     }
00106 
00107 };
00108 
00109 unsigned dbg_ptr_allocator::na_ = 0;
00110 unsigned dbg_ptr_allocator::nf_ = 0;
00111 
00112 
00113 typedef bm::mem_alloc<dbg_block_allocator, dbg_ptr_allocator> dbg_alloc;
00114 
00115 typedef bm::bvector<dbg_alloc> bvect;
00116 
00117 
00118 
00119 int main(void)
00120 {
00121     {
00122         bvect bv;
00123 
00124         bv[10] = true;
00125         bv[100000] = true;
00126         bv[10000000] = false;
00127     }
00128 
00129     cout << "Number of BLOCK allocations = " <<  dbg_block_allocator::na_ << endl;
00130     cout << "Number of PTR allocations = " <<  dbg_ptr_allocator::na_ << endl;
00131 
00132     assert(dbg_block_allocator::balance() == 0);
00133     assert(dbg_ptr_allocator::balance() == 0);
00134 
00135     return 0;
00136 }
00137 
00138   

Generated on Thu Apr 20 13:28:46 2006 for BitMagic by  doxygen 1.4.1