嵌入式指针

一般应用在内存池相关的代码中，成功使用嵌入式指针有个前提条件：类A对象的sizeof必须不小于4个字节

工作原理：借用A对象所占用的内存空间中的前4个字节，用来链住这些空闲的内存块；

但是一旦某一块内存被分配出去，那么这个块的前4个字节就不在需要了，此时这4个字节（这里的4字节指的是当前编译器默认的指针类型所占内存大小）可以被类A对象正常使用；

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

namespace _nmsp4 {
	class myallocator {
	public:
		void *allocate(size_t size) {
			obj *tmplink;
			if (m_FreePosi == nullptr) {
				size_t realsize = m_sTrunkCout * size; //申请m_TrunkCout倍内存
				m_FreePosi = reinterpret_cast<obj *>(malloc(realsize)); //这里的new是系统的new
				tmplink = m_FreePosi;
				//把分配出来的这块内存，彼此要连起来，供后续使用
				for (int i = 0; i< m_sTrunkCout - 1; ++i) {
					tmplink->next = reinterpret_cast<obj *>(reinterpret_cast<char *>(tmplink) + size);
					tmplink = tmplink->next;
				}
				tmplink->next = nullptr;
			}
			tmplink = m_FreePosi;
			m_FreePosi = m_FreePosi->next;
			return tmplink;
		}
 
		void deallocate(void *phead) {
			reinterpret_cast<obj *>(phead)->next = m_FreePosi;
			m_FreePosi = reinterpret_cast<obj *>(phead);
		}
 
 
	private:
		struct obj {  
			struct obj *next;  
		};
		obj* m_FreePosi; 
		int m_sTrunkCout = 5;//一次分配多少该类内存
	};
 
	class A {
	public:
		int m_i;
		int m_j;
		static myallocator myalloc;
		static void *operator new(size_t size) {
			return myalloc.allocate(size);
		}
 
		static void operator delete(void *phead) {
			myalloc.deallocate(phead);
		}
	};
 
	myallocator A::myalloc;
 
	void func() {
		A *mypa[100];
		for (int i = 0; i < 15; ++i) {
			mypa[i] = new A();
			printf("%p\n", mypa[i]);
		}
	}
}
 
int main()
{
	_nmsp4::func();
	return 0;
}

提示：平时用 ++i 而不是 i++可以少生成一次临时对象。(for循环里)