mallocfree与newdelete的区别

合集下载

malloc、free的用法详解

malloc、free的用法详解

在C里,内存管理是通过专门的函数来实现。

另外,为了兼容各种编程语言,操作系统提供的接口通常是 C 语言写成的函数声明(Windows 本身也由C和汇编语言写成)。

1 分配内存 malloc 函数需要包含头文件:and函数声明(函数原型)void *malloc(int size);说明:malloc 向系统申请分配指定size个字节的内存空间。

返回类型是 void* 类型。

void* 表示未确定类型的指针。

C,C++规定,void* 类型可以强制转换为任何其它类型的指针。

从函数声明上可以看出。

malloc 和 new 至少有两个不同: new 返回指定类型的指针,并且可以自动计算所需要大小。

比如:int *p;p = new int; //返回类型为int* 类型(整数型指针),分配大小为 sizeof(int);或:int* parr;parr = new int [100]; //返回类型为 int* 类型(整数型指针),分配大小为 sizeof(int) * 100;而 malloc 则必须由我们计算要字节数,并且在返回后强行转换为实际类型的指针。

int* p;p = (int *) malloc (sizeof(int));第一、malloc 函数返回的是 void * 类型,如果你写成:p = malloc (sizeof(int)); 则程序无法通过编译,报错:“不能将 void* 赋值给 int * 类型变量”。

所以必须通过 (int *) 来将强制转换。

第二、函数的实参为 sizeof(int) ,用于指明一个整型数据需要的大小。

如果你写成:int* p = (int *) malloc (1);代码也能通过编译,但事实上只分配了1个字节大小的内存空间,当你往里头存入一个整数,就会有3个字节无家可归,而直接“住进邻居家”!造成的结果是后面的内存中原有数据内容全部被清空。

malloc 也可以达到 new [] 的效果,申请出一段连续的内存,方法无非是指定你所需要内存大小。

C++——动态内存分配new--delete

C++——动态内存分配new--delete

C++——动态内存分配new--delete⼀、静态内存分配与动态内存分配静态内存分配:全局或局部变量(对象),编译器在编译时都可以根据变量或对象的类型知道所需内存空间的⼤⼩。

从⽽系统在适当的时候为他们分配内存空间动态内存分配:有些操作对象只有在程序运⾏时才能确定,这样编译器在编译时就⽆法为他们预定存储空间,只能在程序运⾏时,系统根据运⾏时的要求进⾏内存分配称为动态内存分配。

动态分配都在⾃由存储区中进⾏。

1. 动态内存分配:指针变量名=new 类型名(初始化式);delete 指针名;动态分配的⼀般都是⽆名对象,⾃由存储区不会在分配时做初始化(包括清零)所以必须⽤初始化式来显⽰初始化。

1int *pi=new int(0);2delete pi;3//释放的是pi所指向的⽬标的内存空间,也就是撤销了该⽬标。

但是指针pi本⾝并没有撤销,指针所占⽤的内存空间并没有释放。

2. 数组动态分配:1指针变量名=new类型名[下标表达式];2delete[] 指向该数组的指针变量名;3//两式中的⽅括号必须配对使⽤。

如果delete语句中少了⽅括号,因编译器认为该指针指是指向数组第⼀个元素的指针,会产⽣回收不彻底的问题(只回收了数组第⼀个元素所占⽤的内存空间) 3.⾃由存储区对象与构造函数:类对象动态建⽴与删除过程//对于CGoods类,动态建⽴内存与释放内存CGoods *pc;pc=new CGoods;//分配⾃由存储空间,并构建⼀个⽆名的CGoods对象......delete CGoods;//先析构,C++⾃动调⽤商品类的析构函数,再将内存空间返回给⾃由存储区类对象初始化:new后⾯类(class)类型可以有参数这些参数即构造函数的参数。

但对创建数组,则⽆参数,只能调⽤默认的构造函数。

⼆、类的封装: 封装的更⾼境界是在该类对象中的⼀切都是完备的,⾃给⾃⾜的,不仅有数据和对数据的操作,还包括资源的动态安排与释放。

2024年大学英语四级高频词汇总结

2024年大学英语四级高频词汇总结

1.new、delete、malloc、free关系delete会调用对象的析构函数,和new对应free只会释放内存,new调用结构函数。

malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行结构函数,对象在消亡之前要自动执行析构函数。

因为malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行结构函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分派和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

2.delete与delete []区分?delete只会调用一次析构函数,而delete[]会调用每一个组员的析构函数。

在More Effective C++中有更为详细的解释:“当delete操作符用于数组时,它为每个数组元素调用析构函数,然后调用operatordelete来释放内存。

”delete与New配套,delete[]与new []配套MemTest*mTest1=newMemTest[10];MemTest*mTest2=newMemTest;int*pInt1=newint[10];int*pInt2=new int; delete[]pInt1;//-1-delete[]pInt2; //-2- delete[]mTest1;//-3- delete[]mT est2;//-4- 在-4-处报错。

这就阐明:对于内建简单数据类型,delete和delete[]功效是相同的。

对于自定义的复杂数据类型,delete和delete[]不能互用。

delete[]删除一个数组,delete删除一个指针简单来说,用new分派的内存用delete删除用n ew[]分派的内存用delete[]删除delete[]会调用数组元素的析构函数。

C_C++面试常见问题

C_C++面试常见问题

C/C++面试常见问题1.new、delete、malloc、free关系delete会调用对象的析构函数,和new对应free只会释放内存,new调用构造函数。

malloc 与free是C++/C语言的标准库函数,new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。

由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

2.delete与delete []区别delete只会调用一次析构函数,而delete[]会调用每一个成员的析构函数。

在More Effective C++中有更为详细的解释:“当delete操作符用于数组时,它为每个数组元素调用析构函数,然后调用operatordelete来释放内存。

”delete与New配套,delete []与new []配套MemTest*mTest1=newMemTest[10];MemTest*mTest2=newMemTest;int*pInt1=newint[10];int*pInt2=newint;delete[]pInt1; //-1-delete[]pInt2; //-2-delete[]mTest1;//-3-delete[]mTest2;//-4-在-4-处报错。

这就说明:对于内建简单数据类型,delete和delete[]功能是相同的。

对于自定义的复杂数据类型,delete和delete[]不能互用。

delete[]删除一个数组,delete删除一个指针简单来说,用new分配的内存用delete删除用new[]分配的内存用delete[]删除delete[]会调用数组元素的析构函数。

C++new和delete详细解析

C++new和delete详细解析

C++new和delete详细解析C++中的new 和delete 是操作符,new 分配对象时候会⾃动调⽤构造函数,delete对象时候,会⾃动调⽤析构函数,⽽C语⾔中 malloc()和 free()是函数。

理论上malloc free 和 new 、delete 可以混搭⽤,但是最好不要这样⽤,也不能保证程序正确运⾏。

C++中new 和delete的语法格式如下:#include "stdlib.h"#include "stdio.h"#include "string.h"#include <iostream>using namespace std;//new 和delete是操作符//malloc() 和free() 是函数//new 在堆上分配基础类型、分配数组类型、分配对象int main01() {//new基础类型int* p = (int*)malloc(sizeof(int));free(p);int* p2 = new int;*p2 = 101;printf("*p2:%d \n", *p2);delete p2;//开辟⼀个存放整数的空间,并指定该整数的初值为100int* p3 = new int(100);system("pause");return0;}class Test {public:Test(int mya, int myb) {cout << "构造函数,我被调⽤了" <<endl;a = mya;b = myb;}~Test() {cout << "析构函数,我被调⽤了" << endl;}int getA(){return a;}protected:private:int a;int b;};int main() {//new数组int* p1 = (int*)malloc(10*sizeof(int)); //int a[10]p1[0] = 1 ;free(p1);int* p2 = new int[10];p2[0] = 1;p2[1] = 2;delete [] p2;//new对象 new操作符也会⾃动的调⽤这个类的构造函数//delete⾃动的调⽤这个类的析构函数,说明程序员可以//⼿动控制类对象的⽣命周期Test* p3 = new Test(1,2);cout << p3->getA() << endl;delete p3;system("pause"); return0;}。

C与C++经典面试题(内存泄露)

C与C++经典面试题(内存泄露)
该函数被C编译器编译后在库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。
3.4一个类有基类、内部有一个其他类的成员对象,构造函数的执行顺序是怎样的。(Autodesk)
答:先执行基类的(如果基类当中有虚基类,要先执行虚基类的,其他基类则按照声明派生类时的顺序依次执行),再执行成员对象的,最后执行自己的。
{
if ( strDest == NULL || strSrc == NULL)
return NULL ;
if ( strDest == strSrc)
return strDest ;
char *tempptr = strDest ;
while( (*strDest++ = *strSrc++) != ‘\0’)
3.9.2那为什么有了new/delete,还要malloc/free呢?
3.10 #define DOUBLE(x) x+x (Autodesk)
i = 5*DOUBLE(10);i是多少?正确的声明是什么?
答案:i为60。正确的声明是#define DOUBLE(x) (x+x)
3.11有哪几种情况只能用intialization list而不能用assignment? (Autodesk)
掌握的页面替换算法nru最近不用fifo第二次机会页面替换算法lru最近最少使用算法315有四个同样的容器里面装满了粒数相同的药丸正常药丸的质量为m变质药丸的质量为m1现在已知这四个容器中有一个装的全是变质药丸用电子秤只称一次找出哪个容器装的是变质药丸microsoft答案

【C++】new和malloc的区别

【C++】new和malloc的区别

【C++】new和malloc的区别C语⾔提供了malloc和free两个系统函数,完成对堆内存的申请和释放,malloc/free是库函数,需要头⽂件⽀持。

⽽C++则提供了两个关键字new和delete,需要编译器⽀持。

1、new和deleteC++中,⽤new和delete动态创建数组或单个对象,new表达式返回指向该新创健对象的指针,可以通过指针访问此对象。

int *pi=new int;这个new表达式在堆区中分配创建了⼀个整型对象,并返回此对象的地址,并⽤该地址初始化指针pi 。

动态创建的对象可以⽤初始化变量的⽅法初始化。

int *pi=new int(100); //指针pi所指向的对象初始化为100string *ps=new string(10,’9’);//*ps 为“9999999999”如果不提供显⽰初始化,对于类类型,⽤该类型的默认构造函数初始化;对于内置类型,⽆初始化。

int *pi=new int( );//初始化为0int *pi=new int;//pi 指向⼀个没有初始化的intstring *ps=new string( );//初始化为空字符串(对于提供了默认构造函数的类类型,没有必要对其对象进⾏值初始化)撤销动态创建的对象,delete表达式释放指针指向的地址空间。

delete pi ;// 释放单个对象delete [ ]pi;//释放数组如果指针指向的不是new分配的内存地址,则使⽤delete是不合法的。

在delete之后,重设指针的值delete p; //执⾏完该语句后,p变成了不确定的指针,在很多机器上,尽管p值没有明确定义,但仍然存放了它之前所指对象的地址,然后p所指向的内存已经被释放了,所以p不再有效。

此时,该指针变成了悬垂指针(悬垂指针指向曾经存放对象的内存,但该对象已经不存在了)。

悬垂指针往往导致程序错误,⽽且很难检测出来。

⼀旦删除了指针所指的对象,⽴即将指针置为0,这样就⾮常清楚的指明指针不再指向任何对象。

new和malloc的区别

new和malloc的区别

new和malloc的区别⼀、new是操作符,⽽malloc是函数void* malloc(size_t);void free(void*);void *operator new (size_t);void operator delete (void *);void *operator new[] (size_t);void operator delete[] (void *);⼆、new在调⽤的时候先分配内存,在调⽤构造函数,释放的时候调⽤析构函数。

#include <iostream>using namespace std;class Player{public:Player(){cout << "call Player::ctor\n";}~Player(){cout << "call Player::dtor\n";}void Log(){cout << "i am player\n";}};int main(){cout << "Initiate by new\n";Player* p1 = new Player();p1->Log();delete p1;cout << "Initiate by malloc\n";Player* p2 = (Player*)malloc(sizeof(Player));p2->Log();free(p2);}输出结果为:Initiate by newcall Player::ctori am playercall Player::dtorInitiate by malloci am player三、new是类型安全的,malloc返回void*四、new可以被重载五、new分配内存更直接和安全六、malloc 可以被realloc#include <iostream>using namespace std;int main(){char* str = (char*)malloc(sizeof(char*) * 6);strcpy(str, "hello");cout << str << endl;str = (char*)realloc(str, sizeof(char*) * 12);strcat(str, ",world");cout << str << endl;free(str);}输出结果为:hellohello,world七、new发⽣错误抛出异常,malloc返回null⼋、malloc可以分配任意字节,new 只能分配实例所占内存的整数倍数⼤⼩。

堆分配存储的方法

堆分配存储的方法

堆分配存储的方法
堆分配存储的方法是指在程序运行期间动态地分配和释放内存空间的方法。

常见的堆分配存储的方法有以下几种:
1. malloc和free:malloc是动态分配内存的函数,用于在堆上
分配一块指定大小的内存空间。

free函数用于释放先前malloc
分配的内存空间。

这种方法是C语言中常用的堆分配存储的
方法。

2. new和delete:new是C++中的关键字,用于在堆上分配一
块指定大小的内存空间,并调用构造函数进行初始化。

delete
关键字用于释放new分配的内存空间,并调用析构函数进行
清理工作。

这种方法是C++中常用的堆分配存储的方法。

3. calloc和realloc:calloc是一个动态分配内存的函数,用于
在堆上分配一块指定大小的内存空间,并初始化为0。

realloc
函数用于重新分配先前动态分配的内存空间的大小。

这种方法常用于C语言中。

4. new[]和delete[]:new[]是new的数组形式,用于在堆上分
配连续的一组指定大小的内存空间,并调用构造函数进行初始化。

delete[]则用于释放new[]分配的内存空间,并调用析构函
数进行清理工作。

这种方法常用于C++中对数组的堆分配存储。

注意:使用堆分配存储的方法需要手动管理内存的分配和释放,
需要确保正确地释放已使用的内存,避免内存泄漏和野指针等问题。

对c_中malloc_free和new_delete的探讨_戴春燕

对c_中malloc_free和new_delete的探讨_戴春燕

对c++中malloc/free和new/delete的探讨Ξ戴春燕,徐智文(包钢(集团)公司包头钢铁职业技术学院,内蒙古包头014010)摘 要:函数malloc/free和运算符new/delete是c与c++中进行动态内存分配必不可少的工具。

文章从语法、功能以及它们的相同点与不同点等方面介绍了malloc/free和new/delete在内存分配上的应用。

关键词:C++;对象;malloc;free;new;delete中图分类号:TP311 文献标识码:B 文章编号:1009-5438(2009)01-0059-02Discussion about Malloc/Free and N e w/Delete in C++DAI Chun-yan,XU Zhi-wen(Baotou Vocational and Technical College o f Iron&Steel,Baotou014010,Nei Monggol,China) Abstract:The function malloc/free and the operator new/delete are abs olutely necessary tools to distribute dynamic mem ory in c and c++.From syntax,function,the sameness and difference between malloc/free and new/delete,the article introduces the application in distribution of dynamic mem ory. K ey w ords:C++;object;malloc;free;new;delete 程序员编程时经常要进行内存分配,动态内存分配技术可以保证在程序运行过程中按照实际需要申请适量的内存,使用结束后释放。

C_c++语言面试宝典(保证你通过面试)

C_c++语言面试宝典(保证你通过面试)

12.将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?
格式:类型标识符 &函数名(形参列表及类型说明){ //函数体 } 好处:在内存中不产生被返回值的副本;(注意:正是因为这点原因,所以返回一个局 部变量的引用是不可取的。因为随着该局部变量生存期的结束,相应的引用也会失效,产生 runtime error! 注意事项: (1)不能返回局部变量的引用。这条可以参照 Effective C++[1]的 Item 31。主要原因是 局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指 "的引用,程序会进入
2.delete 与 delete []区别
delete 只会调用一次析构函数,而 delete[] 会调用每一个成员的析构函数。在 More Effective C++中有更为详细的解释:“当 delete 操作符用于数组时,它为每个数组元素调用 析构函数,然后调用 operatordelete 来释放内存。”delete 与 New 配套,delete []与 new []配套
你真诚的朋友:左老师
1.new、delete、malloc、free 关系
delete 会调用对象的析构函数,和 new 对应 free 只会释放内存,new 调用构造函数。malloc 与 free 是 C++/C 语言的标准库函数,new/delete 是 C++的运算符。它们都可用于申请动态内 存和释放内存。对于非内部数据类型的对象而言,光用 maloc/free 无法满足动态对象的要求。 对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于 malloc/free 是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析 构函数的任务强加于 malloc/free。因此 C++语言需要一个能完成动态内存分配和初始化工作 的运算符 new,以及一个能完成清理与释放内存工作的运算符 delete。注意 new/delete 不是 库函数。

深入理解C语言的new[]和delete[]

深入理解C语言的new[]和delete[]

深⼊理解C语⾔的new[]和delete[]⽬录1、重载操作符2、new和delete的原理3、new[]和delete[]的原理总结c++的动态内存管理⽅式和c语⾔不⼀样,在c++中使⽤new和delete来替换c语⾔中的malloc和free。

这⾥有⼏个点不⼀样,1、new和delete是操作符,malloc和free是函数(我的理解是c++将new和delete约定为操作符⽽已,new和delete操作符重载函数本质上还是函数)2、c++有了类的概念,类对象的初始化除了要分配内存,还需要对内存进⾏初始化!所以,c++必须引⼊⼀种新的内存分配⽅式,既可以像malloc⼀样开辟内存,还要能够调⽤类对象的构造函数(delete的引⼊同理)。

3、new[]和delete[]是c++完全新增的内存操作符,他们和new和delete也是有不⼀样的地⽅。

下⾯,咱们来⼀⼀讲解⬇1、重载操作符既然new和delete都是操作符,咱们可以对new和delete进⾏重载;当你再使⽤new和delete操作内存时,编译器就会调⽤到咱们⾃⼰重载的new/delete全局函数了。

(如对操作符重载不了解的,请⾃⾏补充知识)void* operator new(size_t size){if(size == 0) size = 1;void* ptr = malloc(size);if(ptr == nullptr){std::cout << "ERROR NEW!" << std::endl;}std::cout << "NEW Memory Size = " << size << " address = " << ptr << std::endl;return ptr;}void* operator new[](size_t size){if(size == 0) size = 1;void* ptr = malloc(size);if(ptr == nullptr){std::cout << "ERROR NEW[]!" << std::endl;}std::cout << "NEW[] Memory Size = " << size << " address = " << ptr << std::endl;return ptr;}void operator delete(void* ptr){std::cout << "DELETE " << ptr << std::endl;if(ptr) free(ptr);}void operator delete[](void* ptr){std::cout << "DELETE[] " << ptr << std::endl;if(ptr) free(ptr);}此时,再使⽤ int* p = new int {1}; 开辟内存,那么,c++编译器会⾃动链接到我们刚才的操作符重载函数 void*operator new(size_t size) ,⾄于编译器是怎么将 int* p = new int {1}; 解析成 void* operator new(size_t size) 函数的,咱们不关⼼,咱们只要知道编译器做了这样⼀层代码解析转换即可。

new_delete与free_malloc的区别

new_delete与free_malloc的区别

一、操作对象不同
malloc/free是库函数,而new/delete是C++的运算符。

前者只是分配大小设置好的内存空间,而后者可以通过new调用构造函数创建对象,通过delete调用这是二者操作对象的不同。

二、用法上的不同
malloc返回值的类型是void *,所以调用时要进行显式的转换。

malloc函数本身不能识别要申请的内存是什么类型,它只关心内存的总字节数。

如果p是NULL指针,那么free对p无论操作多少次也不会出问题。

如果不是NULL,那么free对p连续操作两次就会导致程序运行出错。

运算符new使用起来要比函数malloc简单很多,这是因为new内置了sizeof、类型转换和类型安全检查功能。

在使用new的时候,还可以实现初始化对内存的初始化工作。

因此:
1、new是自动计算需要分配的内存空间,而malloc需要手动计算。

2、new是类型安全的,malloc不是的。

3、对于对象而言,new会调用construct,而malloc不会;delete会调用destructor,free不会。

5、malloc/free需要库文件支持,new/delete不需要。

C++中free()与delete的区别

C++中free()与delete的区别

C++中free()与delete的区别1、new/delete是C++的操作符,⽽malloc/free是C中的函数。

2、new做两件事,⼀是分配内存,⼆是调⽤类的构造函数;同样,delete会调⽤类的析构函数和释放内存。

⽽malloc和free 只是分配和释放内存。

3、new建⽴的是⼀个对象,⽽malloc分配的是⼀块内存;new建⽴的对象可以⽤成员函数访问,不要直接访问它的地址空间;malloc分配的是⼀块内存区域,⽤指针访问,可以在⾥⾯移动指针;new出来的指针是带有类型信息的,⽽malloc返回的是void指针。

4、new/delete是保留字,不需要头⽂件⽀持;malloc/free需要头⽂件库函数⽀持。

我们看⼀看malloc/free和new/delete如何实现对象的动态内存管理,见⽰例。

1class Obj2 {3public:4 Obj() { cout << "Initialization" << endl; }5 ~Obj() { cout << "Destroy" << endl; }6void Initialize() { cout << "Initialization" << endl; }7void Destroy() { cout << "Destroy" << endl; }8 };910void UseMallocFree()11 {12 Obj *a = (Obj*)malloc(sizeof(obj));13 a->Intialize();14// ...15 a->Destroy();16free(a);17 }1819void UseNewDelete()20 {21 Obj *a = new Obj;22//...23delete a;24 }类Obj的函数Initialize模拟了构造函数的功能,函数Destroy模拟了析构函数的功能。

malloc和new的用法

malloc和new的用法

malloc和new的用法在C和C++编程中,动态内存分配是一种非常重要的技术。

由于程序在运行时可能需要动态地创建变量和数据结构,需要使用动态内存分配技术来满足这些需求。

在C语言中,我们使用malloc函数来动态分配内存;在C++语言中,我们使用new运算符来实现动态内存分配。

1. malloc函数malloc函数的原型如下:void *malloc(size_t size);其中,size_t是一个无符号整数类型,用来表示需要分配的内存空间的大小。

malloc函数返回一个void指针类型,它指向分配的内存空间的起始地址。

如果分配失败,malloc函数返回NULL。

使用malloc函数动态分配内存的步骤如下:(1) 通过调用malloc函数分配内存空间。

(2) 对内存空间进行初始化。

(3) 使用分配的内存空间。

(4) 使用完毕后,需要使用free函数释放内存空间。

2. new运算符new运算符是C++中用于动态分配内存的操作符,它的语法如下:new 类型名 [初始化列表]其中,类型名表示需要分配的内存空间的类型,初始化列表是可选的,用来对分配的内存空间进行初始化。

new运算符返回一个指向类型名所表示的类型的指针。

使用new运算符动态分配内存的步骤如下:(1) 通过调用new运算符分配内存空间。

(2) 对内存空间进行初始化。

(3) 使用分配的内存空间。

(4) 使用完毕后,需要使用delete运算符释放内存空间。

3. malloc和new的区别(1) malloc函数是C语言中的函数,new运算符是C++语言中的运算符。

(2) malloc函数分配的内存空间必须使用free函数释放,而new运算符分配的内存空间必须使用delete运算符释放。

(3) malloc函数分配的内存空间不会被初始化,而new运算符分配的内存空间可以使用初始化列表进行初始化。

(4) new运算符可以自动计算需要分配的内存空间的大小,而malloc函数需要手动指定需要分配的内存空间的大小。

内存分配方式,堆区,栈区,new、delete、malloc、free

内存分配方式,堆区,栈区,new、delete、malloc、free

1.内存分配方式内存分配方式有三种:[1]从静态存储区域分配。

内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。

例如全局变量,static变量。

[2]在栈上创建。

在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。

[3]从堆上分配,亦称动态内存分配。

程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。

动态内存的生存期由程序员决定,使用非常灵活,但如果在堆上分配了空间,就有责任回收它,否则运行的程序会出现内存泄漏,频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

2.程序的内存空间一个程序将操作系统分配给其运行的内存块分为4个区域,如下图所示。

,1、栈区(stack)由编译器自动分配释放,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

其操作方式类似于数据结构中的栈。

2、堆区(heap)一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。

分配方式类似于链表。

3、全局区(静态区)(static)存放全局变量、静态数据、常量。

程序结束后有系统释放4、文字常量区常量字符串就是放在这里的。

程序结束后由系统释放。

5、程序代码区存放函数体(类成员函数和全局函数)的二进制代码。

下面给出例子程序,3.堆与栈的比较3.1申请方式stack: 由系统自动分配。

例如,声明在函数中一个局部变量int b; 系统自动在栈中为b开辟空间。

heap: 需要程序员自己申请,并指明大小,在C中malloc函数,C++中是new运算符。

如p1 = (char *)malloc(10); p1 = new char[10];如p2 = (char *)malloc(10); p2 = new char[20];但是注意p1、p2本身是在栈中的。

new和malloc的区别深入解析

new和malloc的区别深入解析

new和malloc的区别深⼊解析1.1 malloc的全称是memory allocation,中⽂叫动态内存分配。

extern void *malloc(unsigned int num_bytes);分配长度为num_bytes字节的内存块。

如果分配成功则返回指向被分配内存的指针,分配失败返回空指针NULL。

当内存不再使⽤时,应使⽤free()函数将内存块释放。

1.2 void *malloc(int size);说明:malloc 向系统申请分配指定size个字节的内存空间,返回类型是 void* 类型。

void* 表⽰未确定类型的指针。

C,C++规定,void* 类型可以强制转换为任何其它类型的指针。

备注:void* 表⽰未确定类型的指针,更明确的说是指申请内存空间时还不知道⽤户是⽤这段空间来存储什么类型的数据(⽐如是char还是int或者...)1.3 freevoid free(void *FirstByte):该函数是将之前⽤malloc分配的空间还给程序或者是操作系统,也就是释放了这块内存,让它重新得到⾃由。

1.4注意事项申请了内存空间后,必须检查是否分配成功。

当不需要再使⽤申请的内存时,记得释放;释放后应该把指向这块内存的指针指向NULL,防⽌程序后⾯不⼩⼼使⽤了它。

这两个函数应该是配对。

如果申请后不释放就是内存泄露;如果⽆故释放那就是什么也没有做。

释放只能⼀次,如果释放两次及两次以上会出现错误(释放空指针例外,释放空指针其实也等于啥也没做,所以释放空指针释放多少次都没有问题)。

虽然malloc()函数的类型是(void *),任何类型的指针都可以转换成(void *),但是最好还是在前⾯进⾏强制类型转换,因为这样可以躲过⼀些编译器的检查。

1.5 malloc()到底从哪⾥得到了内存空间?答案是从堆⾥⾯获得空间。

也就是说函数返回的指针是指向堆⾥⾯的⼀块内存。

操作系统中有⼀个记录空闲内存地址的链表。

C++中的new VS C语言中的malloc

C++中的new VS C语言中的malloc

动作不同:在C++中,new一个对象时,程序完成对象的空间的分配的同时,构造函数也被调用,类似,delete一个对象时,对象的空间被释放的同时析构函数也被调用。

在C中,malloc和free 则没有构造函数和析构函数被调用这个动作。

当然,在没有特定的构造函数或析构函数时,C++也没有这个动作。

关于重载:在C++中,对于任何非数组的空间分配,我们可以通过定义函数名相同但参数不同的构造函数完成对构造函数的重载,而对于数组的空间分配,就只能使用默认构造函数了,若你试图去开辟一个没有默认构造函数的数组,Compiler会出错。

在C中,自然是没有重载这个事情了。

返回值不同:在C中,malloc 返回一个void *指针,需要你强制指针类型转换在C++中,你直接new一个就好。

注意,对于基本类型,这个差别是二者唯一的差别,当然不建议在C++中使用malloc+强制类型转换创建基本数据类型或者对象。

定义不同:new是操作符malloc是函数异常处理方式不同:new抛出异常malloc返回NULL 分配空间单位不同: ...by chriszeng87 2011-09-22 回复(0)相关讨论转:C++学习重点分析一、#include “filename.h”和#include 的区别#include “filename.h”是指编译器将从当前工作目录上开始查找此文件#include 是指编译器将从标准库目录中开始查找此文件二、头文件的作用加强安全检测通过头文件可能方便地调用库功能,而不必关心其实现方式三、* , &修饰符的位置对于*和&修饰符,为了避免误解,最好将修饰符紧靠变量 ...by SpringArt 2007-02-26 回复(0)我来学C++<二>我的第一个C++类#include <iostream.h>//导入头文件class Point{//定义类/* 类的定义可以用class 和struct来定义struct 定义的类的成员函数和成员变量默认为public class 定义的类的成员函数和成员变量默认为pritive */ public: int x; int y; Point(){//构造函 ...by zhaojuan8 2009-03-17 回复(2)从main.c开始走进Ruby-登上调试 ...我想更深入的了解Ruby内部的实现,出发点或许过于天真,我想了解下这门语言的实现,从中或许可以学习到某些思路,比如:如果我们要设计另外一种动态语言该如何去下手,如何将其他语言的特性融合进Ruby或者我们要设计的语言,特定领域的特定语言该如何设计(不要一门又广又全的语言,但又不是DSL)。

C语言中的malloc和C++中new的区别

C语言中的malloc和C++中new的区别

n ew和malloc的区别1、new 是c++中的操作符,malloc是c 中的一个函数2、new 不止是分配内存,而且会调用类的构造函数,同理delete会调用类的析构函数,而malloc则只分配内存,不会进行初始化类成员的工作,同样free也不会调用析构函数3、内存泄漏对于malloc或者new都可以检查出来的,区别在于new可以指明是那个文件的那一行,而malloc没有这些信息。

4、new 和malloc效率比较new 有三个字母, malloc有六个字母new可以认为是malloc加构造函数的执行。

new出来的指针是直接带类型信息的。

而malloc返回的都是void指针。

一:new delete 是运算符,malloc,free是函数malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。

由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

我们先看一看malloc/free和new/delete如何实现对象的动态内存管理,见示例。

class Obj{public :Obj(void){ cout << “Initialization” << endl; }~Obj(void){ cou t << “Destroy” << endl; }void Initialize(void){ cout << “Initialization” << endl; }void Destroy(void){ cout << “Destroy” << endl; }};void UseMallocFree(void){Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存a->Initialize(); // 初始化//…a->Destroy(); // 清除工作free(a); // 释放内存}void UseNewDelete(void){Obj *a = new Obj; // 申请动态内存并且初始化//…delete a; // 清除并且释放内存}示例用malloc/free和new/delete如何实现对象的动态内存管理类Obj的函数Initialize模拟了构造函数的功能,函数Destroy模拟了析构函数的功能。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

相同点:都可用于申请动态内存和释放内存
不同点:
(1)操作对象有所不同。

malloc与free是C++/C 语言的标准库函数,new/delete 是C++的运算符。

对于非内部数据类的对象而言,光用maloc/free 无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数,对象消亡之前要自动执行析构函数。

由于malloc/free 是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加malloc/free。

(2)在用法上也有所不同。

函数malloc 的原型如下:
void * malloc(size_t size);
用malloc 申请一块长度为length 的整数类型的内存,程序如下:
int *p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上:“类型转换”和“sizeof”。

malloc 返回值的类型是void *,所以在调用malloc 时要显式地进行类型转换,将void * 转换成所需要的指针类型。

malloc 函数本身并不识别要申请的内存是什么类型,它只关心内存的总字节数。

函数free 的原型如下:
void free( void * memblock );
为什么free 函数不象malloc 函数那样复杂呢?这是因为指针p 的类型以及它所指的内存的容量事先都是知道的,语句free(p)能正确地释放内存。

如果p 是NULL 指针,那么free
对p 无论操作多少次都不会出问题。

如果p 不是NULL 指针,那么free 对p连续操作两次就会导致程序运行错误。

new/delete 的使用要点
运算符new 使用起来要比函数malloc 简单得多,例如:
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
这是因为new 内置了sizeof、类型转换和类型安全检查功能。

对于非内部数据类型的对象而言,new
在创建动态对象的同时完成了初始化工作。

如果对象有多个构造函数,那么new 的语句也可以有多种形式。

如果用new 创建对象数组,那么只能使用对象的无参数构造函数。

例如
Obj *objects = new Obj[100]; // 创建100 个动态对象
不能写成
Obj *objects = new Obj[100](1);// 创建100 个动态对象的同时赋初值1
在用delete 释放对象数组时,留意不要丢了符号…[]‟。

例如
delete []objects; // 正确的用法
delete objects; // 错误的用法
后者相当于delete objects[0],漏掉了另外99 个对象。

///////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
1new自动计算需要分配的空间,而malloc需要手工计算字节数
2 new是类型安全的,而malloc不是,比如:
int* p = new float[2]; // 编译时指出错误
int* p = malloc(2*sizeof(float)); // 编译时无法指出错误
new operator 由两步构成,分别是operator new 和construct
3 operator new对应于malloc,但operator new可以重载,可以自定义内存分配策略,甚至不做内存分配,甚至分配到非内存设备上。

而malloc无能为力
4new将调用constructor,而malloc不能;delete将调用destructor,而free不能。

5 malloc/free要库文件支持,new/delete则不要。

///////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
1. 本质区别
malloc/free是C/C++语言的标准库函数,new/delete是C++的运算符。

对于用户自定义的对象而言,用maloc/free无法满足动态管理对象的要求。

对象在创建的同时要自动执
行构造函数,对象在消亡之前要自动执行析构函数。

由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。

class Obj
{
public :
Obj() { cout <<“Initialization”<< endl; }
~Obj() { cout <<“Destroy”<< endl; }
void Initialize() { cout <<“Initialization”<< endl; }
void Destroy() { cout <<“Destroy”<< endl; }
};
void UseMallocFree()
{
Obj *a = (obj *) malloc( sizeof( obj ) ); // allocate memory
a->Initialize(); // initialization //…
a->Destroy(); // deconstruction
free(a); // release memory
}
void UseNewDelete(void)
{
Obj *a =new Obj;
//…
delete a;
}
类Obj的函数Initialize实现了构造函数的功能,函数Destroy实现了析构函数的功能。

函数UseMallo cFree中,由于malloc/free不能执行构造函数与析构函数,必须调用成员函数Initialize和Destroy来完成“构造”与“析构”。

所以我们不要用malloc/free来完成动态对象的内存管理,应该用new/delete。

由于内部数据类型的“对象”没有构造与析构的过程,对它们而言malloc/free和new/delete是等价的。

2. 联系
既然new/delete的功能完全覆盖了malloc/free,为什么C++还保留malloc/free呢?因为C++程序经常要调用C函数,而C程序只能用malloc/free管理动态内存。

如果用free释放“new创建的动态对象”,那么该对象因无法执行析构函数而可能导致程序出错。

如果用delete释放“malloc申请的动态内存”,理论上讲程序不会出错,但是该程序的可读性很差。

所以new/delete,malloc/free必须配对使用。

///////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////。

相关文档
最新文档