动态数组& allocator

问题来源

在编写程序的时候，对数组、“二维数组”的分配的删除掌握的不是很清楚，不能正确的进行定义初始化。
以及在使用vector的时候，如何正确的定义及初始化

注意！！！
尽量使用标准库容器vector而不是使用动态分配数组

动态数组

1.new 数组

int *pia=new int [10];                 // 10个未初始化的int
int *pia2=new int [10]() ;            // 10个初始化为0的int

string *psa=new string [10] ;       // 10个空string

string *psa2=new string [10]() ;   // 10个空string

delete [] pia;                             // 数组的释放
delete [] pia2; 

2.数组指针，指针数组

注意区分，在定义的过程中都会使用

int (*matrix)[10] ;                       //含有10个整数数组的指针
int matrix[][10];
// attention 
int *matrix [10];                         // 10个指针构成的数组

3.“二维数组”
c++中其实不存在“二维数组”，平常所说的二维数组是指 数组的类型是另一维数组；

int [2][3];            //是一个元素类型为 int[3] 的数组

new int[a][b]       //！！错误代码，没有确定数组的元素类型

// 使用new来创建二维数组，使用函数来展示其性质

void function1(int n)
{
    int i,j;
    int (*arr_2D)[5] = new int[n][5];  // 数组的元素类型为"int[5]"
    for(i=0;i<n;++i){
        for(j=0;j<5;++j){
            arr_2D[i][j]=i*5+j;
        }
    }
    delete [] arr_2D;                   // 数组的删除  
}

void function2(int n,int m)
{
    int i,j;
    int **arr_2D=new int *[n];             // n个指针组成的数组
    for(i=0;i<n;i++){
        arr_2D[i]=new int [m];          // 将每个指针指向一个数组
    }
    for(i=0;i<n;++i){                           // 进行赋值
        for(j=0;j<m;++j){
            arr_2D[i][j]=i*m +j;
        }
    }
    // delete
    // 先回收低级数组
    for(i=0;i<n;i++)
    {
        delete [] arr_2D[i];
    }
    // 回收高一级的数组
    delete [] arr_2D;
}

4.使用 vector

// 引入STL,会扩大程序 但是程序运行时间几乎不影响
#include<vector>
using namespace std;

vector<vector<int>> res (m, vector<int>(n,1))    // 构造n*m 数组 并将元素都初始化为1

allocator

• new & delete局限性
  new 内存分配和对象构造组合在一起
  delete 对象析构和内存释放组合在一起

• allocator类
  在头文件中
  允许分配内存和初始化进行分离。提供更好的性能及灵活的内存管理能力

分配的内存是未构造的

// how to use allocator
#include<memory>

allocator<string> alloc;                // 定义一个可以分配string的allocator对象
auto const p=alloc.allocate(n);      // 分配n个未初始化的string  

// 送了两个算法，在未初始化内存中创建对象，算法也在memory头文件中
uninitialized_copy(b,e,b2);        // 迭代器拷贝    begin-end
uninitialized_copy_n(b ,n,b2);   // begin开始  n个元素 拷贝到 b2开始的内存中
uninitialized_fill(b,e,t);            //  创建对象，对象的值均为 t的拷贝
uninitialized_fill_n(b, n,t);        // 到n n个对象



// 释放内存

allocator<T> a;
a.allocate(n);
a.deallocate(p,n);   // p指针开始
a.destory(p);        // 对p进行析构

一个使用的例子
将 一个有int的vector ，将其内容拷贝到动态内存中，我们分配一个比vector中元素所占空间大一倍的动态内存

拷贝到动态内存中，并将后一半空间定值填充。

#include<vector>
#include<iostream>
#include<memory>
vector<int> vi(10,1);
allocator<int> alloc;
auto p=alloc.allocate(vi.size() *2);   //  动态内存
auto q=uninitialized_copy(vi.begin(),vi,end(),p);  // 拷贝到p开始的内存 ，注意返回时递增后的目的位置迭代器
uninitialized_fill_n(q,vi.size(),0);                       //后一半空间的填充

转载于:https://www.cnblogs.com/GeekDanny/p/10728412.html