本文共 9973 字,大约阅读时间需要 33 分钟。
#define _CRT_SECURE_NO_WARNINGS 1#include#include int globalVar = 1;static int staticGlobalVar = 1;void Test(){ static int staticVar = 1; int localVar = 1; int num1[10] = { 1, 2, 3, 4 }; char char2[] = "abcd"; char* pChar3 = "abcd"; int* ptr1 = (int*)malloc(sizeof (int)* 4); int* ptr2 = (int*)calloc(4, sizeof(int)); int* ptr3 = (int*)realloc(ptr2, sizeof(int)* 4); free(ptr1); free(ptr3); std::cout << "sizeof(num1):" < << std::endl; std::cout << "sizeof(char2):"< << std::endl; std::cout << "strlen(char2):" << strlen(char2) << std::endl; std::cout << "sizeof(pChar3):" << sizeof(pChar3) << std::endl; std::cout << "strlen(pChar4):" << strlen(pChar3) << std::endl; std::cout << "sizeof(ptr1):" << sizeof(ptr1) << std::endl;}int main(){ Test(); return 0;}
记住: sizeof是一个C语言中的一个单目运算符,而strlen是一个函数,用来计算字符串的长度。sizeof求的是数据类型所占空间的大小,而strlen是求字符串的长度,strlen(结束的标志是是否碰到\0)。
解释栈为啥是向下生长,堆是向上生长。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1#includeint main(){ int a = 1; int b = 2; std::cout << &a << std::endl; std::cout << &b << std::endl; return 0;}
代码如下
int* c = (int*)malloc(sizeof(int)); int* d = (int*)malloc(sizeof(int)); std::cout << c << std::endl; std::cout << d << std::endl;注意:在堆区后一个开辟的空间的地址不一定比前面先开辟空间的地址大,因为可能后开辟空间的地址是在前面释放的空间上开辟的地址。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1#include// 1.malloc/calloc/realloc的区别是什么int main(){ int* p1 = (int*)malloc(sizeof(int)); int* p2 = (int*)calloc(4,sizeof(int)); int* p3 = (int*)realloc(p2, sizeof(int) * 10); free(p1); //free(p2); // 这里需要free(p2)吗? free(p3); return 0;}
注意:如果此时你在p2的基础上扩容,则p2则不需要自己释放,否则会发生错误。
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1#includenew/delete和malloc/free 针对内置类型没有任何差别,只是用法不一样。 代码如下int main(){ int* p1 = new int; //C++动态的申请一个int类型的空间 int* p2 = (int*)malloc(sizeof(int*)); //C动态申请一个int类型的空间 delete p1; free(p2); int* p3 = new int[10]; //C++动态申请10个int类型的空间 int* p4 = (int*)malloc(sizeof(int*)* 10); //C动态申请1个int类型的空间 delete[] p3; free(p4); int* p5 = new int(1); //C++动态申请1个int类型的空间并且初始化为1 int* p6 = new int[3]{ 1, 2, 3}; //C++动态申请3个int类型的空间并且初始化 delete p5; delete[] p6; return 0;}
void Test(){ //new/delete和malloc/free 针对内置类型没有任何差别,只是用法不一样 // 动态申请一个int类型的空间 int* ptr4 = new int; // 动态申请一个int类型的空间并初始化为10 int* ptr5 = new int(10); // 动态申请10个int类型的空间 int* ptr6 = new int[3]; delete ptr4; delete ptr5; delete[] ptr6;}注意:申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用new[]和delete[]。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1#include注意:在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会。class Test{ public: Test() :_data(0) { std::cout << "Test():" << std::endl; } ~Test() { std::cout << "~Test():" << std::endl; }private: int _data;};void Test2(){ //申请一个Test类型的空间 Test* p1 = (Test*)malloc(sizeof(Test)); free(p1); //申请十个Test类型的空间 Test* p2 = (Test*)malloc(sizeof(Test)* 10); free(p2);}void Test3(){ //申请一个Test类型的对象 Test* p1 = new Test; //申请10个Test类型的对象 Test* p2 = new Test[10];}int main(){ Test T; Test3(); return 0;}
new和delete是用户进行动态内存申请和释放的操作符,operator new 和operator delete是系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间。
代码如下
#define _CRT_SECURE_NO_WARNINGS 1#includeint main(){ //以下三种方式开辟空间和释放空间的效果是一样的 int* p1 = (int*)malloc(sizeof(int)); //malloc和free free(p1); int* p2 = new int; //new和delete delete p2; int* p3 = (int*)operator new(sizeof(int));//operator new与operator delete operator delete (p3); return 0;}
operator new失败了处理方式不一样,malloc失败返回NULL,operator new失败以后抛异常。 代码如下
#define _CRT_SECURE_NO_WARNINGS 1#includeoperator new与operator delete底层源码using namespace std;void f(){ // 他的用法跟malloc和free是完全一样的,功能都是在堆上申请释放空间 // 失败了处理方式不一样,malloc失败返回NULL,operator new失败以后抛异常 void* p3 = malloc(0x7fffffff); if (p3 == NULL) { cout << "malloc fail" << endl; } void* p4 = operator new(11); char* p5 = new char[0x7fffffff]; cout << "继续" << endl;}int main(){ try { f(); } catch (exception& e) { cout << e.what() << endl; } return 0;}
/*operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,尝试执行空 间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。*/void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc){ // try to allocate size bytes void *p; while ((p = malloc(size)) == 0) if (_callnewh(size) == 0) { // report no memory // 如果申请内存失败了,这里会抛出bad_alloc 类型异常 static const std::bad_alloc nomem; _RAISE(nomem); } return (p);}/*operator delete: 该函数最终是通过free来释放空间的*/void operator delete(void *pUserData){ _CrtMemBlockHeader * pHead; RTCCALLBACK(_RTC_Free_hook, (pUserData, 0)); if (pUserData == NULL) return; _mlock(_HEAP_LOCK); /* block other threads */ __TRY /* get a pointer to memory block header */ pHead = pHdr(pUserData); /* verify block type */ _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)); _free_dbg(pUserData, pHead->nBlockUse); __FINALLY _munlock(_HEAP_LOCK); /* release other threads */ __END_TRY_FINALLY return;}/*free的实现*/#define free(p) _free_dbg(p, _NORMAL_BLOCK)
写了类专属重载就不用调用全局的operator new与Operator delete。
struct ListNode{ ListNode* _next; ListNode* _prev; int _val; //类中重载专属operator new void* operator new(size_t n) { void* p = nullptr; p = allocator没有写operator new与operator delete。().allocate(1); cout << "memory pool allocate" << endl; return p; } void operator delete(void* p) { allocator ().deallocate((ListNode*)p, 1); cout << "memory pool deallocate" << endl; } ListNode(int val) :_next(nullptr) , _prev(nullptr) , _val(val) { }};int main(){ ListNode* p = new ListNode(1); delete p; return 0;}
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用场景: 定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调构造函数进行初始化。 代码如下
#define _CRT_SECURE_NO_WARNINGS 1#includeusing namespace std;class A{ public: A(int a = 0) : _a(a) { cout << "A():" << this << endl; } ~A() { cout << "~A():" << this << endl; }private: int _a;};int main(){ // p现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行 // A* p = (A*)malloc(sizeof(A)); // 等价于直接用A* p = new A A* p = (A*)operator new(sizeof(A)); new(p)A; // new(p)A(3); // 定位new,placement-new,显示调用构造函数初始化这块对象空间 // 等于 delete p p->~A(); // 析构函数可以显示调用 operator delete(p); return 0;}
什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。
内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死。
代码如下:
void MemoryLeaks(){ // 1.内存申请了忘记释放 int* p1 = (int*)malloc(sizeof(int)); int* p2 = new int; // 2.异常安全问题 int* p3 = new int[10]; Func(); // 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放. delete[] p3;}
C/C++程序中一般我们关心两种方面的内存泄漏:
总结一下:内存泄漏非常常见,解决方案分为两种:1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。
当我们想在win32平台上堆上想开辟4G的内存空间0xffffffff的时候会发生错误。 代码如下:
#define _CRT_SECURE_NO_WARNINGS 1#include那如何在堆上开辟4G的空间呢? 因为32位的平台下,内存大小为4G,但是堆区差不多2G,所以不可能在32位的平台上一次在堆上开辟4G的内存。但是我们可以将编译器上的win32改为x64,在64位平台下,我们便可以一次性在堆上申请4G的内存了。using namespace std;int main(){ //1byte == 8bit // 1KB = 1024byte // 1MB = 1024KB // 1GB = 1024MB // 1TB = 1024GB void* p1 = malloc(0xffffffff); cout << p1 << endl; return 0;}
以上就是今天要讲的内容,本文仅仅简单介绍了C、C++内存管理的使用,而new、delete提供了快速能使我们快速便捷创建对象,而且还能调用构造函数与析构函数,非常的便捷,所以我们务必掌握。到现在,内存管理已经完毕,接下就是STL的重头戏。另外如果上述有任何问题,请懂哥指教,不过没关系,主要是自己能坚持,更希望有一起学习的同学可以帮我指正,但是如果可以请温柔一点跟我讲,爱与和平是永远的主题,爱各位了。
转载地址:http://bulzi.baihongyu.com/