一个可以跨 dll 使用的 allocator

参照Stephan T. Lavavej 写的 Mallocator，自己写了一个 allocator，用于跨 dll 分配和释放字符串

http://blogs.msdn.com/vcblog/archive/2008/08/28/the-mallocator.aspx

1. #pragma once
3. // The following headers are required for all allocators.
4. #include <stddef.h>  // Required for size_t and ptrdiff_t and NULL
5. #include <new>       // Required for placement new and std::bad_alloc
6. #include <stdexcept> // Required for std::length_error
8. // The following headers contain stuff that allocator uses.
9. #include <iostream>  // For std::cout
10. #include <ostream>   // For std::endl
12. template <typename T>
13. class pheap_allocator
14. {
15. public:
16.     // The following will be the same for virtually all allocators.
17.     typedef T       *pointer;
18.     typedef const T *const_pointer;
19.     typedef T       &reference;
20.     typedef const T &const_reference;
21.     typedef T       value_type;
22.     typedef size_t  size_type;
23.     typedef ptrdiff_t difference_type;
25. public:
26.     // Default constructor, copy constructor, rebinding constructor, and estructor.
27.     // Empty for stateless allocators.
28.     pheap_allocator() {}
29.     pheap_allocator(const pheap_allocator&) {}
30.     template <typename U> pheap_allocator(const pheap_allocator<U>&) {}
31.     ~pheap_allocator() {}
33.     pointer address(reference r) const { return &r; }
34.     const_pointer address(const_reference s) const { return &s; }
36.     size_type max_size() const
37.     {
38.         // The following has been carefully written to be independent of
39.         // the definition of size_t and to avoid signed/unsigned warnings.
40.         return (~static_cast<size_type>(0)) / sizeof(T);
41.     }
43.     bool operator != (const pheap_allocator& other) const { return !(*this == other); }
44.     // Returns true if and only if storage allocated from *this
45.     // can be deallocated from other, and vice versa.
46.     // Always returns true for stateless allocators.
47.     bool operator == (const pheap_allocator& other) const { return true; }
49.     void construct(T * const p, const_reference t) const
50.     {
51.         void * const pv = static_cast<void *>(p);
52.         new (pv) T(t);
53.     }
55.     void destroy(T * const p) const; // Defined below.
58.     // The following will be different for each allocator.
59.     pointer allocate(const size_type n) const
60.     {
61.         std::cout << "Allocating " << (unsigned int)n << " object(s) of size " << sizeof(T) << std::endl;
63.         if (n == 0)
64.             return NULL;
66.         // All allocators should contain an integer overflow check.
67.         // The Standardization Committee recommends that std::length_error
68.         // be thrown in the case of integer overflow.
69.         if (n > max_size())
70.             throw std::length_error("pheap_allocator<T>::allocate() - Integer verflow.");
72.         void * const pv = ::HeapAlloc(::GetProcessHeap(),HEAP_ZERO_MEMORY,n * sizeof(T));
74.         // Allocators should throw std::bad_alloc in the case of memory allocation failure.
75.         if (pv == NULL)
76.             throw std::bad_alloc();
78.         return static_cast<pointer>(pv);
79.     }
81.     void deallocate(T * const p, const size_t n) const
82.     {
83.         std::cout << "Deallocating " << (unsigned int)n << " object(s) of size " << sizeof(T) << std::endl;
84.         ::HeapFree(::GetProcessHeap(),HEAP_ZERO_MEMORY,p);
85.     }
87.     //allocator::rebind 
88.     //  A structure that enables an allocator for objects of one type to allocate storage for objects of another type
89.     template <typename U>
90.     struct rebind
91.     {
92.         typedef pheap_allocator<U> other;
93.     };
94.     // The following will be the same for all allocators that ignore hints.
95.     template <typename U>
96.     pointer allocate(const size_type n, const U * /* const hint */) const
97.     {
98.         return allocate(n);
99.     }
100. private:
101.     pheap_allocator& operator = (const pheap_allocator&);
102. };
104. // The definition of destroy() must be the same for all allocators.
105. template <typename T>
106. void pheap_allocator<T>::destroy(T * const p) const
107. {
108.     p->~T();
109. };

//dll 内的导出函数fn2()

1. #include <string>
2. typedef std::basic_string<TCHAR, std::char_traits<TCHAR>, pheap_allocator<TCHAR> > tstring;
4. #include <vector>
5. typedef std::vector< tstring, pheap_allocator<tstring> > vecString;
7. DLL_API int fn2(vecString &vs)
8. {
9.      vs.clear();
10.      vs.push_back("1234567890123456789012345678901234567890");
11.      vs.push_back("12345678901234567890");
12.      vs.resize(5);
13.      return 0;
14. }

//测试

1. DWORD WINAPI proc1(LPVOID)
2. {
3.     while(1)
4.     {
5.         tstring s = "12345678901234567890";
6.         fn1(s);
7.         s = "12345678901234567890123456789012345678901234567890123456789012345678901234567890";
9.         vecString vs;
10.         vs.push_back(s);
11.         fn2(vs);
13.         s = vs[0];
14.         vs.clear();
15.     }
16.     return 0;
17. }
18. int _tmain(int argc, _TCHAR* argv[])
19. {
20.     for(int i = 0; i < 6; ++i)
21.         CreateThread(NULL, 0, proc1, NULL, 0, NULL);
23.     while(1){};
24.     return 0;
25. }

测试没有任何问题，代码用了进程的堆，HeapAlloc()的第二个参数里不加 HEAP_NO_SERIALIZE 标志的话，会自动对堆访问操作同步，多线程测试也通过