【C/C++】动态内存管理( C++:new,delete)

简介: C++的`new`和`delete`用于动态内存管理,分配和释放内存。`new`分配内存并调用构造函数,`delete`释放内存并调用析构函数。`new[]`和`delete[]`分别用于数组分配和释放。不正确匹配可能导致内存泄漏。内置类型分配时不初始化,自定义类型则调用构造/析构。`operator new`和`operator delete`是系统底层的内存管理函数,封装了`malloc`和`free`。定位`new`允许在已分配内存上构造对象,常用于内存池。智能指针等现代C++特性能进一步帮助管理内存。

C++中的动态内存管理:new/delete
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。

new:
用于在运行时动态的分配内存并返回该内存的指针。它可以与数据类型一起使用,以指定要分配的内存大小和类型。例如,int* p = new int;这行代码会分配一个足以存储int类型数据的内存块,并将返回的地址赋值给指针p。
delete:
用于释放由new分配的内存。在C++中,必须显示释放不再需要的内存,以防止内存泄漏。delete运算符接受一个指针作为参数,并释放该指针指向的内存。例如,delete p;这行代码会释放之前由new为p分配的内存。
接下来,我们详细讲讲new和delete的用法。

new和delete操作内置类型

申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用new[]和delete[]。
下面可以来看一组代码案例:

// 动态申请一个int类型的空间
int ptr1 = new int;
cout <<
ptr1 << endl;

// 动态申请一个int类型的空间并初始化为10
int ptr2 = new int(10);
cout <<
ptr2 << endl;

// 动态申请10个int类型的空间
int ptr3 = new int[3];
for (int i = 0; i < 3; i++)
cout <<
(ptr3 + i) << " ";
cout << endl;

// 动态申请10个int类型的空间,并初始化
int ptr4 = new int[3] {1, 2};
for (int i = 0; i < 3; i++)
cout <<
(ptr4 + i) << " ";
cout << endl;

delete ptr1;
delete ptr2;
// 释放数组空间delete之后指针之前要加[]
delete[] ptr3;
delete[] ptr4;

以下是此段代码运行结果:

可以看出,单纯的new不会自动给内置类型初始化。所以,如果需要特定的值,需要像ptr2那样给动态申请的空间初始化。
通过ptr3和ptr4的对比,会发现,new同样不会对动态开辟的数组进行初始化,但是可以通过ptr4初始化数组的方式,此时,未被赋值的类型会自动初始化成0。

new和delete操作自定义类型
单纯拿new和delete对内置类型的操作来说,其实与C语言想必并没有什么太大的优势。但是C++中多了类这一个新的内容之后,new和delete就大有用武之地了。在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会。 自动调用构造和析构的作用可不小,当你的自定义类型有一个指针指向某一块资源的时候,就非常有必要了。自动调用构造和析构可以帮助你在动态内存管理的过程中自动开辟和释放指对象中的针指向的资源,很大程度上避免了空指针和内存泄露等问题。
下面可以看一段代码案例帮助理解:

include

using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】
// 除了开空间还会调用构造函数和析构函数
A p1 = (A)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
cout << endl;

// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;

A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];// 自动调用10次构造和析构
free(p5);
delete[] p6;
cout << endl;
return 0;

}

注:new和delete需要匹配使用,不要和C语言中的动态内存管理函数交叉,否则运行的结果是未定义的。

operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符,operator new 和operator delete是系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间。

我们可以简单来看一下,operator new与operator delete的全局定义:

/
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间
失败,尝试执行空 间不足应对措施,如果改应对措施用户设置了,则继续申请,否
则抛异常。
/
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);
}

/
operator delete: 该函数最终是通过free来释放空间的
/
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);
FINALLY
_munlock(_HEAP_LOCK); / release other threads /
__END_TRY_FINALLY
return;
}
/
free的实现
/

define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道,operator new 实际也是通过malloc来申请空间,如果malloc申请空间成功就直接返回,否则执行用户提供的空间不足应对措施,如果用户提供该措施就继续申请,否则就抛异常。operator delete 最终是通过free来释放空间的。

new和delete的实现原理
本质上说,new实际上就是operator new的一个封装,而operator new又是malloc的一个封装;delete实际上就是operator delete的一个封装,而operator delete又是free的一个封装。

内置类型:
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
自定义类型:
new的原理
调用operator new函数申请空间
在申请的空间上执行构造函数,完成对象的构造
delete的原理
在空间上执行析构函数,完成对象中资源的清理工作
调用operator delete函数释放对象的空间
new T[N]的原理
调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请
在申请的空间上执行N次构造函数
delete[]的原理
在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释放空间
定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式:
new (place_address) type 或new(place_address)type(initializer-list)
place_address必须是一个指针,initializer-list是类型的初始化列表。

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调构造函数进行初始化。

下面看一组代码案例:

include

using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
int _a;
};
// 定位new/replacement new使用演示
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
A p1 = (A)malloc(sizeof(A));
new(p1)A; // 注意:如果A类的构造函数有参数时,此处需要传参
p1->~A();
free(p1);
cout << endl;

A* p2 = (A*)operator new(sizeof(A));
new(p2)A(10);
p2->~A();
operator delete(p2);
cout << endl;

// 当你想创建多个对象,可以考虑使用循环
A* p3 = (A*)operator new(sizeof(A) * 4);
for (int i = 0; i < 4; i++)
    new(p3 + i)A(10);

for (int i = 0; i < 4; i++)
    cout << (p3 + i)->_a << " ";
cout << endl;
for (int i = 0; i < 4; i++)
    (p3 + i)->~A();
cout << endl;

// 要创建多个对象时,也可以这样使用定位new,编译器支持
A* p4 = (A*)malloc(sizeof(A) * 4);
new(p4)A[4] {1, 2, 3};
for (int i = 0; i < 4; i++)
    cout << (p4 + i)->_a << " ";
cout << endl;
for (int i = 0; i < 4; i++)
    (p4 + i)->~A();
free(p4);
cout << endl;
return 0;

}

运行结果如图:

结语
本篇博客详细讲解了C和C++中动态内存管理的方式,在C语言中,可以使用,malloc,realloc,calloc和free这四个函数进行动态内存管理;在C++中虽然也支持使用C中的四个函数,但新增的new和delete关键字能自动调用自定义类型的拷贝构造函数和析构函数,且开辟或释放失败后不再返回空指针,而是抛异常。我们同样讲到了operator new和operator delete这两个全局函数,它们通过封装能得到我们的new和delete。最后提到了定位new,可以支持给已经开辟的自定义类型空间进行构造或赋值。 关于内存管理的内容还不止于此,在后期的C++11的内容中,会讲到智能指针,内存泄露问题的规避管理等等知识。
博主后续还会产出更多有意思的内容,感谢大家的支持!♥

相关文章
|
24天前
|
存储 程序员 编译器
玩转C++内存管理:从新手到高手的必备指南
C++中的内存管理是编写高效、可靠程序的关键所在。C++不仅继承了C语言的内存管理方式,还增加了面向对象的内存分配机制,使得内存管理既有灵活性,也更加复杂。学习内存管理不仅有助于提升程序效率,还有助于理解计算机的工作原理和资源分配策略。
|
3月前
|
存储 缓存 编译器
【硬核】C++11并发:内存模型和原子类型
本文从C++11并发编程中的关键概念——内存模型与原子类型入手,结合详尽的代码示例,抽丝剥茧地介绍了如何实现无锁化并发的性能优化。
213 68
|
22天前
|
安全 C语言 C++
彻底摘明白 C++ 的动态内存分配原理
大家好,我是V哥。C++的动态内存分配允许程序在运行时请求和释放内存,主要通过`new`/`delete`(用于对象)及`malloc`/`calloc`/`realloc`/`free`(继承自C语言)实现。`new`分配并初始化对象内存,`delete`释放并调用析构函数;而`malloc`等函数仅处理裸内存,不涉及构造与析构。掌握这些可有效管理内存,避免泄漏和悬空指针问题。智能指针如`std::unique_ptr`和`std::shared_ptr`能自动管理内存,确保异常安全。关注威哥爱编程,了解更多全栈开发技巧。 先赞再看后评论,腰缠万贯财进门。
103 0
|
2月前
|
存储 程序员 编译器
什么是内存泄漏?C++中如何检测和解决?
大家好,我是V哥。内存泄露是编程中的常见问题,可能导致程序崩溃。特别是在金三银四跳槽季,面试官常问此问题。本文将探讨内存泄露的定义、危害、检测方法及解决策略,帮助你掌握这一关键知识点。通过学习如何正确管理内存、使用智能指针和RAII原则,避免内存泄露,提升代码健壮性。同时,了解常见的内存泄露场景,如忘记释放内存、异常处理不当等,确保在面试中不被秒杀。最后,预祝大家新的一年工作顺利,涨薪多多!关注威哥爱编程,一起成为更好的程序员。
|
4月前
|
存储 缓存 C语言
【c++】动态内存管理
本文介绍了C++中动态内存管理的新方式——`new`和`delete`操作符,详细探讨了它们的使用方法及与C语言中`malloc`/`free`的区别。文章首先回顾了C语言中的动态内存管理,接着通过代码实例展示了`new`和`delete`的基本用法,包括对内置类型和自定义类型的动态内存分配与释放。此外,文章还深入解析了`operator new`和`operator delete`的底层实现,以及定位new表达式的应用,最后总结了`malloc`/`free`与`new`/`delete`的主要差异。
94 3
|
4月前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
290 4
|
5月前
|
程序员 C++ 容器
在 C++中,realloc 函数返回 NULL 时,需要手动释放原来的内存吗?
在 C++ 中,当 realloc 函数返回 NULL 时,表示内存重新分配失败,但原内存块仍然有效,因此需要手动释放原来的内存,以避免内存泄漏。
|
24天前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
2天前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
31 16
|
6天前
|
安全 C++
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
45 6

热门文章

最新文章