关于new操作符如何实现C中的realloc函数
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了关于new操作符如何实现C中的realloc函数相关的知识,希望对你有一定的参考价值。
参考技术A 最起码你要知道new和malloc不能完全等同,new是要去调用构造函数的,malloc则不会。然后呢,你要明白realloc函数中其实现也是先分配新的数据块,复制数据,再释放旧的数据块。按照这种思路可以这样实现(假设你已经有一块内存A了):1.先new一块新的内存B,并且sizeof(B)>=sizeof(A);2.若上一步成功,则用memcpy将A中的内容复制到B,当然事先最好将B中的内容初始化为0,memset一下;3.若上一步成功,则delete[] A,然后A=B。如果处理的是非自定义类(即基本数据类型)对象的时候,这样就足够了。如果是类对象数组的话,对象的复制不能通过简单的memcpy完成,而指针的delete[],也会有潜在的问题。本回答被提问者采纳C/C++内存管理
C++内存管理
C/C++内存分布
示例图:
栈区(stack):由编译器自动分配与释放,存放为运行时函数分配的局部变量、函数参数、返回数据、返回地址等。其操作类似于数据结构中的栈。
堆区(heap):一般由程序员自动分配,如果程序员没有释放,程序结束时可能有OS回收。其分配类似于链表。
数据段:存放的是全局数据、与静态数据,全局数据又可分为已初始化的全局区(data)和未初始化的全局区(BSS);
代码段:可执行代码和只读常量(文字常量区);
内存映射段:文件映射、动态库、匿名映射
C语言内存开辟(堆上)的三大函数
面试题:malloc、calloc、realloc区别
三个函数的声明分别是:
void* realloc(void* ptr, unsigned newsize);
void* malloc(unsigned size);
void* calloc(size_t numElements, size_t sizeOfElement);
相同点:都在stdlib.h函数库内它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL
**malloc用于申请一段新的地址,参数size为需要内存空间的长度,如:
char p;
p=(char)malloc(20);
calloc与malloc相似,参数sizeOfElement为申请地址的单位元素长度,numElements为元素个数,如:
char* p;
p=(char*)calloc(20,sizeof(char));
realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度
例如:
char* p;
p=(char*)malloc(sizeof(char)20);
p=(char)realloc(p,sizeof(char)*40);
注意,这里的空间长度都是以字节为单位。
C语言的标准内存分配函数:malloc,calloc,realloc,free等。
malloc与calloc的区别为1块与n块的区别:
malloc调用形式为(类型*)malloc(size):在内存的动态存储区中分配一块长度为“size”字节的连续区域,返回该区域的首地址。
calloc调用形式为(类型*)calloc(n,size):在内存的动态存储区中分配n块长度为“size”字节的连续区域,返回首地址。
realloc调用形式为(类型*)realloc(ptr,size):将ptr内存大小增大(减少)到size。类似于调整,可调大也可调小。
free的调用形式为free(voidptr):释放ptr所指向的一块内存空间。
探究realloc底层实现。
realloc()函数指的是在原有内存的基础上进行操作,对该内存的大小进行扩容或者是减容,底层实现:
只是从代码层面,没有从底层说
void* my_realloc(void* des, size_t size)
{
void* new_space = malloc(size);//1.申请空间
memcpy(new_space, des, size);//2.对原空间size大小个数据复制,此时size为新开辟的空间大小
free(des);//3释放原空间
des = NULL;
return new_space;//返回新开辟的空间
}
realloc(void*des,size_t size)会做四件事:
1.根据size申请一段新的空间
2.对原空间的内容拷贝原空间size个字节大小。(假如说缩容的话,则可能会造成数据丢失).
3.释放掉原空间(这点很关键),这块的realloc会有两种处理策略,一个是在原空间上进行操作(扩容或者减容)不去寻找新空间 ,第二种情况是在新空间中开辟一段空间。(因为这是操作系统做决定的,所以我们无法模拟出来)。
4.在开辟成功的基础上返回新开辟的空间首地址。
void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么?
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗?
free(p3 );
}
看一下这个需要free(p2)吗?答案是不需要的,因为根据上面那个realloc底层实现上来看,他会在封装realloc内部进行操作,free()掉原空间,所以此时入去再去free()的话就相当于对一块原空间free了两次(以上陈述建立在新空间中开辟)。
C++内存开辟与释放函数
内存开辟函数new与new[]操作符
new
new的底层实现:
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);
}
new什么时候会开辟失败?
内存不足的时候会开辟失败,此时它会进入上面的那个if(_callnewh(size)==0)这个判断语句,然后对内存中的资源进行回收,若回收到了的话分配,回收不到的话会抛出 bad_alloc类型异常
new的使用:
void test()
{
int* p = new int;
*p = 100;
cout << *p << endl;
}
int main()
{
test();
system("pause");
return 0;
}
new[]
底层相当于循环去调用malloc(),这个函数一般用来开辟数组
实现原理:
1. 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申
请
2. 在申请的空间上执行N次构造函数
void* operator new[](size_t size=sizeof(type)*n);
void test()
{
int* p = new int[10];
for (int i = 0; i < 10; i++)
{
p[i] = i * 10;
}
for (int i = 0; i < 10; i++)
{
cout << p[i] << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}
看底层
内存释放delete操作符
delete p;//释放p,释放单个变量
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
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 );//可以看到底层实现是用free做的
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
delete [] p ;//释放p所指向的数组空间
实现原理:
1. 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
2. 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释放空间
测试用例:
void test()
{
int* p = new int;
int* p1 = new int[10];
delete p;
delete[]p1;
}
int main()
{
test();
return 0;
}
c语言内存管理与C++内存管理的区别
1.C语言的三个在堆上的内存开辟函数的返回值需要进行强转(C++下),new的返回值不需要强转,因为在申请的时候编译器已经将其类型转好了
int *p=new int;//告诉编译器你要的是个int类型的数据。
2.C语言的开辟出来的空间的值除了calloc()函数之外,其与开辟出来空间的值皆为随机值。而C++的new可以初始化值。C++11中提出来的。
void test()
{
int* p =(int *) malloc(sizeof(int) * 10);
int* p1 = (int*)calloc(10, sizeof(int));
//底下这个语句给初始值就从0号下标开始依次往下赋值,没有初始化的元素赋值为0;
//若没有给初始值的话,比如 int *p2=new int[10];//此时里面的值全为随机值
int* p2 = new int[10]{ 1 };
free(p);
free(p1);
delete[]p2;
}
int main()
{
test();
return 0;
}
可以看到 malloc出现的数组的值全为随机值,calloc为0,new中因为我只给了1个初始化变量,所以除了第一个元素外,其余9个全为0.
3.C语言的内存开辟函数开辟出来的类对象无法自动调用类的构造函数。而new出来的对象可以。同时,free()自动调用类的析构函数,而delete可以,
class date
{
public:
date()
{
year = 1900;
month = 0;
day = 0;
cout << "构造函数调用" << endl;
}
~date()
{
cout << "析构函数调用" << endl;
}
private:
int year;
int month;
int day;
};
void test01()
{
date* m1 = (date*)malloc(sizeof(date) * 5);
cout << "free调用" << endl;
free(m1);
}
void test02()
{
date* m2 = new date[5];
cout << "delete调用" << endl;
delete[]m2;
}
int main()
{
cout << "malloc开辟" << endl;
test01();
cout << "new 开辟" << endl;
test02();
return 0;
}
4.如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
5.在自定义方法分析:首先看C语言的内存开辟函数,它只开辟了与对象同等大小的空间,但是它不是对象。C++提供的new开辟内存,干了两件事,第一件事开辟内存,第二件事调用构造函数,完成对类对象变量的初始化。它开辟出来的是一个对象。对应的delete会调用析构函数,若你有析构函数,则调用你自身的析构,若没有,则调用系统自动生成的析构。
在使用的时候必须对应使用
malloc()对应free() new对应delete new[]对象 delete[]
必须做到匹配使用
如果不匹配使用,轻则的话内存泄露,重则的话程序会崩溃。
1.我们试一下malloc开辟让delete去释放。
class student
{
public:
student()
{
cout << "构造调用" << endl;
age = 20;
char* name = new char[20];
}
~student()
{
if (name)
{
delete[]name;
}
cout << "析构调用" << endl;
}
private:
int age;
char* name;
};
void test()
{
student* m1 = (student*)malloc(sizeof(student));
if (m1 == NULL)
{
cout << "内存开辟失败,退出" << endl;
return;
}
delete m1;
}
int main()
{
test();
return 0;
}
2.用new开辟,free()释放
class student
{
public:
student()
{
cout << "构造调用" << endl;
age = 20;
char* name = new char[20];
}
~student()
{
if (name)
{
delete[]name;
}
cout << "析构调用" << endl;
}
private:
int age;
char* name;
};
void test()
{
student* m1 = new student;
free(m1);
}
int main()
{
test();
return 0;
}
3。new开辟,delete []释放
class student
{
public:
student()
{
cout << "构造调用" << endl;
age = 20;
char* name = new char[20];
}
~student()
{
if (name)
{
delete[]name;
}
cout << "析构调用" << endl;
}
private:
int age;
char* name;
};
void test()
{
student* m1 = new student;
delete[]m1;
}
int main()
{
test();
return 0;
}
4.new[]开辟,free释放,崩溃
5.new[]开辟,delete释放,崩溃
注:一定要匹配使用。不然可能要不出现内存泄露,要不然程序崩溃。
同一个类,自定义析构函数比不自定义析构函数多4字节?
前提:new[]开辟,开辟类数组
是因为
class student
{
public:
student()
{
cout << "构造调用" << endl;
age = 100;
}
~student()
{
cout << "析构调用" << endl;
}
private:
int age;
};
void test()
{
//student* m1 = new student;
//delete m1;
student* m2 = new student[10];
delete[]m2;
}
int main()
{
test();
return 0;
}
为了对比:
此时我们注释掉显式定义出的析构函数
此时我们再来看内存
重载new与delete操作符
class student
{
public:
student()
{
age = 12;
}
~student()
{
}
void* operator new(size_t size)
{
return malloc(size);
}
void operator delete(void* p)
{
if (p)
{
free(p);
}
}
private:
int age;
};
int main()
{
student* m1 = new student;
delete m1;
}
不过这样重载感觉很蠢,我们一般会在固定需求时使用。
malloc()
malloc(size)为C语言开辟内存函数,它一般开辟size个大小,那么它真的就占这么大吗?当然不是,因为你要管理该空间,管理是不是要存储这部分的起始地址,和结束地址,所以在C/C++中有一个结构体,专门管理这部分空间。
#define nNoMansLandSize 4
typedef struct _CrtMemBlockHeader
{
// Pointer to the block allocated just before this one:
struct _CrtMemBlockHeader *pBlockHeaderNext;
// Pointer to the block allocated just after this one:
struct _CrtMemBlockHeader *pBlockHeaderPrev;
char *szFileName; // File name
int nLine; // Line number
size_t nDataSize; // Size of user block
int nBlockUse; // Type of block
long lRequest; // Allocation number
// Buffer just before (lower than) the user's memory:
unsigned char gap[nNoMansLandSize];
} _CrtMemBlockHeader;
这是管理malloc的结构体的,共占32个字节。
// Pointer to the block allocated just before this one:
struct _CrtMemBlockHeader *pBlockHeaderNext;
// Pointer to the block allocated just after this one:
struct _CrtMemBlockHeader *pBlockHeaderPrev;
可以看到开辟的空间是用双向链表组织起来的。
定位new
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式:
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针,initializer-list是类型的初始化列表
使用场景:
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化,所以如果是自定义
类型的对象,需要使用new的定义表达式进行显示调构造函数进行初始化
class Test
{
public:
Test()
: _data(0)
{
cout<<"Test():"<<this<<endl;
}
~Test()
{
cout<<"~Test():"<<this<<endl;
}
private:
int _data;
};
void Test()
{
// pt现在指向的只不过是与Test对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
Test* pt = (Test*)malloc(sizeof(Test));
new(pt) Test; // 注意:如果Test类的构造函数有参数时,此处需要传参
}
new(pt) Test;没有去开辟空间,因为空间已经malloc出来了,只是让其去调用test的构造函数而已。
以上是关于关于new操作符如何实现C中的realloc函数的主要内容,如果未能解决你的问题,请参考以下文章
C++初阶:内存管理C/C++内存分布及管理方式 | new/delete实现原理及operator new和operator delete函数
C++初阶:内存管理C/C++内存分布及管理方式 | new/delete实现原理及operator new和operator delete函数
内存动态分配之realloc(),malloc(),calloc()与new运算符