1,问题:
1,new 关键字创建出来的对象位于什么地方?
1,位于堆空间;
2,有没有可能位于其它地方?
1,有;
2,通过一些方式可以使动态创建的对象位于静态存储区;
3,这个存储区在程序结束后释放;
2,new/delete 被忽略的事实:
1,new/delete 的本质是 C++ 预定义的操作符;
1,new/delete 是关键字,但本质是预定义的操作符;
2,C++ 中操作符可以重载;
2,C++ 对这两个操作符做了严格的行为定义;
1,new:
1,获取足够大的内存空间(默认为堆空间);
2,在获取的空间中调用构造函数创建对象;
2,delete:
1,调用析构函数销毁对象;
2,归还对象所占用的空间(默认为堆空间);
3,在 C++ 中能够重载 new/delete 操作符:
1,全局重载(不推荐);
1,实际工程开发中不建议这样做
2,局部重载(针对具体类型进行重载);
1,针对具体的类重载;
3,重载 new/delete 的意义在于改变动态对象创建时的内存分配方式;
1,可以将创建的对象放到其它的内存空间里面去;
4,new/delete 的重载方式:
1,代码示例:
1 // static member function 2 void* operator new(unsinged int size) // 第一步获取内存,参数表示需要获取的内存大小; 3 { 4 void* ret = NULL; 5 6 /* ret point to allocated memory */ // 第二步在内存中调用构造函数创建对象; 7 8 return ret; 9 } 10 11 // static member function 12 void operator delete (void* p) // p 指针指向对应的对象地址,也就是要释放的地址; 13 { 14 /* free the memory which is pointed by p */ 15 }
2,通过函数来对这两个操作符进行重载;
3,一般针对具体类来重载,所以说 new/delete 的重载函数就是类的成员函数,并且这两个重载函数默认为静态成员函数,写不写 static 都是静态成员函数;
3,静态存储区中创建动态对象编程实验:
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Test 7 { 8 static const unsigned int COUNT = 4; 9 10 static char c_buffer[]; // 本质是这里申请空间而下面只是标记使用而已; 11 static char c_map[]; 12 13 int m_value; 14 public: 15 void* operator new (unsigned int size) 16 { 17 void* ret = NULL; // 如果这片内存已经满了,返回空; 18 19 /* 查找在 c_buffer 里面那些位置是空闲的,可以用来创建 Test 对象 */ 20 for(int i=0; i<COUNT; i++) 21 { 22 if( !c_map[i] ) // 当前空间不可用了; 23 { 24 c_map[i] = 1; // 标记为不可用; 25 26 ret = c_buffer + i * sizeof(Test); // 查找 c_buffer 这片可用内存空间的首地址,并返回这片空间; 27 28 cout << "succeed to allocate memory: " << ret << endl; 29 30 break; 31 } 32 } 33 34 return ret; 35 } 36 37 void operator delete (void* p) 38 { 39 if( p != NULL ) // 空指针时候什么都不处理; 40 { 41 char* mem = reinterpret_cast<char*>(p); 42 int index = (mem - c_buffer) / sizeof(Test); // 得到要释放的动态对象在 c_map 中的位置; 43 int flag = (mem - c_buffer) % sizeof(Test); // 这些位置必须是固定的,如果 flag 不为 0,指针则不合法; 44 45 if( (flag == 0) && (0 <= index) && (index < COUNT) ) 46 { 47 c_map[index] = 0; // 释放这个地址,即标记这个地址可用; 48 49 cout << "succeed to free memory: " << p << endl; 50 } 51 } 52 } 53 }; 54 55 char Test::c_buffer[sizeof(Test) * Test::COUNT] = {0}; // 定义一块静态的内存空间,内存空间想要存储的是 Test 对象,最多存储 4 个 Test 对象; 56 char Test::c_map[Test::COUNT] = {0}; // 标记数组,用于标记在那些位置已经创建了对象,作用是标记; 57 58 int main(int argc, char *argv[]) 59 { 60 cout << "===== Test Single Object =====" << endl; 61 62 Test* pt = new Test; // 这里是在 c_buffer 里面的静态存储区当中的空间生成的; 63 64 delete pt; 65 66 cout << "===== Test Object Array =====" << endl; 67 68 Test* pa[5] = {0}; 69 70 for(int i=0; i<5; i++) 71 { 72 pa[i] = new Test; 73 74 cout << "pa[" << i << "] = " << pa[i] << endl; 75 } 76 77 for(int i=0; i<5; i++) 78 { 79 cout << "delete " << pa[i] << endl; 80 81 delete pa[i]; 82 } 83 84 return 0; 85 }
1,结论:
1,new/delete 关键字是可以重载的;
2,重载的意义是改变内存的分配方式,使得动态创建的对象不再位于堆空间里面;
3,这个实验位于自定义的静态存储区里面的 c_buffer 数组当中;
2,拓展:
1,工程中可以结合不同方法来应用 new/delete 特性;
2,将本实验的方法和二阶构造法结合在一起,我们就可以创建一个类,并且规定这个类最多产生多少个对象;
3,单例模式仅仅使得一个类只有一个对象存在,而这里的方法加上二阶构造就可以诞生 N 例模式;
4,问题:
1,如何在指定的地址上创建 C++ 对象?
1,我们已经掌握了在静态存储区里面创建对象,是否可以扩展下这个方法,在任意的地址上创建对象呢?
2,通过重载 new/delete 也许就可以在指定的地址上创建对象;
5,设计思路:
1,在类中重载 new/delete 操作符;
2,在 new 的操作符重载函数中返回指定的地址;
3,在 delete 操作符重载中标记对应的地址可用;
6,自定义动态对象的存储空间编程实验:
1 #include <iostream> 2 #include <string> 3 #include <cstdlib> 4 5 using namespace std; 6 7 class Test 8 { 9 static unsigned int c_count; // 动态实时做决定,所以这个地方就不能有常量; 10 static char* c_buffer; 11 static char* c_map; 12 13 int m_value; 14 public: 15 /* 动态指定想在什么类型上指定申请对象 */ 16 static bool SetMemorySource(char* memory, unsigned int size) 17 { 18 bool ret = false; // 返回值为 bool 类型,告诉函数调用者,当前动态空间设置是否成功; 19 20 c_count = size / sizeof(Test); // 计算传进来的空间可以创建多少对象; 21 22 ret = (c_count && (c_map = reinterpret_cast<char*>(calloc(c_count, sizeof(char))))); 23 24 if( ret ) // 空间至少为 1,且标记指针合法; 25 { 26 c_buffer = memory; // 将指定空间设置到 c_buffer 上; 27 } 28 else // 一切清零; 29 { 30 free(c_map); 31 32 c_map = NULL; 33 c_buffer = NULL; 34 c_count = 0; 35 } 36 37 return ret; 38 } 39 40 void* operator new (unsigned int size) 41 { 42 void* ret = NULL; 43 44 /* 有指定的一个具体空间,通过各种计算和验证,看下所指定的空间上面是否可以动态创建对象,标准是 c_count 大于 0,此时意味着通过 setMemorySource() 所指定的空间是可以创建 Test 对象的,则走 if 路径,否则的话,走 else 路径,通过 malloc() 函数得到一片空间; */ 45 if( c_count > 0 ) // 46 { 47 for(int i=0; i<c_count; i++) 48 { 49 if( !c_map[i] ) 50 { 51 c_map[i] = 1; 52 53 ret = c_buffer + i * sizeof(Test); 54 55 cout << "succeed to allocate memory: " << ret << endl; 56 57 break; 58 } 59 } 60 } 61 else 62 { 63 ret = malloc(size); // 没有指定具体的在那个空间上生成对象时,通过 malloc 来申请默认的堆空间; 64 } 65 66 return ret; 67 } 68 69 void operator delete (void* p) 70 { 71 if( p != NULL ) 72 { 73 if( c_count > 0 ) 74 { 75 char* mem = reinterpret_cast<char*>(p); 76 int index = (mem - c_buffer) / sizeof(Test); 77 int flag = (mem - c_buffer) % sizeof(Test); 78 79 if( (flag == 0) && (0 <= index) && (index < c_count) ) 80 { 81 c_map[index] = 0; 82 83 cout << "succeed to free memory: " << p << endl; 84 } 85 } 86 else 87 { 88 free(p); // 和上面对应 89 } 90 } 91 } 92 }; 93 94 unsigned int Test::c_count = 0; 95 char* Test::c_buffer = NULL; 96 char* Test::c_map = NULL; 97 98 int main(int argc, char *argv[]) 99 { 100 char buffer[12] = {0}; // 定义一片栈上空间,用于存放对象; 101 102 Test::SetMemorySource(buffer, sizeof(buffer)); 103 104 cout << "===== Test Single Object =====" << endl; 105 106 Test* pt = new Test; 107 108 delete pt; 109 110 cout << "===== Test Object Array =====" << endl; 111 112 Test* pa[5] = {0}; 113 114 for(int i=0; i<5; i++) // 只有 3 个对象的空间,则后两个对象指向为 NULL; 115 { 116 pa[i] = new Test; 117 118 cout << "pa[" << i << "] = " << pa[i] << endl; 119 } 120 121 for(int i=0; i<5; i++) 122 { 123 cout << "delete " << pa[i] << endl; 124 125 delete pa[i]; 126 } 127 128 return 0; 129 }
1,通过重载 new/delete,我们可以在任意指定的位置动态创建 C++ 对象;
7,new[]/delete[] 与 new/delete 完全不同:
1,动态对象数组创建通过 new[] 完成;
2,动态对象数组的销毁通过 delete[] 完成;
3,new[]/delete[] 能够被重载,进而改变内存管理方式;
1,这是两个新的操作符;
8,new[]/delete[] 的重载方式:
1,代码示例:
1 // static member function 2 void* operator new[] (unsigned int size) 3 { 4 rerurn malloc(size); 5 } 6 7 // static member function 8 void operator delete[] (void* p) 9 { 10 free(p); 11 }
2,通过类的静态成员函数来重载,不写 static,这两个成员函数在类中也是 静态的;
9,注意事项:
1,nwe[] 实际需要返回的内存空间可能比期望的要多;
1,需要额外的空间来保存数组的信息;
2,如数组长度信息,因为编译器要自动的为我们调用构造函数和析构函数,不保存长度信息,编译器不知道要调用多少次构造函数和析构函数;
2,对象数组占用的内存中需要保存数组信息;
3,数组信息用于确定构造函数和析构函数的调用次数;
10,动态数组的内存管理编程实验:
1 #include <iostream> 2 #include <string> 3 #include <cstdlib> 4 5 using namespace std; 6 7 class Test 8 { 9 int m_value; 10 public: 11 Test() 12 { 13 m_value = 0; 14 } 15 16 ~Test() 17 { 18 } 19 20 void* operator new (unsigned int size) 21 { 22 cout << "operator new: " << size << endl; 23 24 return malloc(size); 25 } 26 27 void operator delete (void* p) 28 { 29 cout << "operator delete: " << p << endl; 30 31 free(p); 32 } 33 34 void* operator new[] (unsigned int size) 35 { 36 cout << "operator new[]: " << size << endl; 37 38 return malloc(size); 39 } 40 41 void operator delete[] (void* p) 42 { 43 cout << "operator delete[]: " << p << endl; 44 45 free(p); 46 } 47 }; 48 49 int main(int argc, char *argv[]) 50 { 51 Test* pt = NULL; 52 53 pt = new Test; // operator new: 4; 54 55 delete pt; // operator delete: 0x8e5d008; 56 57 pt = new Test[5]; // operator new[]: 24;这里多了四个字节,用于保存数组的大小信息,因为编译器自动为我们自调用构造函数和析构函数; 58 59 delete[] pt; // operator delete[]: 0x8e5d018; 60 61 return 0; 62 }
1,new/delete 和 new[]/delete[] 是完全不同的;
2,通过重载的方式说明了它们的不同;
3,意味着在实际的工程里面,有可能在 new 中函数的内存分配方式和 delete[] 中函数内存分配方式是不一样的,因此必须成对使用,必须要匹配;
4,假设 new[] 动态创建数组是从栈上分配的空间,然后 delete 想要将空间归还到堆空间去,如果交叉使用,则意味着有可能把栈上的空间归还到堆空间上,程序会崩溃,所以要成对出现,不要交叉使用,因为它们 new/delete 和 new[]/delete[] 完全不同;
11,小结:
1,new/delete 的本质为操作符;
2,可以通过全局函数重载 new/delete(不推荐);
3,可以针对具体的类重载new/delete;
4,new[]/delete[] 与 new/delete 完全不同;
原文地址:https://www.cnblogs.com/dishengAndziyu/p/10920093.html