动态内存与智能指针

1 静态内存：保存局部static对象、类static成员、定义任何函数之外的变量

   栈内存：用来定义函数内的非static对象

   自由空间（堆）：用堆来存储动态内存，动态内存与其他内存的区别在于，动态内存的生存期由程序控制

2 new     在动态内存中为对象分配一个空间，并返回一个指向该对象的指针

   delete  接受一个动态对象的指针，并销毁这个对象，释放与之关联的内存空间

3 标准库中有两种智能指针来管理动态对象：shared_ptr 允许多个指针指向同一个对象、unique_ptr独占所指向的对象

                                                                    weak_ptr弱引用伴随类，指向shared_ptr所管理的对象

4 智能指针与普通指针最大的区别在于，智能指针自动释放所指向的对象。

5 shared_ptr类

   shared_ptr<string> p1;创建一个智能指针，可以指向string

   shared_ptr<string> p2=make_shared<string>("mmm");   make_shared

6 strblob模板

   StrBlob b1;
    {
        string temp[] = { "a", "an", "the" };
        StrBlob b2(temp, temp + sizeof(temp)/sizeof(*temp));
        b1 = b2;  
        b2.push_back("about");
        cout << b2.size() << endl;
    }

    cout << b1.size() << endl;  b2被销毁了，但是temp的内容仍然被b1保存着

7 直接管理动态内存：new分配内存，delete释放内存

   int *p1=new int;  未定义的int，delete p1是错误的，因为未定义

   int *p1=new int(); *p1为0

   string *p2=new string(10,'9');

   vector<int> *p3=new vector<int>{0,1,2,3,4,5,6,7};

8 shared_ptr与new可以结合使用

   shared_ptr<double> p1;

   shared_ptr<int> p2(new int(42)); 必须使用直接初始化，使用等于号的是间接初始化，错误

   p2.reset（new int（1024））;指向一个新对象

9 unique_ptr 只能有一个unique指定一个给定对象，定义一个unique_ptr时要将它绑定到一个new返回的指针上。

   unique_ptr<int> p(new int(42));不支持拷贝与赋值

   unique_ptr<string> p2(p1.release());  release放弃对*p1的控制权,将*p1空间置空，并返回指针，相当于票转移给p2

   p2.reset(p3.release()); 从p3转移给p2;

   quto p=p2.release(); 不用另一个智能指针保存返回的指针要记得delete p；

10 weak_ptr 不控制对象所指向对象的生存期，指向一个shared_ptr管理的对象。

     auto p=make_shared<int>(42);

     weak_ptr<int> wp(p);  p的引用

11 动态数组

      typedef int arrt[42];

      int *p=new arrt;          p指向第一个int，new返回的是一个元素类型的指针

      int *p=new int[42]();   初始化为0的int

      int *p=new int[42]{0，1, 2, 3, 4, 5}；

      int n；

      int *p=new int[n];合法

      delete [] p；

 

12 智能指针与动态数组

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

     up[1]=1;  up[i] 返回up拥有的数组中，i处的位置

13 allocator类

     将内存分配与构造对象分离开 ，它分配的内存是原始的，未构造的。

     allocator<string> a;

     a.allocate(10);