内存分配和对象构造分离使用

迷南。 2022-01-31 23:23 162阅读 0赞

### 文章目录 ###

*   *  前言
     *  allocator 类

## 前言 ##

new有一些灵活性上的局限，其中一方面表现在它将内存分配和对象构造组合在了一起。类似的，delete将对象析构和内存释放组合到了一起。这样会给我们在特定情况下带来一些不必要的浪费，同时带来性能上不必要的消耗。  
举个例子：

std::string* const p = new std::string[n];
    std::string s;
    std::string* q = p;
    while(std::cin >> s && q != p + n){ 
    	*q++ = s;
    }
    const size_t size = q - p;
    delete[] p;

对上面代码的解释：  
new表达式分配并初始化了n个string，但是，我们可能不需要n个string，少量string就足够了。这样一来，我们就可能创建了一些永远也用不到的对象（无端调用构造函数造成性能损耗）。而且，对于那些确实要使用的对象，我们也在初始化之后立即赋予了它们新值，每个使用到的元素都被赋值了两次：第一次是默认初始化时，第二次是我们手动赋值时。还有一点，那些没有默认构造函数的类，如果想要动态分配数组，我们就得自定义一个构造函数。

**所以，在一些特定情况下，我们有必要将内存分配和对象构造分离开来。**

## allocator 类 ##

> 标准库allocator类定义在头文件<memory>中，它可以帮助我们把内存分配和内存构造分离开来。

<table> 
 <thead> 
  <tr> 
   <th>allocator类提供的接口</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>allocator&lt;T&gt; a</td> 
   <td>定义了一个名为a的allocator对象，a可以为类型为T的对象分配内存</td> 
  </tr> 
  <tr> 
   <td>a.allocate(n)</td> 
   <td>分配一段原始的内存，足以保存n个类型为T的对象。返回指向这段内存起始地址的指针</td> 
  </tr> 
  <tr> 
   <td>a.deallocate(p, n)</td> 
   <td>释放从T*指针p中地址开始的内存，这块内存保存了n个类型为T的对象</td> 
  </tr> 
  <tr> 
   <td>a.construct(p, args)</td> 
   <td>p为T*类型的指针，指向一块原始内存。arg被传递给类型为T的构造函数，用来在p指向的内存中构造一个对象</td> 
  </tr> 
  <tr> 
   <td>a.destroy(p)</td> 
   <td>p为T*类型的指针，此算法对p指向的对象执行析构函数</td> 
  </tr> 
 </tbody> 
</table>

使用示例：

#include <string>
    #include <memory>
    
    int main(){ 
        std::allocator<std::string> alloc; //定义一个可以分配string的allocator对象
        auto const p = alloc.allocate(3); //分配3个未初始化的string
        auto q = p; //q和p指向最后构造的元素之后的位置(由于还未构造，所以均指向刚分配的原始内存的起始地址)
        alloc.construct(q++); //*q为空字符串
        alloc.construct(q++, 10, 'c'); //*q为cccccccccc
        alloc.construct(q++, "reinterpret"); //*q为reinterpret
        
        std::cout << *p << std::endl; //可以操控分配的内存上已经构造的对象
        std::cout << *q << std::endl; //error：因为q此时指向未构造的内存
        //当使用完对象后，对每个构造的元素调用destroy，destroy会调用对象的析构函数
        while(q != p){ 
            alloc.destroy(--q);
        }
        //调用完destroy后，手动释放刚才分配的原始内存
        alloc.deallocate(p, 3);
        
        return 0;
    }