在这里,data-type 可以是包括数组在内的任意内置的数据类型,也可以是包括类或结构在内的用户自定义的任何数据类型。让我们先来看下内置的数据类型。例如,我们可以定义一个指向 double 类型的指针,然后请求内存,该内存在执行时被分配。我们可以按照下面的语句使用 new 运算符来完成这点:

double* pvalue = NULL; // 初始化为 null 的指针pvalue = newdouble; // 为变量请求内存

如果自由存储区已被用完,可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针,并采取以下适当的操作:

double* pvalue = NULL; if( !(pvalue = newdouble)){cout << "Error: out of memory." <<endl; exit(1); }

malloc() 函数在 C 语言中就出现了,在 C++ 中仍然存在,但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比,其主要的优点是,new 不只是分配了内存,它还创建了对象。

在任何时候,当您觉得某个已经动态分配内存的变量不再需要使用时,您可以使用 delete 操作符释放它所占用的内存,如下所示:

delete pvalue; // 释放 pvalue 所指向的内存

下面的实例中使用了上面的概念,演示了如何使用 new 和 delete 运算符:

实例

#include<iostream>usingnamespacestd; intmain(){double* pvalue = NULL; // 初始化为 null 的指针pvalue = newdouble; // 为变量请求内存 *pvalue = 29494.99; // 在分配的地址存储值cout << "Value of pvalue : " << *pvalue << endl; deletepvalue; // 释放内存return0; }

当上面的代码被编译和执行时,它会产生下列结果:

Value of pvalue : 29495

数组的动态内存分配

假设我们要为一个字符数组(一个有 20 个字符的字符串)分配内存,我们可以使用上面实例中的语法来为数组动态地分配内存,如下所示:

char* pvalue = NULL; // 初始化为 null 的指针
pvalue = new char[20]; // 为变量请求内存

要删除我们刚才创建的数组,语句如下:

delete [] pvalue; // 删除 pvalue 所指向的数组

下面是 new 操作符的通用语法,可以为多维数组分配内存,如下所示:

一维数组

// 动态分配,数组长度为 mint *array=newint[m]; //释放内存delete[]array;

二维数组

int **array; // 假定数组第一维长度为 m, 第二维长度为 n// 动态分配空间array = newint *[m]; for(inti=0; i<m; i++ ){array[i] = newint[n]; }//释放for(inti=0; i<m; i++ ){delete[]array[i]; }delete[]array;

二维数组实例测试:

实例

#include<iostream>usingnamespacestd; intmain(){int **p; inti,j; //p[4][8] //开始分配4行8列的二维数据 p = newint *[4]; for(i=0;i<4;i++){p[i]=newint[8]; }for(i=0; i<4; i++){for(j=0; j<8; j++){p[i][j] = j*i; }}//打印数据 for(i=0; i<4; i++){for(j=0; j<8; j++){if(j==0)cout<<endl; cout<<p[i][j]<<"\t"; }}//开始释放申请的堆 for(i=0; i<4; i++){delete[]p[i]; }delete[]p; return0; }

三维数组

int ***array; // 假定数组第一维为 m, 第二维为 n, 第三维为h// 动态分配空间array = newint **[m]; for(inti=0; i<m; i++ ){array[i] = newint *[n]; for(intj=0; j<n; j++ ){array[i][j] = newint[h]; }}//释放for(inti=0; i<m; i++ ){for(intj=0; j<n; j++ ){delete[]array[i][j]; }delete[]array[i]; }delete[]array;

三维数组测试实例:

实例

#include<iostream>usingnamespacestd; intmain(){inti,j,k; // p[2][3][4]int ***p; p = newint **[2]; for(i=0; i<2; i++){p[i]=newint *[3]; for(j=0; j<3; j++)p[i][j]=newint[4]; }//输出 p[i][j][k] 三维数据for(i=0; i<2; i++){for(j=0; j<3; j++){for(k=0;k<4;k++){p[i][j][k]=i+j+k; cout<<p[i][j][k]<<""; }cout<<endl; }cout<<endl; }// 释放内存for(i=0; i<2; i++){for(j=0; j<3; j++){delete[]p[i][j]; }}for(i=0; i<2; i++){delete[]p[i]; }delete[]p; return0; }

对象的动态内存分配

对象与简单的数据类型没有什么不同。例如,请看下面的代码,我们将使用一个对象数组来理清这一概念:

实例

#include<iostream>usingnamespacestd; classBox{public: Box(){cout << "调用构造函数!" <<endl; } ~Box(){cout << "调用析构函数!" <<endl; }}; intmain(){Box* myBoxArray = newBox[4]; delete[]myBoxArray; // 删除数组return0; }

如果要为一个包含四个 Box 对象的数组分配内存,构造函数将被调用 4 次,同样地,当删除这些对象时,析构函数也将被调用相同的次数(4次)。

当上面的代码被编译和执行时,它会产生下列结果:

调用构造函数!
调用构造函数!
调用构造函数!
调用构造函数!
调用析构函数!
调用析构函数!
调用析构函数!
调用析构函数!

AI 思考中...

C++ 异常处理

C++ 命名空间

6 篇笔记写笔记

#0
kikiqi
353***[email protected]
参考地址
178
delete 与 delete[] 区别:

1、针对简单类型使用 new 分配后的不管是数组还是非数组形式内存空间用两种方式均可如:
```
int *a = new int[10]; 
delete a; 
delete [] a; 
```
此种情况中的释放效果相同,原因在于:分配简单类型内存时,内存大小已经确定,系统可以记忆并且进行管理,在析构时,系统并不会调用析构函数, 它直接通过指针可以获取实际分配的内存空间,哪怕是一个数组内存空间(在分配过程中系统会记录分配内存的大小等信息,此信息保存在结构体_CrtMemBlockHeader中, 具体情况可参看VC安装目录下CRT\SRC\DBGDEL.cpp)

2、针对类Class,两种方式体现出具体差异

当你通过下列方式分配一个类对象数组:
```
class A
{
 private:
 char *m_cBuffer;
 int m_nLen;
 public:
 A(){ m_cBuffer = new char[m_nLen]; }
 ~A() { delete [] m_cBuffer; }
};
A *a = new A[10];
// 仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数 剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放 从而造成内存泄漏
delete a;
// 调用使用类对象的析构函数释放用户自己分配内存空间并且 释放了a指针指向的全部内存空间
delete [] a;
```
所以总结下就是,如果ptr代表一个用new申请的内存返回的内存空间地址,即所谓的指针,那么:
- delete ptr -- 代表用来释放内存,且只用来释放ptr指向的内存。
- delete[] rg -- 用来释放rg指向的内存,!!还逐一调用数组中每个对象的 destructor!!
对于像 int/char/long/int*/struct 等等简单数据类型,由于对象没有 destructor,所以用 delete 和 delete [] 是一样的!但是如果是C++ 对象数组就不同了!
kikiqi
kikiqi
353***[email protected]
参考地址
9年前 (2017年08月07日)

小高Carl

gao***[email protected]

利用动态内存, 我们也可以做出链表, 可以不断增长的数组:

#include <iostream>
#include <cstdio>
using namespace std;
struct node
{ 
 //链表的节点
 int data;//数据
 int num;//节点编号
 struct node *next;//指向下一个节点
};
int main()
{
 struct node *head/*头节点*/, *p, *q;
 head=NULL;
 p=NULL;
 q=new node;
 q->next=NULL;
 q->num=1;
 int a=-1;
 cout<<"请输入第1个数字:";
 cin>>a;
 q->data=a;
 head=q;
 while (a!=0)
 {
 p=q;
 q=new node;
 q->next=NULL;
 p->next=q;
 q->num=p->num+1;
 cout<<"请输入第"<<q->num<<"个数字:";
 cin>>a;
 q->data=a;
 }
 //前面都是输入,这以下都是输出
 q=head;
 p=NULL;
 while (q->data!=0)
 {
 printf("%d %d\n",q->num,q->data);
 q=q->next;
 }
 
 //释放内存
 q=head;
 p=q;
 while(q->next!=NULL)
 {
 p=q->next;
 delete []q;
 q = p; 
 }
 return 0;
}

->: 用指针访问结构体内的变量。

在链表中插入、删除节点也很简单, 先给next赋下一个节点地址,再加数据即可。

小高Carl

gao***[email protected]

9年前 (2017年11月21日)

#0
ぁ佌応妚弐☞
321***[email protected]
参考地址
105
new 和 malloc 内部的实现方式有什么区别?

new 的功能是在堆区新建一个对象,并返回该对象的指针。

所谓的【新建对象】的意思就是,将调用该类的构造函数,因为如果不构造的话,就不能称之为一个对象。

而 malloc 只是机械的分配一块内存,如果用 mallco 在堆区创建一个对象的话,是不会调用构造函数的。

严格说来用 malloc 不能算是新建了一个对象,只能说是分配了一块与该类对象匹配的内存而已,然后强行把它解释为【这是一个对象】,按这个逻辑来,也不存在构造函数什么事。

同样的,用 delete 去释放一个堆区的对象,会调用该对象的析构函数。

用 free 去释放一个堆区的对象,不会调用该对象的析构函数。

做个简单的实验即可明了:
```
#include <iostream>
#include <malloc.h>
class TEST
{
private:
 int num1;
 int num2;
public:
 TEST()
 {
 num1 = 10;
 num2 = 20;
 }
 void Print()
 {
 std::cout << num1 << " " << num2 << std::endl;
 }
};
int main(void)
{
 // 用malloc()函数在堆区分配一块内存空间,然后用强制类型转换将该块内存空间
 // 解释为是一个TEST类对象,这不会调用TEST的默认构造函数
 TEST * pObj1 = (TEST *)malloc(sizeof(TEST));
 pObj1->Print();
 // 用new在堆区创建一个TEST类的对象,这会调用TEST类的默认构造函数
 TEST * pObj2 = new TEST;
 pObj2->Print();
 return 0;
}
/*
运行结果:
-----------------------------
-842150451 -842150451 |
10 20 |
请按任意键继续. . . |
-----------------------------
我们可以看到pObj1所指的对象中,字段num1与num2都是垃圾值
而pObj2所指的对象中,字段num1与num2显然是经过了构造后的值
*/
```
ぁ佌応妚弐☞
ぁ佌応妚弐☞
321***[email protected]
参考地址
8年前 (2018年04月25日)

lclz

610***[email protected]

第二个笔记,思路是好的,但是错误的。这种写法最后会是一个 data 为 0 的结点,但遍历和析构时用 data 为 0 判断结束而导致缺少对 data 为 0 结点的操作,改正如下:

#include<iostream>
using namespace std;
struct node
{
 //链表的节点
 int data;//数据
 int num;//节点编号
 struct node *next;//指向下一个节点
};
int main()
{
 struct node *head/*头节点*/, *p, *q;
 head = NULL;
 p = NULL;
 q = new node;
 q->next = NULL;
 q->num = 1;
 int a = -1;
 cout << "请输入第1个数字:";
 cin >> a;
 q->data = a;
 head = q;
 while (a != 0)
 {
 p = q;
 q = new node;
 q->next = NULL;
 p->next = q;
 q->num = p->num + 1;
 cout << "请输入第" << q->num << "个数字:";
 cin >> a;
 q->data = a;
 }
 //前面都是输入,这以下都是输出
 q = head;
 p = NULL;
 while (1)
 {
 printf("%d %d\n", q->num, q->data);
 if (q->data == 0)
 break;
 q = q->next;
 }
 //释放内存
 q = head;
 p = q;
 while (1)
 {
 p = q->next;
 delete[]q;
 q = p;
 if (!q)
 break;
 }
 return 0;
}

lclz

610***[email protected]

6年前 (2020年09月08日)

三维power

dua***[email protected]

#include <iostream>
using namespace std;
 
int main()
{
 int *p; 
 int i;
 p = new int [4];
 for(i=0;i<4;i++){
 p[i]=i;
 }
 
 //打印数据 
 for(i=0; i<4; i++){
 cout<<p[i]<<"\t\t"; 
 } 
 
 //开始释放申请的堆 
 delete [] p; // 理论上:删除p指向的整个数组。
 //delete p; // 理论上:删除p指向的数组的第一个int 元素。验证不会报错。
 //delete *p; //报错。语法错误。
 
 cout <<"\n";
 cout <<p[0]<< "\t\t";
 cout <<p[1]<< "\t\t";
 cout <<p[2]<< "\t\t"; 
 cout <<p[3]<< "\t\t";
 
 // 给p重新赋值。能打印出结果。说明p变量本身并没有被销毁。销毁的是它指向的变量。
 int a = 20;
 p = &a;
 cout<<"\n"<<*p;
 
 return 0;
}

实际验证结果:

放开 delete [] p; 注释 delete p; 运行结果:

0 1 2 3 
0 0 30150672 0 
20

注释 delete [] p; 放开 delete p; 运行结果:

0 1 2 3 
0 0 7651344 0 
20

无论 delete [] p 还是 delete p, 运行结果竟然是一样的。

三维power

dua***[email protected]

4年前 (2022年09月14日)

#0
caucy
237***[email protected]
13
针对上一个问题,delete[] p和delete p对于简单类型的释放没什么太大区别,但对于举的例子而言,前者确实会释放整个数组内存,后者只释放数组开头元素的内存。但验证的方法不对,在delete操作后p实际上成为了野指针,不再指向任何有效值。这也是为什么打印出了两个奇怪值的原因。
caucy
237***[email protected]
3年前 (2023年05月04日)

菜鸟教程 -- 学的不仅是技术,更是梦想!

C++ 面向对象

C++ 高级教程

C++ 资源库

C++ 动态内存

new 和 delete 运算符

实例