malloc和new区别

合集下载

C++辅导:内存分配和释放

C++辅导:内存分配和释放

内存分配和释放⼏乎是所有程序的基本要求,同时也是最容易出现问题的地⽅之⼀。

通过遵循⼏条简单的规则,你可以避免很多常见的内存分配问题。

原则1 ⽤new、delete取代malloc、calloc、realloc和freemalloc、calloc、realloc和free是C语⾔的⽤法,它们不会理会对象的存在与否,更不会去调⽤构造和析构函数,所以在C++中经常会引起⿇烦。

如果混⽤这些函数会造成更⼤的⿇烦。

⽐如要防⽌⽤malloc分配,⽤delete释放,这些都需要花费格外的精⼒。

原则2 new、delete和new[]、delete[]要成对使⽤调⽤new所包含的动作:从系统堆中申请恰当的⼀块内存。

若是对象,调⽤相应类的构造函数,并以刚申请的内存地址作为this参数。

调⽤new[n]所包含的动作:从系统堆中申请可容纳n个对象外加⼀个整型的⼀块内存;将n记录在额外的哪个整型内存中。

(其位置依赖于不同的实现,有的在申请的内存块开头,有的在末尾);调⽤n次构造函数初始化这块内存中的n个连续对象。

调⽤delete所包含的动作:若是对象,调⽤相应类的析构函数(在delete参数所指的内存处);该该内存返回系统堆。

调⽤delete[]所包含的动作:从new[]记录n的地⽅将n值找出;调⽤n次析构函数析构这快内存中的n个连续对象;将这⼀整快内存(包括记录n的整数)归还系统堆。

可以看出,分配和释放单个元素与数组的操作不同,这就是为什么⼀定要成对使⽤这些操作符的原因。

原则3 确保所有new出来的东西适时被delete掉不需要的内存不能及时被释放(回系统)就是⼤家常听到的内存泄露(memory leak)。

狭义的内存泄露是指分配的内存不再使⽤,从更⼴义上说,没有及时释放也是内存泄露,只是程度较轻⽽已。

内存泄露不管有多少,只要运⾏的时间够长,最终都回耗尽所有的内存。

内存泄露的问题极难查找,因为当出现问题时,内存已然耗尽,此时CPU正在运⾏什么程序,什么程序就崩溃(哪怕是系统程序)。

C++笔试题(华为)

C++笔试题(华为)

1. 写出判断ABCD四个表达式是否正确,若正确,写出经过表达式中a的值(3分)int a = 4;(A) a += (a++); (B) a += (++a); (C) (a++) += a; (D) (++a) += (a++);a = ?答:C错误,左侧不是一个有效变量,不能赋值,可改为(++a) += a;改后答案依次为9,10,10,112. 某32位系统下,C++程序,请计算sizeof的值(5分)char str[] = "ALLEN";char *p = str;int n = 10;请计算(1) sizeof(str) = ?(2) sizeof(p) = ?(3) sizeof(n) = ?(4) void *pp = malloc(100);sizeof(pp) = ?答:(1) 6 (2) 4 (3) 4 (4) 43. 回答下面的问题. (4分)(1) 头文件中的ifndef/define/endif干什么用?答:防止头文件被重复引用。

(2) #include <filename.h>和#include "filename.h"有什么区别?答:前者用来包含开发环境提供的库头文件,后者用来包含自己编写的头文件。

(3) 在C++程序中调用被C编译器编译后的函数,为什么要加extern "C"声明?答:函数和变量被C++编译后在符号库中的名字与C语言的不同,被extern "C"修饰的函数和变量是按照C语言方式编译和连接的。

由于编译后的名字不同,C++程序不能直接调用C函数。

C++提供了一个C连接交换指定符号extern "C"来解决这个问题。

(4) switch()中不允许的数据类型是?答:实型。

4. 回答下面的问题(6分)(1) void GetMemory(char **p, int num){*p = (char *)malloc(num);}void Test(void){char *str = NULL;GetMemory(&str, 100);strcpy(str, "hello");printf(str);}请问运行Test函数会有什么样的结果?答:输出“hello”。

指针类型

指针类型


编译程序将按下面来解释:
int max(int *x,int num) { ...... ... *(x+i) ... ...... }
int main() { int a[10]; ...... ...max(&a[0],10)... .... }
避免指针参数带来的副作用

指针作为形参的类型可以产生两个效果:
指向常量的指针作为函数形参类型

如果只需要指针参数的第一种效果,则应把形参定 义为指向常量的指针。例如:
void g(const A *p) //A为一个结构类型 { ...... p->no = ... //Error,不能改变p所指向的数据。 } 再例如: void f(const int *p,int num) //或者, void f(const int p[],int num) { ....... p[i] = ... //Error,不能改变p所指向的数据。 ...... }
指针作为函数返回值类型

函数的返回值类型可以是一个指针类型。例如:
int *max(int x[], int num) { int max_index=0; for (int i=1; i<num; i++) if (x[i] > x[max_index]) max_index = i; return &x[max_index]; }
指针类型的定义

指针类型的定义格式为:
typedef <类型> *<指针类型名>; • 其中,<指针类型名>表示一个指针类型,其 值集为<类型>所表示的数据的地址,例如: typedef int *Pointer; • 上面定义了一个指针类型Pointer,其值集为所 有int变量的地址。

用C的malloc和C++的new开辟空间的区别

用C的malloc和C++的new开辟空间的区别

1. new 不但分配对象空间, 还会在分配后调用对象的构造函数,需要手动使用delete来调用析构函数释放空间,而malloc 只是分配, 不构造:class A{public:A(): m_value(0){}//构造函数public:int m_value;};struct B{Int a;};A *pb1 = new A;Struct B *pb2 = (B *)malloc(sizeof(B));pb1 因为被new 调用了构造函数, 所以pb1->m_value == 0, pb2 的构造函数没有被调用, 所以pb2->m_value 的值不确定(即未初始化).2. new 分配时要指定类型, 是类型安全的; 而malloc 返回的是void *, 类型不安全; 类型不安全的东西在C++ 里是不被提倡的!3.引用只是别名不能作为指针来直接使用,&p=new int;是错误的,但是可以定义如下:int *p=new int;int &rp=p;这样的是rp为指针变量p的别名,*rp就是指针变量p所指向的内容。

4.指针可以指向不同的地址,但是引用不能,它只能指向一个,如:int *p=new int;//引用必须要为对象int a,b;p=&a;p=&b;可以使用。

Int a,b;Int &rt=a;&rt=b;会出现错误。

指针不用初始化,但是引用必须初始化。

int &ra;&ra=a;会报错。

引用的一定是对象,否则会出错如:int *p;int &rp=p;会出错。

5.引用只能在块中使用,不能出块。

如:{int a;int &ra=a;ra=9;}ra=10;//出错,因为出了定义引用的块,他只能在相应的{}中使用。

6.const A *const(cost A *const one)中的各个const的意义如下:(1):表示返回的指针值的对象是不能修改的(2):表示返回的指针是不可以修改的(3):表示指针变量one所指的内容是不可以修改的(4):表示指针变量one是不可以修改的。

malloc、calloc、new的区别

malloc、calloc、new的区别

malloc、calloc、new的区别这⼏个都是动态申请空间⽤到的关键字。

malloc定义:calloc定义:new定义:、FutureNow这个⼈整理的挺好的。

malloc和calloc的区别:calloc在动态分配完内存后,⾃动初始化该内存空间为零,⽽不做初始化,分配到的空间中的数据是随机数据。

其中malloc的简介如下:原型:extern void* malloc(unsigned int size); [1]功能:动态分配内存;注意:size仅仅为申请内存字节⼤⼩,与申请内存块中存储的数据类型⽆关,故编程时建议通过以下⽅式给出,"长度 * sizeof(数据类型)"; [2]calloc的⽤法:void *calloc(size_t nmenb, size_t size);calloc()函数为nmemb个元素的数组分配内存空间,其中,每个元素的长度都是size个字节。

如果要求的空间⽆效,那么此函数返回。

在分配了内存之后,calloc()函数会通过将所有位设置为0的⽅式进⾏初始化。

⽐如,调⽤calloc()函数为n个整数的数组分配存储空间,且保证所有整数初始化为0:pi = calloc(n, sizeof(int));因为calloc()函数会清空分配的内存,⽽malloc()函数不会,所以可以调⽤以“1”作为第⼀个实参的calloc()函数,为任何类型的数据项分配空间。

⽐如:struct point{ int x, y;} *pi;pi = calloc(1, sizeof(struct point));在执⾏此语句后,pi将指向⼀个结构体,且此的成员x和y都会被设为0。

⼀般使⽤后要使⽤ (起始地址的指针) 对内存进⾏释放,不然内存申请过多会影响计算机的性能,以⾄于得重启电脑。

如果使⽤过后不清零,还可以使⽤该指针对该块内存进⾏访问。

头⽂件:或.h [1]以上两个进⾏动态分配的空间,⽤完了之后需要⼈为的进⾏动态的释放。

malloc和calloc区别

malloc和calloc区别

函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。

malloc()函数有一个参数,即要分配的内存空间的大小:void *malloc(size_t size);calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。

void *calloc(size_t numElements,size_t sizeOfElement);如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。

函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,而后者能。

如果由malloc()函数分配的内存空间原来没有被使用过,则其中的每一位可能都是0;反之,如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。

也就是说,使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。

函数calloc()会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。

需要包含头文件:#include <syslib.h>#i nclude<malloc.h>函数声明(函数原型):void *malloc(int size);说明:malloc 向系统申请分配指定size个字节的内存空间。

返回类型是void* 类型。

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

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

从函数声明上可以看出。

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

c语言中 new 的含义

c语言中 new 的含义在C语言中,`new`并不是一个原生的关键字或标准库函数,而是一种常见的编程习惯,通常用于动态分配内存。

它的含义是通过动态内存分配,创建一个新的数据对象。

让我们来了解一下`new`在C语言中的用法和含义。

在C语言中,我们可以使用`malloc`函数来动态分配内存。

`malloc`函数的原型如下:```cvoid *malloc(size_t size);```而使用`new`来进行动态内存分配的一般方法如下所示:```c#include <stdlib.h>int *ptr;ptr = (int*)malloc(sizeof(int));```上述代码中,我们首先声明了一个名为`ptr`的指针变量,然后调用`malloc`函数来分配一个`int`类型的内存空间。

在这里,通过`(int*)`进行了类型转换,将`void*`指针转换为`int*`类型指针,以便程序知道所分配的内存空间的类型。

使用`new`的好处之一是,它可以自动计算所需内存的大小,这使得分配更加方便。

例如,如果要分配一个`int`数组,可以使用以下代码:```c#include <stdlib.h>int *arr;int size = 5; // 数组大小arr = (int*)malloc(size * sizeof(int));```在上述代码中,我们使用`malloc`函数分配了一个包含5个`int`元素的数组的内存空间。

通过将所需的内存大小计算为`size * sizeof(int)`,我们可以确保分配足够的内存空间来容纳整个数组。

虽然`new`不是C语言的原生特性,但在某些特定的C编译器和编程环境中,您可能会发现`new`关键字被用作动态内存分配的替代方法。

但是,请注意这不是C语言标准要求的行为,因此在编写C代码时,使用`malloc`函数是更为常见和推荐的方法。

总结一下,`new`在C语言中的含义是使用动态内存分配来创建新的数据对象。

堆分配存储的方法

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

常见的堆分配存储的方法有以下几种:
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++基础

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 C++的new

c语言new:C++的new“new”是C++的一个关键字,同时也是操作符。

关于new的话题非常多,因为它确实比较复杂,也非常神秘,下面我将把我了解到的与new有关的内容做一个总结。

new的过程当我们使用关键字new在堆上动态创建一个对象时,它实际上做了三件事:获得一块内存空间、调用构造函数、返回正确的指针。

当然,如果我们创建的是简单类型的变量,那么第二步会被省略。

假如我们定义了如下一个类A:class A{int i;public:A(int _i) :i(_i*_i) {}void Say() { printf("i=%dn", i); }};//调用new:A* pa = new A(3);那么上述动态创建一个对象的过程大致相当于以下三句话(只是大致上):A* pa = (A*)malloc(sizeof(A));pa->A::A(3);return pa;虽然从效果上看,这三句话也得到了一个有效的指向堆上的A对象的指针pa,但区别在于,当malloc失败时,它不会调用分配内存失败处理程序new_handler,而使用new的话会的。

因此我们还是要尽可能的使用new,除非有一些特殊的需求。

new的三种形态到目前为止,本文所提到的new都是指的“new operator”或称为“new expression”,但事实上在C++中一提到new,至少可能代表以下三种含义:new operator、operator new、placement new。

new operator就是我们平时所使用的new,其行为就是前面所说的三个步骤,我们不能更改它。

但具体到某一步骤中的行为,如果它不满足我们的具体要求时,我们是有可能更改它的。

三个步骤中最后一步只是简单的做一个指针的类型转换,没什么可说的,并且在编译出的代码中也并不需要这种转换,只是人为的认识罢了。

但前两步就有些内容了。

new operator的第一步分配内存实际上是通过调用operator new来完成的,这里的new实际上是像加减乘除一样的操作符,因此也是可以重载的。

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

常量对象的动态分配
const int *pic = new const int(1024); * const 对象必须被初始化, 否则会编译错误,(因此我们也不能创建const数组,因为const数组不能被初始化,除了类数组) * 用new表达式返回的值作为初始值的指针必须是一个指向const类型的指针. eg: const int * 它的生命期同样也用delete表达式来结束 eg: delete pic; <3>定位new表达式(placement new expression) 形式: new (place_address) type-specifier 头文件: #include <new> place_adress必须是指针
输出结果:
int * int * int (*)[2] int (*)[2] int (*)[2][3] int (*)[2][3]
类别:c/c++ |
| 添加到搜藏 | 分享到i贴吧 | 浏览(250) | 评论 (0)
上一篇:科学计算与可视化课件 下一篇:Delaunay三角剖分算法
最近读者:
登录后,您就出现在 这里。
#include <typeinfo> using namespace std; int main() {
int *a%DA%BA%F5%D1%D8%CD%BE%B5%C4%B7%E7%B... 2010-11-26
C/C++中 mallnt; //assign
/%D4%DA%BA%F5%D1%D8%CD%BE%B5%C4%B7%E7%B... 2010-11-26
C/C++中 malloc和new区别_人生是一场旅行的空间_空间Page 2 of 3
*q = i;
外的所有维数。例如: int *p1 = new int[10]; 返回的是一个指向int的指针int*
int (*p2)[10] = new int[2][10]; new了一个二维数组, 去掉最左边那一维[2], 剩下int[10], 所以返回的是一个指向int[10]这种一维数组的指针int (*)[10]. int (*p3)[2][10] = new int[5][2][10]; new了一个三维数组, 去掉最左边那一维[5], 还有int[2][10], 所以返回的是一个指向二维数组int[2][10] 这种类型的指针int (*)[2][10]. #include<iostream>
_堕落天使
愚中作乐
Maple_HL
fans_cs
diamondevil
savioryu
网友评论:
deneb
stoneboy100 200
发表评论:
内 %D8%CD%BE%B5%C4%B7%E7%B... 2010-11-26
int main(){ //char* p=new char("Hello"); //error分配一个char(1字节)的空间, //用"Hello"来初始化,这明显不对
char* p=new char[6];
//p="Hello"; //不能将字符串直接赋值给该字符指针p,原因是: //指针p指向的是字符串的第一个字符,只能用下面的
eg: int *buf = new int[2]; int *pb = new (buf) int;
*pb = 11; cout << *pb << endl; cout << *buf << endl; cout << pb << endl; cout << buf << endl;
// 11 // 11
Page 3 of 3
int *b = new int[]; int (*c)[2] = new int[34][2]; int (*d)[2] = new int[][2]; int (*e)[2][3] = new int[34][2][3]; int (*f)[2][3] = new int[][2][3]; a[0] = 1; b[0] = 1; //运行时错误,无分配的内存,b只起指针的作用,用来指向相应的数据 c[0][0] = 1; d[0][0] = 1;//运行时错误,无分配的内存,d只起指针的作用,用来指向相应的数据 e[0][0][0] = 1; f[0][0][0] = 1;//运行时错误,无分配的内存,f只起指针的作用,用来指向相应的数据 cout<<typeid(a).name()<<endl; cout<<typeid(b).name()<<endl; cout<<typeid(c).name()<<endl; cout<<typeid(d).name()<<endl; cout<<typeid(e).name()<<endl; cout<<typeid(f).name()<<endl; delete[] a; delete[] b; delete[] c; delete[] d; delete[] e; delete[] f; }
//strcpy strcpy(p,"Hello"); cout<<*p<<endl; cout<<p<<endl; delete[] p;
//只是输出p指向的字符串的第一个字符! //输出p指向的字符串!
return 0;}
输出结果: H
Hello 3. 当使用new运算符定义一个多维数组变量或数组对象时,它产生一个指向数组第一个元素的指针,返回的类型保持了除最左边维数
// 同样pb跟buf的所指向的地址也是相同的 //
int *pp = new (buf + 1) int; *pp = 22; * 因为定位符并不分配内存,所以我们并没有与定位符相匹配的delete表达式, 对此我们需要删除的是分配内存的指针,在上面的例子中 我们 delete [] buf;new和delete运算符用于动态分配和撤销内存的运算符. c++中new的几种用法 在释放时有区别。你用new申请的堆内存,你有释放它的义务和责任,你必须用delete释放它,否则会造成内存泄漏,即memory lea k, 对于一个对象而言,释放它的方式取决于你的构造函数,是否用到new申请内存。但是例2的指针是一定要用delete释放的。 c++中,new的用法很灵活,这里进行了简单的总结: 1. new() 分配这种类型的一个大小的内存空间,并以括号中的值来初始化这个变量; 2. new[] 分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这些变量; #include<iostream> #include<cstring> using namespace std;
查看文章
C/C++中 malloc和new区别 2009/05/14 21:06
1,malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。 2,对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡 之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的 任务强加于malloc /free. 3,因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以一个能完成清理与释放内存工作的运算符delete.注意ne w/delete不是库函数。 4,C++程序经常要调用C函数,而C程序只能用malloc/free管理动态内存 new 是个操作符,和什么"+","-","="……有一样的地位。 malloc是个分配内存的函数,供你调用的。 new是保留字,不需要头文件支持。 malloc需要头文件库函数支持。 new 建立的是一个对象, malloc分配的是一块内存。 new建立的对象你可以把它当成一个普通的对象,用成员函数访问,不要直接访问它的地址空间 malloc分配的是一块内存区域,就用指针访问好了,而且还可以在里面移动指针。 简而言之: new 是一个操作符,可以重载 malloc是一个函数,可以覆盖 new 初始化对象,调用对象的构造函数,对应的delete调用相应的析构函数 malloc仅仅分配内存,free仅仅回收内存 三种形式的new表达式 <1> 单个对象的动态分配 <2> 数组的动态分配 <3> 定位new表达式 <1>int *pi = new int(11); // initializer
pi[i] = 0; * 动态数组的第一维不必是常量值, 这样就不必在编译时刻就知道维数,我们可以根据需要分配大小合适的内存单元 * 释放动态数组: delete [ ] pi; 如果不小心忘记了空括号,编译器不会捕捉到这个错误, 务必要小心 * 一般为了避免动态分配数组带来的内存管理的问题, 我们使用c++ 的 标准库vector, list or string 会自动管理内存的容器类型 ---------------------
C/C++中 malloc和new区别_人生是一场旅行的空间_空间Page 1 of 3
人生是一场旅行的空间
今天很残酷,明天很残酷,后天很美好,大部分人死 在明天晚上,见不到后天的太阳! 最大的失败是放 弃,最大的敌人是自己,最大的对手是时间!
相关文档
最新文档