【C++语言】动态内存管理

简介: 【C++语言】动态内存管理

前言

本章要介绍的是动态内存管理:


  • 我们的定义的变量,储存位置在哪?
  • C动态内存管理方式:malloc/calloc/realloc/free
  • C++动态内存管理方式:new/delete
  • operator new与operator delete函数
  • new和delete的实现原理
  • 定位new表达式

内存管理

数据存储位置

不妨先来看看以下代码:看自己能否分清楚?

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在哪里?____

2. 填空题:
sizeof(num1) = ____;
sizeof(char2) = ____;      strlen(char2) = ____;
sizeof(pChar3) = ____;     strlen(pChar3) = ____;
sizeof(ptr1) = ____;
 

答案如下:

如果有困难的话,就可以往下看了。

需要存储的一些数据它的存储方式如下:

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);
 }

C语言动态内存管理方式

C语言的动态内存管理方式,我们其实已经了解了:malloc/calloc/realloc/free。就不过多介绍了,通过一个面试题来测试下自己的掌握情况: 【面试题】malloc/calloc/realloc的区别?

C++动态内存管理方式:new/delete

  1. 内置类型:
void Test1()
{
  //malloc~free
  // 动态申请一个int类型的空间
  int* ptr1 = (int*)malloc(sizeof(int));
  //动态申请一个int类型的空间并初始化为10
  int* ptr2= (int*)malloc(sizeof(int));
  if (ptr2 != NULL)
    *ptr2 = 10;
  // 动态申请10个int类型的空间
  int* ptr3 = (int*)malloc(sizeof(int)*10);
  free(ptr1);
  free(ptr2);
  free(ptr3);

  //new~delete
  // 动态申请一个int类型的空间
  int* ptr4 = new int;
  // 动态申请一个int类型的空间并初始化为10
  int* ptr5 = new int(10);
  // 动态申请10个int类型的空间
  int* ptr6 = new int[3];
  //动态申请4个int类型的空间并初始化为1,2,3,4
  int* ptr7=new int[4]{1,2,3,4};
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
  delete[] ptr7;
}


其实不难发现malloc和new在内置类型上都只是开辟空间,差别其实不大,最多就是多写几行代码。

  1. 自定义类型:
class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
  ~A()
  {
    cout << "~A():" << this << endl;
  }
private:
  int _a;
};
void Test2()
{
  //new~delete除了开辟空间,还会调用自定义类型的构造和析构函数。
  A* p1 = (A*)malloc(sizeof(A));
  A* p2 = new A(1);
  free(p1);
  delete p2;
}


从上方反汇编代码,我们可以清楚的看到,new调用了构造函数而delete调用了析构函数。而malloc和free并不会,这也是new和malloc的最大区别。


operator new与operator delete函数

那为什么有这样的区别呢?C语言过渡到C++,malloc到new,这会不会有什么关联呢?答案是肯定的。


1.new和delete是用户进行动态内存申请和释放的操作符

2. operator new 和operator delete是系统提供的全局函数

3.new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间。

4. operator new底层是mallocl来申请空间的,operator delete底层也是通过free来释放空间的


我们进入封装内容看下:

不信,我们来看看operator new代码呗:

//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 开辟空间,开辟的是自定义类型大小的空间;
  • 构造函数:主要是申请资源,也就是_array的空间申请;


  • delete的实现:
  • 析构函数:先释放_array申请的资源;
  • 释放空间:然后调用operator delete释放自定义类型空间;


补充:

new T[N]的原理

  1. 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对 象空间的申请
  2. 在申请的空间上执行N次构造函数


delete[]的原理

  1. 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
  2. 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释 放空间


定位new表达式(了解)

注意:这已经不是new了,而是new这个关键字的一个用法

new可以显示调用构造函数和析构函数,以下代码为定位new来模拟new和delete的实现过程。

int main()
{
  // p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
  
  A* p1 = (A*)malloc(sizeof(A));
  new(p1)A;  // 注意:如果A类的构造函数有参数时,此处需要传参
  p1->~A();
  free(p1);

  A* p2 = (A*)operator new(sizeof(A)); //开辟空间
  new(p2)A(10); //显式调用构造函数
  p2->~A();   //显式调用析构函数
  operator delete(p2);         //释放空间
  return 0;
}


常见面试题

malloc/free和new/delete的区别:

malloc/free和new/delete的共同点是:都是从堆上申请空间,并且需要用户手动释放。 不同的地方是:

1.malloc和free是函数,new和delete是操作符

2.malloc申请的空间不会初始化,new可以初始化

3.malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可, 如果是多个对象,[]中指定对象个数即可

4.malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型

5.malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要,但是new需 要捕获异常

6.申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new 在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成 空间中资源的清理


总结

本节主要是介绍空间内的存储,以及一些管理动态内存的方法。最重要的是new和delete的用法以及它的原理。

相关文章
|
10天前
|
存储 C语言 C++
【C/C++】动态内存管理( C++:new,delete)
C++的`new`和`delete`用于动态内存管理,分配和释放内存。`new`分配内存并调用构造函数,`delete`释放内存并调用析构函数。`new[]`和`delete[]`分别用于数组分配和释放。不正确匹配可能导致内存泄漏。内置类型分配时不初始化,自定义类型则调用构造/析构。`operator new`和`operator delete`是系统底层的内存管理函数,封装了`malloc`和`free`。定位`new`允许在已分配内存上构造对象,常用于内存池。智能指针等现代C++特性能进一步帮助管理内存。
|
10天前
|
存储 编译器 程序员
【C/C++】动态内存管理(C:malloc,realloc,calloc,free)
探索C++与C语言的动态内存管理:从malloc到new/delete,了解内存分布及栈、堆的区别。文章涵盖malloc、realloc、calloc与free在C中的使用,强调内存泄漏的风险。C++引入new和delete,支持对象构造与析构,还包括operator new和placement-new。深入分析内存管理机制,揭示C与C++在内存处理上的异同。别忘了,正确释放内存至关重要!
|
4天前
|
安全 算法 编译器
C++一分钟之-内存模型与数据竞争
【7月更文挑战第10天】了解C++11内存模型对多线程编程至关重要。它定义了线程间同步规则,包括顺序一致性、原子操作和内存屏障。数据竞争可能导致不确定行为,如脏读和丢失更新。可通过互斥量、原子操作和无锁编程避免竞争。示例展示了`std::mutex`和`std::atomic`的使用。掌握内存模型规则,有效防止数据竞争,确保多线程安全和性能。
11 0
|
11天前
|
存储 Java 程序员
Python和C++在内存管理方面有什么不同?
【7月更文挑战第2天】Python和C++在内存管理方面有什么不同?
13 0
|
11天前
|
Java C++ 开发者
如何根据项目需求选择使用C++还是Python进行内存管理?
【7月更文挑战第2天】如何根据项目需求选择使用C++还是Python进行内存管理?
16 0
|
2天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
22 10
|
7天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
39 9
|
2天前
|
存储 编译器 C语言
【C++基础 】类和对象(上)
【C++基础 】类和对象(上)
|
10天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
|
10天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。