前言
本篇博客讲解一下c++的类和对象,看这个之前请先看:C++入门基础-CSDN博客
💓 个人主页:普通young man-CSDN博客
⏩ 文章专栏:C++_普通young man的博客-CSDN博客
⏩ 本人giee:普通小青年 (pu-tong-young-man) - Gitee.com
若有问题 评论区见📝
🎉欢迎大家点赞👍收藏⭐文章
目录
C语言中动态内存管理方式:malloc/calloc/realloc/free
operator new与operator delete函数
c++的内存分布
在学习C语言的当中,我们就学过内存管理,但是在c++当中我们优化了这里,首先我们看看一看这些代码(请选出答案放在评论区):
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
1. 选择题:
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里?____
staticGlobalVar在哪里?____
staticVar在哪里?____
localVar在哪里?____
num1 在哪里?____
char2在哪里?____
*char2在哪里?___
pChar3在哪里?____
*pChar3在哪里?____
ptr1在哪里?____
*ptr1在哪里?____
【说明】
栈(Stack):
- 栈是一种用于管理局部变量、函数参数以及函数调用返回地址的数据结构。
- 它遵循“后进先出”(LIFO)原则,这意味着最后压入栈的数据将最先被弹出。
- 栈是向下增长的,即当内存被分配或释放时,栈指针会向低地址移动或回退。
内存映射段(Memory Mapping Segment):
- 这是一种高效的I/O操作方法,通过将文件或其他对象直接映射到进程的地址空间,允许进程像访问内存一样读写这些对象。
- 内存映射可以用于创建共享内存区域,从而实现进程间的通信。
堆(Heap):
- 堆用于程序运行时的动态内存分配,比如通过
malloc()
、new
等函数申请的内存。- 堆的大小可以动态调整,通常是从低地址向高地址增长。
数据段(Data Segment):
- 数据段用于存储全局变量和静态变量。
- 在程序启动时,这部分内存就已经初始化,并且在程序运行期间保持不变。
代码段(Code Segment):
- 又称为文本段(Text Segment),用于存放编译后的机器码指令和只读常量。
- 这部分内存通常是只读的,以防止程序意外修改自身的指令集。
C语言中动态内存管理方式:malloc/calloc/realloc/free
void Test ()
{
// 1.malloc/calloc/realloc的区别是什么?
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗?
free(p3 );
}
c++的内存管理方式
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因 此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。
int main() {
//动态申请一个int类型的空间
int* p1 = new int;
//动态申请一个int类型的空间,并初始化为10
int* p2 = new int(10);
//动态申请一个10个int类型的空间
int* p3 = new int[10];
//释放
delete(p1);
delete(p2);
delete[](p3);
}
注意:申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用 new[]和delete[],注意:匹配起来使用。
我们来看几段代码,探讨一个问题
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0);
~A();
private:
int _a;
};
A::A(int a) :_a(a)
{
cout << "构造" << endl;
}
A::~A()
{
cout << "析构" << endl;
}
int main() {
A* p = new A;
cout << "$$$$$$$$$$$$$$" << endl;
delete(p);
}
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0);
~A();
private:
int _a;
};
A::A(int a) :_a(a)
{
cout << "构造" << endl;
}
A::~A()
{
cout << "析构" << endl;
}
int main() {
A* p = new A[10];
cout << "$$$$$$$$$$$$$$" << endl;
delete[](p);
}
发现了什么?
是不是发现当我们用new这个关键字来开辟空间的时候会自动调用构造函数,反之delete关键字会调用析构,我们来看你一下汇编代码:
为什么会这样?那我们就来探讨new delete的底层
operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符,operator new 和operator delete是 系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过 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来释放空间的。
这边我简单的给大家展示一下抛异常:
可以看一下申请了多少后抛的异常:
我这边是3个1024相乘 == 1G,这里申请了27个G,这个不是真的申请了这么多,这个是虚拟内存,需要映射在物理内存,而计算机比较聪明是不会映射27个G,其实你是不可能用到这么多的。
我们看一下小一点的
结果一样,还是说一下这个虚拟内存,不是物理内存,我的内存条才16g。只是说让你知道这个知识
#include<iostream>
using namespace std;
void func() {
int a = 0;
while (1)
{
void* p = new char[1024 ];
a++;
cout << a << endl;
}
}
int main() {
try
{
func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
}
new和delete的实现原理
5.1 内置类型
- 对于内置类型如
int
,char
,double
等,new
和malloc
都可以用来分配内存,但是:
new
在分配失败时会抛出异常,而malloc
则返回NULL
。new
和delete
通常用于单个元素,而new[]
和delete[]
用于分配和释放连续的数组空间。5.2 自定义类型
new
和delete
的原理
new
操作符的工作流程如下:
- 调用
operator new
函数来分配内存。- 在分配的内存上构造对象,调用相应的构造函数。
delete
操作符的工作流程如下:
- 调用对象的析构函数,进行必要的资源清理。
- 调用
operator delete
函数释放内存。
new[]
和delete[]
的原理
new[]
操作符用于分配连续的数组空间:
- 调用
operator new[]
函数,内部可能多次调用operator new
来分配足够大的内存块。- 对每个元素调用构造函数。
delete[]
操作符用于释放数组空间:
- 对数组中的每个元素调用析构函数。
- 调用
operator delete[]
函数,它可能内部调用operator delete
来释放内存。实现细节
operator new
和operator delete
是用户可以重载的运算符,用于自定义内存分配和释放的行为。_free_dbg
和_malloc_dbg
等函数提供了调试版本的内存管理,它们包含了额外的检查和跟踪信息,例如验证块类型和线程锁等,以帮助开发者检测潜在的内存问题。总之,
new
和delete
不仅分配和释放内存,还负责构造和析构对象,这使得它们成为管理自定义类型时更强大的工具,而malloc
和free
主要用于简单的内存管理,不涉及构造和析构过程。
定位new表达式(placement-new)
这个简单理解就是脱了裤子放屁
定位
new
表达式(placementnew
)是一种特殊的new
操作,它不是为了分配内存,而是为了在已经预分配好的内存位置上调用构造函数,从而初始化一个对象。这种技术在内存池、缓存管理和某些高级数据结构中非常有用,因为它允许你更精细地控制内存的分配和使用。使用格式
定位
new
的语法如下:
new (place_address) type;
new (place_address) type(initializer_list);
place_address
必须是一个指向足够大内存的指针,该内存之前已经被分配。type
是你想在指定内存位置上创建的对象类型。initializer_list
是用于初始化对象的构造函数参数列表。使用场景
定位
new
表达式主要在以下情况下使用:
- 内存池管理:在预先分配的大块内存中创建对象,避免频繁的小块内存分配和释放带来的开销。
- 缓存系统:在缓存中创建和销毁对象,缓存提供预分配的内存。
- 复用对象:在对象被销毁后,同一块内存可以用来创建新的对象,避免了重新分配内存的成本。
- 复杂数据结构:在固定大小的内存中创建对象,例如在环形缓冲区中。
示例
简单说定位new就是跳过了malloc这这一段,直接在指定的内存里面构造
这是对比,你会觉得感觉多此一举,脱了裤子放屁,我给你看一种场景
你会发现p的地址和arr的地址是一样的,这就是指定内存中构造,我用指定一个类也是一样的
这边打印了A就说明调用了构造函数
#include<iostream> using namespace std; class A { public: A(int n = 10); ~A(); private: int _a; }; A::A(int n) :_a(n) { cout << "A" << endl; } A::~A() { cout << "~A" << endl; } int main(){ //int arr[512];//内存池 A *p = (A*)malloc(sizeof(A)); //使用定位new在对应的内存上进行构造 A * p1 = new(p)A; cout << p1 << endl; cout << p << endl; cout << sizeof(p) << endl; cout << sizeof(A) << endl;//这是类的大小 cout << sizeof(p1) << endl; /*cout << p << endl; cout << p + 0xf << endl;*/ //cout << arr << endl; //直接使用new构造 //int* p2 = new int; //cout << p2 << endl; } // //int main() { // // // //对比 // // A* p1 = new A(1); // delete p1; // // A* p2 = (A*)operator new(sizeof(A)); // new(p2)A(1); // // p2->~A(); // operator delete(p2); //}
malloc/free和new/delete的区别
malloc
和free
与new
和delete
在C++中用于动态内存管理,但它们之间存在关键的区别。下面总结了两者的主要共同点和不同之处:共同点
- 堆内存分配:
malloc
和free
以及new
和delete
都用于从堆内存中分配和释放空间。- 手动管理:无论是使用
malloc
/free
还是new
/delete
,程序员都必须显式地管理内存,包括分配和释放。不同点
性质不同:
malloc
和free
是标准C库中的函数,用于原始内存分配和释放。new
和delete
是C++的操作符,提供了更高级的内存管理功能,特别是在处理类和对象时。初始化:
malloc
分配的内存不会被初始化,意味着它可能包含任意的垃圾值。new
不仅分配内存,还可以初始化对象,尤其是当使用自定义类型的对象时,它会调用构造函数。类型安全和大小计算:
- 使用
malloc
时,你需要手动计算所需的空间大小并将其作为参数传递。new
更加类型安全,你只需指定对象类型或数组类型,编译器会自动计算所需的内存大小。返回值和类型转换:
malloc
返回void*
类型的指针,使用时通常需要显式类型转换。new
返回与所创建对象类型匹配的指针,无需显式类型转换。错误处理:
- 当
malloc
无法分配足够的内存时,它返回NULL
,使用时需要检查是否为NULL
。new
在无法分配内存时抛出std::bad_alloc
异常,需要通过异常处理机制来捕获和处理。自定义类型对象的构造和析构:
malloc
和free
不会调用构造函数或析构函数,因此对于自定义类型,仅分配和释放内存而不进行对象的初始化或清理。new
在分配内存后会调用构造函数来初始化对象,而delete
在释放内存前会调用析构函数来清理对象中的资源。了解这些差异有助于在编写C++程序时做出更合适的内存管理选择。对于自定义类型的对象,使用
new
和delete
是更安全和更方便的选择,因为它自动处理了构造和析构过程。而对于简单的数据类型或不需要构造和析构的情况,malloc
和free
可能更加直接和高效。