数组与智能指针

shared_ptr数组

可以通过shared_ptr定义数组，但shared_ptr的析构函数只会释放数组的第一个对象，导致内存泄漏，因此需要提供删除器

也可采用自带的

shared_ptr<A> pVec(new A10, std::default_delete<A[]>());

shared_ptr<int>  p1 = new int(1024);
错误，因为shared_ptr的单参数构造器有explicit修饰，不能从内置类型直接转换成为对象！！，所以此行编译报错！！
shared_ptr<int> p1(new int(1024));正确，调用了单参数构造器进行初始化，传入了指针初始化

  std::shared_ptr<int> p4(new int, std::default_delete<int>());
  shared_ptr<int> b= make_shared<int>(10);

unique_ptr

unique_ptr没有重载operator*()所以，要使用unique_ptr指向的数组的话，就只能使用operator[]来
访问数组元素了，

#include <iostream>
#include<memory>
using namespace std;
 
int main()
{
//    shared_ptr<int[]> ps(new int[1000]);由于默认是delete，所以禁止new [] 
    unique_ptr<int[]> ps(new int[99]);
    for(int i = 0 ; i < 10 ; i++)
        ps[i] = 10 - i;用operator[]访问数组元素，同时也没有operator*和operator++等
    for(int i = 0 ; i < 10 ; i++)
        cout << ps[i] << endl;
    return 0;
}

拍_

关键使用：

①不要让auto_ptr和shared_ptr指向new[]申请的动态内存（除非为智能指针定义一个删除器）
原因：auto_ptr 和 shared_ptr 的默认释放内存方式是delete，如果动态对象是以new[] 形式创建的，比如数组，
就不要使用auto_ptr和shared_ptr，否则就会导致以delete形式去释放new[]申请的内存
一句话概括就是auto_ptr和shared_ptr只能指向new（除非为智能指针定义一个删除器）
② unique_ptr可以指向 new和new[] 申请的动态内存

e.g循环队列 智能指针

class MyCircularQueue {
    // int* data;
    // unique_ptr<int[]> data;

    int front,rear;
    int len;

    unique_ptr<int[]> data;
    

public:
    MyCircularQueue(int k) {
        // data=new int[k];
        // data(new int[k]);
        len=k;
        data=unique_ptr<int[]>(new int[len]);
        front=rear=-1;
    }
    ~MyCircularQueue() {
        // delete[] data;
    }
    bool enQueue(int value) {
        if(isFull())
            return false;
        if(isEmpty())
            front++;
        
        rear=(rear+1)%len;
        data[rear]=value;
        return true;
    }//rear后移一位,若到最后则转到数组头部
    
    bool deQueue() {
        if(isEmpty())
            return false;
        if(front==rear && front!=-1)//只剩一位
            front=rear=-1;//都需要置为-1
        else
            front=(front+1)%len;
        return true;

    }
    
    int Front() {
        if(isEmpty())
            return -1;
        return data[front];
    }
    
    int Rear() {
        if(isEmpty())
            return -1;
        return data[rear];
    }
    
    bool isEmpty() {
        if(front==rear && front==-1)
            return true;
        else
            return false;
    }
    
    bool isFull() {
        if(front==(rear+1)%len)
            return true;
        else
            return false;
    }
};