malloc和delete

c++内存分配机制

C++的内存分配机制可以分为四个区域：堆区、栈区、全局/静态存储区和常量存储区。

1. 堆区：动态内存分配区，程序在运行时可以向该区域申请一定大小的内存，用malloc或new来申请，用free或delete来释放。

2. 栈区：存放函数的参数值和局部变量，由编译器自动分配和释放，其操作方式类似于数据结构中的栈。

3. 全局/静态存储区：全局变量和静态变量被存放在此区域中，包括初始化的全局变量和静态变量（空白初始化的全局变量和静态变量也会被存放在此区域），全局变量和静态变量在程序整个运行期间一直被保留。

4. 常量存储区：常量被存放在此区域中，不允许修改。

C++内存分配机制遵循二八定律，即80%的内存空间被80%的程序所使用，而剩下的20%的内存空间则被浪费。

因此，在编写C++程序时，应该尽可能地利用好内存空间，避免内存空间的浪费。

cc++动态申请数组

cc++动态申请数组new和delete运算符⽤于动态分配和撤销内存的运算符new使⽤⽅法:1. 开辟单变量地址空间1)new int; //开辟⼀个存放数组的存储空间,返回⼀个指向该存储空间的地址.int *a = new int 即为将⼀个int类型的地址赋值给整型指针a.2)int *a = new int(5) 作⽤同上,可是同⼀时候将整数赋值为52. 开辟数组空间⼀维: int *a = new int[100];开辟⼀个⼤⼩为100的整型数组空间⼆维: int **a = new int[5][6]三维及其以上:依此类推.⼀般使⽤⽅法: new 类型 [初值]delete使⽤⽅法:1. int *a = new int;delete a; //释放单个int的空间2.int *a = new int[5];delete [] a; //释放int数组空间要訪问new所开辟的结构体空间,⽆法直接通过变量名进⾏,仅仅能通过赋值的指针进⾏訪问.⽤new和delete能够动态开辟,撤销地址空间.在编程序时,若⽤完⼀个变量(通常是临时存储的数组),下次须要再⽤,但却⼜想省去⼜⼀次初始化的功夫,能够在每次開始使⽤时开辟⼀个空间,在⽤完后撤销它.#include <iostream>using namespace std;int main(){char *p=new char[10];scanf ("%s",p);printf ("%s",p);delete []p;while (1);return 0;}这是⼆维数组的申请⽅法#define ROW 100#define COL 200#define T char (int,float,....) //通⽤数据类型T ** pTemp ;*pTemp = new T[ROW] ;for (int i = 0 ; i < COL ; i ++)pTemp[i] = new T[COL};/////////////////deletefor (int i =0 ; i < COL ; i ++)delete [] pTemp[i] ;delete [][]pTemp ;1.分配内存空间函数malloc 调⽤形式： (类型说明符*) malloc (size) 功能：在内存的动态存储区中分配⼀块长度为"size" 字节的连续区域。

new与delete区别

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

它们都可用于申请动态内存和释放内存2.对于非内部数据类型的对象(由enum，union，class、struct等关键字修饰的变量, 基本数据类型如int,char,double等都是内部数据类型,)而言，光用maloc/free无法满足动态对象的要求。

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

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

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

注意new/delete不是库函数。

4.C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

5.new可以认为是malloc加构造函数的执行。

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

而malloc 返回的都是void*指针。

new delete在实现上其实调用了malloc,free函数6.new建立的对象你可以把它当成一个普通的对象,用成员函数访问,不要直接访问它的地址空间;malloc分配的是一块内存区域,就用指针访问好了,而且还可以在里面移动指针.7.new 建立的是一个对象；malloc分配的是一块内存.相同点：都可用于申请动态内存和释放内存联系；既然new/delete的功能完全覆盖了malloc /free，为什么C++还保留malloc/free 呢？因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

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

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

c语言中new和delete的用法

c语言中new和delete的用法C语言中new和delete的用法C语言是一门底层的编程语言，不像其他高级语言一样内建有new 和delete的关键字，而是需要使用malloc和free函数来在堆内存中分配和释放内存。

然而，为了提高代码的可读性和可维护性，我们可以自定义一些函数来模拟new和delete的功能。

本文将介绍C语言中使用new和delete的几种常见用法。

使用malloc函数模拟new为了模拟C++中的new操作符，在C语言中可以定义一个名为new的函数，该函数使用malloc函数分配指定大小的内存，并返回相应的指针。

void* new(size_t size) {void* ptr = malloc(size);return ptr;}上述代码中，new函数接受一个size参数，该参数表示要分配的内存大小。

函数内部使用malloc函数分配内存，并将其返回。

使用free函数模拟delete与new函数类似，我们也可以定义一个名为delete的函数来模拟C++中的delete操作符。

void delete(void* ptr) {free(ptr);}上述代码中，delete函数接受一个指针ptr，该指针指向要释放的内存。

函数内部使用free函数释放指定的内存。

示例下面是一个使用new和delete的示例，演示如何动态分配和释放内存。

#include <>int main() {int* ptr = (int*)new(sizeof(int));*ptr = 10;printf("Value: %d\n", *ptr);delete(ptr);return 0;}上述代码首先使用new函数动态分配一个int类型的内存，并将其赋值为10。

然后，使用printf函数输出该内存的值。

最后，使用delete函数释放该内存。

总结通过定义自定义的new和delete函数，我们可以在C语言中模拟C++中的new和delete操作符的功能。

C++经典知识点面试题

C++经典知识点⾯试题1、指针的优点和缺点优点：灵活⾼效(1)提⾼程序的编译效率和执⾏速度（数组下标往下移时，需要使⽤乘法和加法，⽽指针直接使⽤++即可）(2)通过指针可使⽤主调函数和被调函数之间共享变量或数据结构，便于实现双向数据通讯。

(3)可以实现动态的存储分配。

(4)便于表⽰各种数据结构，如结构体，编写⾼质量的程序。

缺点：容易出错(1)可能变成野指针，导致程序崩溃(2)内存泄露(3)可读性差2、指针和引⽤的定义和区别(1)指针和引⽤的定义1)指针：指针是⼀个变量，存储⼀个地址，指向内存的⼀个存储单元；2)引⽤跟原来的变量实质上是同⼀个东西，只不过是原变量的⼀个别名⽽已。

(2)指针和引⽤的区别<1> 从内存分配上来说：1)指针是⼀个实体，⽽引⽤仅是个别名，即为指针分配内存，⽽不为引⽤分配内存空间；<2> 从指向的内容来说：2)引⽤只能在定义时被初始化⼀次，之后不可变；指针可变；3)引⽤不能为空，指针可以为空；4)const与指针搭配可以表⽰指针指向和指针指向内容是否可变。

const与引⽤搭配只有⼀种，即来修饰其内容的可读性。

由于引⽤从⼀⽽终，不⽤修饰其指向。

5)指针可以有多级，但是引⽤只能是⼀级(int **p；合法,⽽int &&a是不合法的)<3> 其他⽅⾯6)"sizeof引⽤"得到的是所指向的变量(对象)的⼤⼩，⽽"sizeof指针"得到的是指针本⾝的⼤⼩；7)指针和引⽤的⾃增(++)运算意义不⼀样；指针和引⽤在符号表中的形式：程序在编译时分别将指针和引⽤添加到符号表上。

在符号表上记录的是变量名及变量所对应地址。

在符号表上，指针变量对应的地址值为指针变量的地址值，⽽引⽤对应的地址值是引⽤对象的地址值。

符号表⽣成后就不会再改，因此指针可以改变指向的对象（指针变量中的值可以改），⽽引⽤对象不能改。

c++——对象的动态建立和释放（new和delete）

c++——对象的动态建⽴和释放（new和delete）3.8 对象的动态建⽴和释放1 new和delete基本语法1）在软件开发过程中，常常需要动态地分配和撤销内存空间，例如对动态链表中结点的插⼊与删除。

在C语⾔中是利⽤库函数malloc和free 来分配和撤销内存空间的。

C++提供了较简便⽽功能较强的运算符new和delete来取代malloc和free函数。

注意： new和delete是运算符，不是函数，因此执⾏效率⾼。

2）虽然为了与C语⾔兼容，C++仍保留malloc和free函数，但建议⽤户不⽤malloc和free函数，⽽⽤new和delete运算符。

new运算符的例⼦：new int; //开辟⼀个存放整数的存储空间，返回⼀个指向该存储空间的地址(即指针)new int(100); //开辟⼀个存放整数的空间，并指定该整数的初值为100，返回⼀个指向该存储空间的地址new char[10]; //开辟⼀个存放字符数组(包括10个元素)的空间，返回⾸元素的地址new int[5][4]; //开辟⼀个存放⼆维整型数组(⼤⼩为5*4)的空间，返回⾸元素的地址float *p=new float (3.14159); //开辟⼀个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变量p3）new和delete运算符使⽤的⼀般格式为：⽤new分配数组空间时不能指定初值。

如果由于内存不⾜等原因⽽⽆法正常分配空间，则new会返回⼀个空指针NULL，⽤户可以根据该指针的值判断分配空间是否成功。

1）应⽤举例2 类对象的动态建⽴和释放使⽤类名定义的对象都是静态的，在程序运⾏过程中，对象所占的空间是不能随时释放的。

但有时⼈们希望在需要⽤到对象时才建⽴对象，在不需要⽤该对象时就撤销它，释放它所占的内存空间以供别的数据使⽤。

这样可提⾼内存空间的利⽤率。

C++中，可以⽤new运算符动态建⽴对象，⽤delete运算符撤销对象⽐如：Box *pt; //定义⼀个指向Box类对象的指针变量ptpt=new Box; //在pt中存放了新建对象的起始地址在程序中就可以通过pt访问这个新建的对象。

堆分配存储的方法

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

常见的堆分配存储的方法有以下几种：
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）1.new、delete、malloc、free关系（1）delete会调用对象的析构函数，new调用构造函数。

Malloc申请内存空间，free只会释放内存。

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

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

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

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

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

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

注意new/delete不是库函数。

（5）都是在堆(heap)上进行动态的内存操作。

用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。

delete 会调用对象的destructor，而free 不会调用对象的destructor.2.delete与delete []区别delete只会调用一次析构函数，而delete[]会调用每一个成员的析构函数。

delete与New配套，delete []与new []配套MemT est*mTest1=newMemTest[10];MemT est*mTest2=newMemTest;int*pInt1=newint[10];int*pInt2=newint;delete[]pInt1; //-1-delete[]pInt2; //-2-报错，要使用deletedelete[]mTest1;//-3-delete[]mTest2;//-4-报错，使用delete这就说明：对于内建简单数据类型，delete和delete[]功能是相同的。

c++面试题自己整理比较全

1.const 符号常量；(1)const char *p(2)char const *p(3)char * const p说明上面三种描述的区别；如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。

2请讲一讲析构函数和虚函数的用法和作用？答：析构函数的作用是当对象生命期结束时释放对象所占用的资源。

析构函数用法：析构函数是特殊的类成员函数它的名字和类名相同，没有返回值，没有参数不能随意调用也没有重载。

只是在类对象生命期结束时有系统自动调用。

虚函数用在继承中，当在派生类中需要重新定义基类的函数时需要在基类中将该函数声明为虚函数，作用为使程序支持动态联遍。

3解释堆和栈的区别栈（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。

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

堆:一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。

注意它与数据结构中的堆是两回事，分配方式倒是类似于链表.4. 头文件的作用是什么?答：一、通过头文件来调用库功能。

在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。

用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。

编译器会从库中提取相应的代码。

二、头文件能加强类型安全检查。

如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。

5. 内存的分配方式的分配方式有几种?答：一、从静态存储区域分配。

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

例如全局变量。

二、在栈上创建。

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

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

详解C++中new运算符和delete运算符的使用

详解C++中new运算符和delete运算符的使⽤C++ ⽀持使⽤ new 和 delete 运算符动态分配和释放对象。

这些运算符为来⾃称为“⾃由存储”的池中的对象分配内存。

new 运算符调⽤特殊函数 operator new，delete 运算符调⽤特殊函数 operator delete。

在 Visual C++ .NET 2002 中，标准 C++ 库中的 new 功能将⽀持 C++ 标准中指定的⾏为，如果内存分配失败，则会引发std::bad_alloc 异常。

如果内存分配失败，C 运⾏库的 new 函数也将引发 std::bad_alloc 异常。

如果您仍需要 C 运⾏库的 new 的⾮引发版本，请将您的程序链接到 nothrownew.obj。

但是，当您链接到 nothrownew.obj 时，标准 C++ 库中的 new 将不再起作⽤。

调⽤ new 运算符在程序中遇到以下语句时，它将转换为对函数 operator new 的调⽤：char *pch = new char[BUFFER_SIZE];如果请求针对零字节存储，operator new 将返回⼀个指向不同的对象的指针（即对 operator new 的重复调⽤将返回不同的指针）。

如果分配请求没有⾜够的内存，则 operator new 将返回 NULL 或引发异常（有关详细信息，请参阅）。

可以编写尝试释放内存的例程并重试分配；有关详细信息，请参阅 _set_new_handler。

有关恢复⽅案的更多详细信息，请参阅以下主题：处理内存不⾜的情况。

下表中描述了 operator new 函数的两个范围。

operator new 函数的范围运算符范围::operator new全局class-name ::operator new类operator new 的第⼀个参数的类型必须为 size_t（STDDEF.H 中定义的类型），并且返回类型始终为 void *。

深入理解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) 函数的，咱们不关⼼，咱们只要知道编译器做了这样⼀层代码解析转换即可。

C语言经典面试题目及答案详解(三)

C语言经典面试题目及答案详解（三）接着更新C语言面试题，希望能帮助到大家！1、变量的声明和定义有什么区别为变量分配地址和存储空间的称为定义，不分配地址的称为声明。

一个变量可以在多个地方声明，但是只在一个地方定义。

加入 extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。

说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。

2、写出 bool 、int、 float、指针变量与“零值”比较的if 语句bool 型数据： if( flag ) {A; } else {B； } int 型数据： if( 0 != flag ) {A; } else {B； }指针型数： if( NULL == flag ) {A; } else {B； } float 型数据： if ( ( flag >= NORM ) && ( flag <= NORM ) ) {A； }注意：应特别注意在 int、指针型变量和“零值”比较的时候，把“零值”放在左边，这样当把“==”误写成“=”时，编译器可以报错，否则这种逻辑错误不容易发现，并且可能导致很严重的后果。

3、sizeof 和 strlen 的区别sizeof 和 strlen 有以下区别：1. sizeof 是一个操作符，strlen 是库函数。

2. sizeof 的参数可以是数据的类型，也可以是变量，而strlen 只能以结尾为‘\0‘的字符串作参数。

3. 编译器在编译时就计算出了 sizeof 的结果。

而 strlen 函数必须在运行时才能计算出来。

并且 sizeof 计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。

4. 数组做 sizeof 的参数不退化，传递给 strlen 就退化为指针了。

注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。

C++内存管理

C++内存管理[导语]内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。

本期专题将从内存管理、内存泄漏、内存回收这三个方面来探讨C++内存管理问题。

1 内存管理伟大的Bill Gates 曾经失言：640K ought to be enough for everybody —Bill Gates 1981程序员们经常编写内存管理程序，往往提心吊胆。

如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。

本文的内容比一般教科书的要深入得多，读者需细心阅读，做到真正地通晓内存管理。

1.1 C++内存管理详解1.1.1 内存分配方式1.1.1.1 分配方式简介在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

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

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

堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。

如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

堆栈的区别

00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
4、大小限制方面：
堆：是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
}
二、堆和栈的理论知识
2.1申请方式
stack:
由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
明确区分堆与栈
在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。

C++常见笔试题

C++方面：1、C++中内存分部可以几个区，各个分区的基本情况；在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。

里面的变量通常是局部变量、函数参数等。

堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。

如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）2、C++（有子类继承父类的情况下）构造函数、析构函数的执行顺序先执行父类的构造函数，接着执行子类的构造函数，然后执行子类的析构函数，最后执行父类的构造函数。

3、介绍一下虚函数，虚函数的作用，怎么调用；只有虚函数的类叫什么，为什么？虚函数主要作用是现象多态性。

可以通过基类指针指向即可。

只有虚函数的类为抽象类。

因为只有虚函数的类不能实例化。

4、进程与线程的区别进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。

它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。

通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。

在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位。

答:线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别:(1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位(2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行(3)拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.(4)系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

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）。

malloc的用法和意义

malloc的用法和意义
1. 什么是malloc？
malloc（Memory Allocate）是一个C标准库函数，用于动态地分配内存空间。

它位于stdlib.h库文件中，可以在程序运行时为变量或数据分配指定长度的内存空间。

2. 如何使用malloc？
malloc函数需要传入一个参数，即所需内存空间的大小（以字节为单位），例如：
```
int* p = (int*)malloc(sizeof(int));
```
上述代码将分配一个整型变量大小（4字节）的内存空间，并将其首地址赋给指针变量p。

需要注意的是，malloc返回的指针类型是void*，需要通过强制类型转换为所需类型的指针使用。

3. malloc的意义
malloc在动态内存分配中具有重要的意义，它可以使程序在运行时根据需要分配内存空间，增加程序的灵活性和适应性。

通过malloc分配的内存空间是位于堆（Heap）或自由存储区（Free Store）中，不同于栈区的局部变量，堆中的内存空间在分配后不会自动回收，需要通过调用函数free手动释放，因此需要程序员自己负责内存的管理，避免出现内存泄漏或悬空指针等问题。

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模拟了析构函数的功能。

delete与free的区别

delete与free的区别1. delete 用于释放 new 分配的空间，free 有用释放 malloc 分配的空间2. delete [] 用于释放 new [] 分配的空间3. delete 释放空间的时候会调用相应对象的析构函数顺便说一下new在分配空间的时候同时会调用对象的构造函数，对对象进行初始化，使用malloc则只是分配内存4. 调用free 之前需要检查需要释放的指针是否为空，使用delete 释放内存则不需要检查指针是否为NULL5. free 和 delete 不能混用，也就是说new 分配的内存空间最好不要使用使用free 来释放，malloc 分配的空间也不要使用 delete来释放举个例子，<string.h>里通常有个strdup函数，它得到一个char*字符串然后返回其拷贝： char * strdup(const char *ps); // 返回ps所指的拷贝在有些地方，c和c++用的是同一个strdup版本，所以函数内部是用malloc分配内存。

这样的话，一些不知情的c++程序员会在调用strdup后忽视了必须对 strdup返回的指针进行free 操作。

为了防止这一情况，有些地方会专门为c++重写strdup，并在函数内部调用了new，这就要求其调用者记得最后delete。

你可以想象，这会导致多么严重的移植性问题，因为代码中strdup以不同的形式在不同的地方之间颠来倒去。

补充一个问题，free和delete 是如何知道需要释放的内存块的大小的？在调用malloc或new 分配内存空间的时候，实际分配的空间会比程序员申请的空间要大。

实际分配的内存空间前面有一部分空间用于保存所分配内存的大小，校验和等信息。

当分配函数返回时，将会返回实际可操作的地址（也就是实际分配空间加上前面用于记录分配信息的空间之后的地址）。

下面举个例子，例子通过破坏 new 返回地址的前面四个字节的数据导致内存空间释放出问题。

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++内存分配机制

cc++动态申请数组

new与delete区别

c语言中new和delete的用法

C++经典知识点面试题

c++——对象的动态建立和释放（new和delete）

堆分配存储的方法

C++面试宝典

c++面试题 自己整理比较全

详解C++中new运算符和delete运算符的使用

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

C语言经典面试题目及答案详解(三)

C++内存管理

堆栈的区别

C++常见笔试题

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

malloc的用法和意义

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

delete与free的区别

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

c++面试题自己整理比较全