12 c++ 动态内存

红太狼 2023-03-01 09:16 42阅读 0赞

## 内存 ##

// 静态内存：保存 static数据 和 全局变量 等
    // 栈内存：保存局部变量
    // 堆内存（动态内存）：程序运行时分配的对象
    
    // c++ 动态内存管理使用 new 分配，delete 删除
    // c++ 提供了两种智能指针（行为像指针的类），可以安全的管理动态分配的内存，即使出现异常智能指针也能安全的释放内存

## 智能指针 ##

// shared_ptr，允许其他shared_ptr指针贡献一个内存，当所有的shared_ptr被销毁，内存也会被销毁
        // shared_ptr 维护一个引用内存的 计数器 ，为了在多个shared_ptr贡献这个计数器，同样将这个计数器放在动态内存中
        // 当一个shared_ptr被销毁或被赋予其他内存的引用（即不在引用该内存），则计数器减1，当计数器为0是，会使用delete销毁内存
        shared_ptr<vector<string>> sp1;
        if(sp1){ 
            cout << "has object" << endl; // 有指向对象
        }
        sp1.get();  // 返回 sp1 保存的指向动态内存（保存着vector<string>）的指针
    
        // sp2 从 sp1拷贝
        shared_ptr<vector<string>> sp2(sp1);
    
        shared_ptr<vector<string>> sp3;
        sp1.swap(sp3);      // 交换 sp1 和 sp3 的指针
    
        sp2 = sp3;          // sp2 指向 sp3 的内存
        sp1.use_count();    // 返回当前共享指针的数量
        sp1.unique();       // 当use_count为1时，返回true
    
        // 更安全的指针生成方式，传入参数为泛型参数指定的类型
        auto sp4 = make_shared<vector<string>>(vector<string>{  "a", "b" });
        for(auto s : *sp4){ 
            cout << s << endl;
        }
    
        { 
            // 离开此作用域，sp5会被 delete，sp5的析构函数被调用，由于共享内存只有sp5使用，所以sp5在析构函数中 delete共享内存
            auto sp5 = make_shared<vector<string>>(vector<string>{  "a", "b" });
        }
    
        // 通过new生成指针
        auto sp6 = make_shared<string>(string("aaa"));
        
        auto sp7 = make_shared<string>();
        sp6.reset(new string("aa"));        // 将sp6指向一个新对象
    
        // unique_ptr指针，只允许有一个指针指向当前内存，unique_ptr不支持拷贝操作（函数返回值的拷贝是一个特殊的拷贝）
        unique_ptr<vector<string>> up1;
        auto p1 = up1.release();    // 释放对内存的管理，返回指向该内存的指针
    	unique_ptr<vector<string>> up2(p1);     // up1释放了对内存的管理，那我们必须自己管理这个内存，这里使用up2接管内存
    
    	// 指针转换
    	std::shared_ptr<DFFile> file;
    	std::shared_ptr<Directories> dir = std::static_pointer_cast<Directories>(file);

## 自定义释放操作 ##

void customizeOpt(string *sp){ 
        delete sp;
    }
    
    void customizeOptTest(){ 
        // 默认释放操作时 delete 对象指针，但我们可以自定义释放操作
        shared_ptr<string> sp1(new string("aaa"), customizeOpt);
    
        unique_ptr<string, decltype(customizeOpt)*> up1(new string("aaa"), customizeOpt);
    }

## 自己管理内存 ##

// 直接管理内存，一般我们不希望直接管理
    int *np1 = new int;     // 分配一个int的内存，但未初始化
    delete np1;             // 不在使用np1后要删除
    int *np2 = new int(0);  // 分配一个int的内存，初始化未0
    delete np2;
    auto *np3 = new auto(string("aaa"));    // np3的类型是 string*
    delete np3;
    
    // 如果内存耗尽，返回空指针
    auto *np4 = new string("aaa");
    if(np4 == nullptr){ 
    }
    delete np4;
    
    const string *np5 = new const string("a");  // 常量指针
    delete np5;
    np5 = nullptr;      // 推荐在delete后将指针置为空
    
    int *arrp1 = new int[10];   // 分配数组
    delete [] arrp1;            // 删除数组

## 弱智能指针 ##

// weak_ptr，弱智能指针，保存share_ptr指向内存的指针和计数器，但不会增加share_ptr的计数器
    // 当weak_ptr检测到计数器为0时，将失效
    auto sp1 = make_shared<string>(string("aaaaaa"));
    weak_ptr<string> wp1(sp1);
    wp1.use_count();    // share_ptr的数量
    wp1.expired();      // 指向的内存是否失效
    sp1.reset(new string("aaaaaa"));      // 将共享指针指向新的内存，此时旧内存的计数器将变为0
    auto p = wp1.lock();         // 如果未失效，返回 share_ptr ，否则返回空的 share_ptr
    if(!p){ 
        cout << wp1.expired() << endl;      // 返回true
        cout << wp1.use_count() << endl;    // 返回0
    }
    wp1.reset();        // 置空物品wp1

## allocator内存分配与构造分离 ##

// 当我们希望将分配和对象构造分离时，可以使用allocator类
    allocator<string> alloc1;       // 空的内存
    auto start = alloc1.allocate(10);   // 分配10个string大小的内存，返回p指向内存的指针
    auto end = start;
    alloc1.construct(end, "a");     // 在第0个分配a
    end++;
    alloc1.construct(end, "ab");    // 在第1个分配b;
    end++;
    
    auto start1 = alloc1.allocate(20);  // 分配新的内存
    uninitialized_copy(start, end, start1);         // 将旧内存的对象拷贝到新内存，注：不要拷贝未构造的内存
    uninitialized_copy_n(start, 2, start1);         // 将旧内存的对象拷贝到新内存
    uninitialized_fill(start1, start1 + 20, "a");   // 填充对象
    
    while (end != start)
    { 
        end--;
        alloc1.destroy(end);        // 销毁end指向的对象，一旦元素被销毁，就可以重新使用这块内存
    }
    alloc1.deallocate(start, 10);   // 释放分配的内存

## 使用头文件 ##

#include <memory>