C++内存管理

文章目录

1. c的内存管理例题
2.c++管理方式
- 1.c++的内置类型
- - 1.申请一个空间并初始化
  - 2.申请连续的空间并初始化
  - 3.总结
- 2.c++的自定义类型
- - 2.总结
3.operator new与operator delete函数
4.new和delete的实现原理
- 1.内置类型
- 2.自定义类型
- - 内存泄露问题&&delete先析构的原因
  - 编译器实现机制问题
5.定位new
- 定位new的使用场景
6.malloc/free与new/delete的区别
- 1.共同点
- 2.不同点
- - 用法角度
  - 底层原理角度

1. 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在哪里？__C__   staticGlobalVar在哪里？__C__
   staticVar在哪里？_C___   localVar在哪里？___A_
   num1 在哪里？__A__
   
   char2在哪里？____   *char2在哪里？___
   pChar3在哪里？____      *pChar3在哪里？____
   ptr1在哪里？____        *ptr1在哪里？____
 - 填空题：
   sizeof(num1) = ____;  
    sizeof(char2) = ____;      strlen(char2) = ____;
   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
   */

globalvar: 是全局变量处于静态区
staticGlobalvar :是全局静态变量，处于静态区
staticvar : 是局部静态变量，处于静态区
localvar: 是局部变量，处于栈
num1 : 是一个局部的数组，处于栈

char2 是一个字符数组，处于栈
*char2 ：char2是一个数组名，由于既不单独放在sizeof内部，也没有取地址，数组名作为首元素地址，*char2是第一个元素，而整个数组处于栈中，所以 *char2处于栈
pchar3: 是一个由const修饰的字符类型指针，指针指向的内容不能改变，说明”abcd”是一个常量字符串，内容不能被修改，处于栈
*pchar3 :由于”abcd”是一个常量字符串，pchar3指向常量字符串，*pchar3 处于常量区
ptr1 :是一个指向堆开辟空间的指针，处于栈
*ptr :是为堆开辟的空间，处于堆
sizeof(num1): 单独当在sizeof内部，数组名代表整个数组，sizeof(num1)=40
– sizeof(char2):单独当在sizeof内部，数组名代表整个数组，abcd\0,sizeof(char2)=5
– sizeof(pChar3):pChar3是一个指针，所以sizeof(pChar3)=4/8
strlen(pChar3):pChar3代表首元素地址，strlen为从给予的地址开始到’\0’结束，strlen(pChar3)=4
– sizeof(ptr1):ptr1是一个指针，sizeof（ptr1)=4/8

2.c++管理方式

1.c++的内置类型

1.申请一个空间并初始化

#include<iostream>
using namespace std;
int main()
{
//int*ptr1=new int;//申请1个int的空间
    int* ptr = new int(10);//申请10个int的空间并初始化为10
 delete ptr;//释放单个空间

    return 0;
}

2.申请连续的空间并初始化

#include<iostream>
using namespace std;
int main()
{
    //int* ptr = new int(10);
    //int* ptr1 = new int[10];//申请10个int的空间
    int* ptr = new int[10] {1, 2, 3, 4};//申请10个int的空间并初始化
 delete []ptr;//释放连续空间
    return 0;
}

这里相当于部分初始化，只初始化了前4个空间，其他空间默认为0

3.总结

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

2.c++的自定义类型

#include<iostream>
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()
{
    A* p = (A*)malloc(sizeof(A) * 10);
    free(p);
    A* p1 = new A[2];
    delete[]p1;
    return 0;
}

申请2个A类型的空间，调用2次构造函数释放空间，并调用2次析构函数
虽然写入了malloc在堆开辟10个A类型空间，free释放空间，但是没有调用构造和析构函数

2.总结

在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

3.operator new与operator delete函数

operator new与operator delete函数是库里面提供的两个全局函数，不是运算符重载

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



#include <iostream>
using namespace std;
#include<iostream>
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()
{
    //申请空间 operator new  封装 malloc
    //在用operator delete p1指向空间
    A* p1 = new A;
    delete p1;

    //申请空间 operator new  封装 malloc
      //在用operator delete []p2指向空间
    A* p2 = new A[10];
    delete []p2;
    return 0;
}

4.new和delete的实现原理

1.内置类型

对于是内置类型，malloc/free与new/delete功能基本一致，但new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间

#include<iostream>
using namespace std;
int main()
{
    int* p1 = (int*)operator new(sizeof(int));//new失败抛异常
    int* p2 = (int*)malloc(sizeof(int));
    if (p2 == nullptr)//malloc失败返回空
    {
        perror("malloc fail");
    }
    return 0;
}

new机制与malloc也不同，new申请空间失败会抛异常，而malloc失败返回nullptr

2.自定义类型

#include<iostream>
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()
{
    A* p1 = new A;//先创建空间，在调用构造函数，
    delete p1;//delete先调用析构函数，在释放空间
    //-----------------------------------
    A* p2 = new A[10];//先创建空间，在调用构造函数10次
    delete[]p2;//delete先调用析构函数10次，在释放空间
    return 0;
}

new先申请一个A的空间，再调用构造函数，delete先调用析构函数，再释放空间
new先申请10个A类型的空间，再调用构造函数10次，delete先调用析构函数10次，再释放空间

内存泄露问题&&delete先析构的原因


class stack
{
public:
    stack()//构造
    {
        cout << "stack()" << endl;
        _a = new int[4];
        _top = 0;
        _capacity = 4;
    }
    ~stack()//析构
    {
        cout << "~stack()" << endl;
        delete[] _a;    
        _top = _capacity = 0;
    }
private:
    int* _a;
    int _top;
    int _capacity;
};
int main()
{
    stack p;
    stack*p1 = new stack;
    delete p1;
    return 0;
}

类的实例化对象生成p，在栈上，调用构造函数，在堆上开辟了4个stack类型的数组
p1是一个指针，在栈上，指向在堆上申请的一个stack，再调用构造函数，_a=new
stack[4]，_a再次指向在堆上申请的4个stack类型的数组，
所以必须先调用析构函数，在释放空间

原文链接：https://blog.csdn.net/qq_62939852/article/details/129015842