C++从入门到放弃之：C++动态内存管理 `new`和`delete`

C++ 动态内存管理

1. C 动态内存管理

• 内存分配函数

malloc()/brk()/sbrk()/mmup()/realloc()/calloc()

• 内存释放函数

free()/brk()

2. C++ 动态内存管理

• 动态分配内存
  new和new[ ]可以根据数据类型自动动态分配内存空间

数据类型 * 指针名= new 数据类型;
数据类型 * 指针名= new 数据类型[数组大小];

• 释放内存
  delete和delete[ ]可以调用由new动态创建的对象析构函数,从而释放其内存空间

delete 指针名;
delete []指针名;

• 成对出现原则
  如果使用new[ ]动态创建了一个数组,数组中的每个元素都是一个对象,那么在使用delete[ ]时,将会调用数组中的每个对象的析构函数,有几个对象就会调用几次析构函数,因此new[ ]和delete[]要成对出现,

• Code
  new/delete

#include <iostream>
using namespace std;
int main (void){
   //int* pi = (int*)malloc(4);
   int* pi = new int;
   *pi = 100;
   cout<<*pi<<endl;//100
   //free(pi);
   delete pi;//防止内存泄露
   pi = NULL;//防止野指针
    return 0;
}

new[ ]/delete[ ]

#include<iostream>
using namespace std;
int main (void){
    //new数组
    int *parr = new int[10];
    for(int i=0;i<10;i++){
        parr[i]=i;
        cout << parr[i] <<' ';
    }
    cout << endl;
    delete[] parr;
    parr = NULL;
    //new数组同时初始化,c++11支持
    int *parr2 = new int[10]{9,8,7,6,5,4,3,2,1};
    for(int i=0;i<10;i++){
        cout << parr2[i] <<' ';
    }
    cout << endl;
    delete[] parr2;
    parr2 = NULL;
    return 0;
}

$ g++ arr.cpp -o arr
arr.cpp: In function ‘int main()’:
arr.cpp:14:29: warning: extended initializer lists only available with -std=c++11 or -std=gnu++11
     int *parr2 = new int[10]{9,8,7,6,5,4,3,2,1};
                             ^
$ ./arr
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0
$ g++ arr.cpp -o arr -std=c++11
$ ./arr
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0

#include <iostream>
using namespace std;
int main (void){
    //int* pi = (int*)malloc(4);
    int *pi = new int;
    *pi = 100;
    cout<<*pi<<endl;//100
    //free(pi)
    delete pi;//防止内存泄露
    pi = NULL;//防止野指针
    //动态分配内存,同时初始化
    int *pi2 = new int(200);
    cout<<*pi2<<endl;//200
    *pi2++;
    cout<<*pi2<<endl;
    (*pi2)++;
    cout<<*pi2<<endl;
    //delete pi2;//防止内存泄露
    return 0;
}

• 关于delete的问题

 #include <iostream>
using namespace std;
int main (void){
    int *p1;
//  delete p1;//释放野指针结果位置,危险
    int *p2 = NULL;
    delete p2;//没有意义
    int* p3 = new int;
    int* p4 = p3;
    //delete p3;
    delete p4;//连续释放
    return 0;
 }

2. C++ 动态内存管理的原理

原理是利用了编译器默认生成的operator new操作符分配对象和operator delete操作符释放对象,底层调用malloc()和free()函数

对象动态创建和销毁过程

1. 调用operator new分配对象所需要的内存编译器实现的operator new
2. 调用类中的构造函数
3. 调用类的析构函数
4. 调用operator delete编译器实现的operator delete

#include <iostream>

using namespace std;

class A {
public:
    A(){
        cout<<"create A"<<endl;
    }
    ~A(){
        cout <<"delete A"<<endl;
    }
    static void* operator new(size_t size){
        cout<<"malloc A"<<endl;
        void* pv = malloc(size);
    }
    static  void operator delete (void* pv){
        cout <<"free A"<<endl;
        free(pv);
    }
private:

};

int main() {

    //1>先分配内存
    // A* pa = A*A::operator new(sizeof(A));
    //2>在调用构造函数
    // pa->构造函数
    A* pa =new A;
    delete pa;
    return 0;
}

/home/panda/WorkSpace/memptr/cmake-build-debug/memptr
malloc A
create A
delete A
free A

进程已结束，退出代码 0