C++primer 阅读笔记---------------动态内存

该博客用于记录自己在阅读过程中不懂的知识点，很少用到但比较重要的知识点以及模棱两可的知识点

函数外的对象以及static对象， 类的static数据成员存储在静态内存，使用之前分配，程序结束销毁，栈内存用于保存函数内的非static变量，仅在该内存块存在，而动态分配的对象则存储在堆中

为了内存的安全，新的标准库提供类两种智能指针，shared_ptr允许多个指针指向同一个对象，unique_ptr独占式，还有一个week_ptr伴随类，它是一种弱引用，指向shared_ptr所管理的对象

shared_ptr<T> sp

unique_ptr<T> up

p.get() //返回p中保存的内置指针，如果智能指针释放类它的对象，则 返回指针所指对象也就没了

swap(p1, p2)

p1.swap(p2)

shared_ptr独有的操作

make_shared<T> (args) //返回一个shared_ptr，指向一个动态内存分配 的类型为T的对象，args初始化，最安全,替代 new

shared_ptr<T>p(q) //p是q的拷贝，q中的指针必须要能转换为 T*，并且q中的计数器会增加

p = q //会递减p原来指向对象的引用计数，递增q

p.unique() //若p.use_count()为1,则为true，否则false

p.use_count() //返回与p共享对象的只能指针数，效率可能很 慢，多用于调试

使用动态内存的原因大概有三个：

不知道自己需要使用多少对象 //容器类的元素都在堆上

不知道所需对象的准确类型

需要在多个对象间共享数据

虽然使用new和delete直接管理内存不安全，但我们还是应该了解

当使用new时，使用定位new向new传递额外参数

int *p = new (nothrow) int; //分配失败返回空指针，不再抛异常

指针delete过后，就变成类空悬指针，指向一块曾经保留数据对象但现在已经无效的内存的指针

接受指针参数的智能指针构造函数是explicit的，所以我们不能将一个内置指针隐式转换为一个智能指针

shared_ptr<int> p1 = new int(1024) //错误， 拷贝，不能隐式转换

shared_ptr<int> p1 (new int(1024)) //正确，直接初始化形式

统样的道理，返回时：

shared_ptr<int> clone(int p) {

return new int(p); //错误

return shared_ptr<int> (new int(p)); //正确

}

shared_ptr<T> p(q) //使用只能指针p管理内置指针q使用new分配的内存块

shared_ptr<T> p(u) //p从u（unique_ptr）那接管对象所有权，u置为空

shared_ptr<T> p(q, d) //使用可调用对象d替代delete

shared_ptr<T> p(p2, d) //p是p2的拷贝，但使用可调用对象d替代delete

p.reset() //将p置为空

p.reset(q) //p指向q

p.reset(q， d)

尽量避免混合使用内置指针和只能指针，也不要用get初始化另一个智能指针或者为另一个智能指针赋值

unique_ptr没有shared_ptr的make_shared(),定义unique_ptr时，需要绑定一个new返回的指针上，和shared_ptr一样必须采用直接初始化形式

unique_ptr<T> u1

unique_ptr<T, d> u2

unique_ptr<T, d> u(D) //类型为d的对象D代替delete

u = nullptr

u.release() //u放弃对指针的控制权，返回内置指针，将u置为空

u.reset() //释放对象

u.reset(q) //如果内置指针q存在，则u指向此对象，否则置为空

u.reset(nullptr)

unique_ptr不能拷贝或赋值，但有个例外，可以拷贝或赋值一个将要被销毁的

unique_ptr<int> clone(int p){

return unique_ptr<int> (new int(p));

}

或者返回一个局部对象的拷贝

unique_ptr<int> clone(int p){

return unique_ptr<int> ret(new int(p));

}

这种拷贝比较特殊，后面讨论它的特殊原因（挖坑）

weak_ptr是一种弱共享的指针，它必须指向一个由shared_ptr管理的对象，但weak_ptr不会影响计数器，因此不能直接使用weak_ptr，借助lock（），同时创建一个weak_ptr时要用一个shared_ptr来初始化

auto p = make_shared<int>(10);

weak_ptr<int> wp(p);

if(shared_ptr<int> np = wp.lock()){ //当wp指向的对象已经被销毁时返 回空的shared_ptr，if不成立

}

weak_ptr<T> w

weak_ptr<T> w(sp)

w = p

w.reset()

w.use_count() //与w共享对象的shared_ptr的数量

w.expired() //w.use_count()为0返回true

w.lock()

使用new动态分配的数组实际上得到的是一个数组元素类型的指针，所以不能对动态数组调用begin和end

可以使用智能指针管理动态数组，当管理的是动态数组时可以下标访问

unique_ptr<int []> up(new int[10]);

up[0] = i;

使用new缺乏一定的灵活性，因为它将内存分配和对象构造结合在了一起，delete类似，allocator类将内存分配和对象构造分开来

allocator<T> a //定义了一个allcator对象，它可以为类型为T的对象 分配内存

a.allocate(n) //分配保存n块T类型的对象的内存

a.deallocate(p, n) //释放从p开始的内存，该内存保存了n个T类型对象， 此时p和n必须和分配时一样，释放前要对其中的对 象执行destroy()

a.constructor(p, args) //p是一个类型为T*的指针，在p所指内存构建一 个对象，args被传递给所构建对象的构造函数

a.destroy(p) //p为T*指针，对所指对象执行析构函数

uninitialized_copy(b, e, p2); //b，e迭代器范围内的元素拷贝到p2迭代 器指定的原始内存

uninitialized_copy_n(b, n, p2); //迭代器b开始，拷贝n个

uninitialized_fill(b, e, t); //b，e范围创建对象，值为t

uninitialized_fill_n(b, n, t);