【足迹C++primer】40、动态数组

动态数组
C++语言定义了第二种new表达式语法。能够分配并初始化一个对象数组。标准库中包括

一个名为allocator的类。同意我们将分配和初始化分离。

12.2.1 new和数组

void fun1()
{
int *pia=new int[2]; //pia指向第一个int
//方括号里的大小必须是整型，但不必是常量
typedef int arrT[42];    //arrT表示42个int的数组类型
int *p=new arrT;         //分配一个42个int的数组；p指向第一个int
//实际上，编译的时候还是这种
int *p1=new int[42];
}

分配一个数组会得到一个元素类型的指针

因为分配的内存并非一个数组类型。因此不能对动态数组调用begin或end

也不能使用范围for语句来处理动态数组中的元素

初始化动态分配对象的数组

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
//新标准中。我们还能够这样写
//10个int分别用列表中相应的值进行初始化
int *pia3=new int[10]{0,1,2,3,4,5,6,7,8,9};
//10个string类型的前面4个用给的值进行初始化。后面的进行值初始化
string *psa3=new string[10]{"a","an","the",string(3,'x')};

动态分配一个空数组是合法的

size_t n=10,n2=0;
int *p=new int
;  //分配数组保存元素
for(int* q=p ; q != p ; ++q)
{
/* 处理数组 */
}

若n为0，new会分配0个对象。

for循环中的条件会失败(p等于q+n,由于n为0)。

因此,循环体不会被运行

释放动态数组

int *p=new int;
int *pa=new int[110];
//为了释放动态数组，我们使用一种特殊形式的delete——在指针前加上一方括号对
delete p;  //p必须指向一个动态分配的对象或为空
delete [] pa;  //pa必须指向一个动态分配的数组或为空

typedef int arrT[42];      //arrT是42个int的数组的类型别名
int *p1=new arrT;           //分配一个42个int的数组;p指向第一个元素
delete [] p1;               //方括号是必须的，由于我们当初分配的是一个动态数组

无论外面怎样，p指向的是一个对象数组的首元素，而不是一个类型为arrT的单一对象。

因此释放的时候必须加上方括号

智能指针和动态数组

//up指向一个包括10个未初始化的int的数组
unique_ptr<int[]> up(new int[10]);
up.release();       //自己主动用delete[]销毁其指针
//当一个unique_ptr指向一个动态数组的时候我们能够用下标訪问数组中的元素
for(size_t i=0 ; i != 10 ; ++i)
up[i]=i;        //为每一个元素赋予一个新值

和unique_ptr不同，shared_ptr不直接支持管理动态数组。

假设希望shared_ptr管理一个动态

数组。那么就必须自己提供自定义的删除器

//为了适应shared_ptr,必须提供自定义的删除器
shared_ptr<int> sp(new int[10], [](int *p){delete [] p;});
sp.reset(); //使用我们提供的lambda释放数组，它使用delete[]
//shared_ptr没有定义下标运算，也不支持下标运算
for(size_t i=0 ; i != 10 ; ++i)
*(sp.get()+i)=i;        //使用get获取一个内置指针

12.23

/**
12.23
编写一个程序，链接两个字符串字面常量，将结果保存在一个动态分配的char数组中
重写这个程序。连接两个标准库string对象
*/
void fun6()
{
string s1="cutter",s2="_point";
unique_ptr<char[]> upc(new char[20]);

for(size_t i=0 ; i != s1.size()+s2.size() ; ++i)
{
if(i < s1.size())
upc[i]=s1[i];
else
upc[i]=s2[i-s1.size()];
}

for(int j=0 ; j != 20 ; ++j)
cout<<upc[j];

upc.release();      //自己主动用delete[]销毁其指针

}

12.2.2allocator类

普通情况下。将内存分配和对象构造结合在一起可能会导致不必要的浪费

int n;
string *const p=new string
;      //构造n个空string
string s;
string *q=p;        //q指向第一个string
while(cin>>s && q != p+n)
*q++=s;         //赋予*q一个新值
const size_t size=q-p;      //记住我们读取了多少个string
//使用数组
delete [] p;        //p指向一个数组;记得用delete[]来释放

可是。我们可能不须要n个string，少量string可能就足够了。

allocator类

int n;
allocator<string> alloc;        //可分配string的allocator对象
auto const p=alloc.allocate(n); //分配n各未初始化的string
/*
allocator分配微构造的内存
*/
auto q=p;     //这里q指向和p一样
alloc.construct(q++);   //*q为空字符串
alloc.construct(q++, 10, 'c');  //*q为cccccccccc
alloc.construct(q++, "hi");     //*q为hi!
//q指向最后构造的元素之后的位置
cout<<*p<<endl; //正确；使用string输出运算符
//    cout<<*q<<endl; //灾难：q指向微构造的内存

while(q != p)
alloc.destroy(--q);     //释放我们真正构造的string

所有代码展示

/**
* 功能:动态数组
* 时间:2014年7月9日10:05:01
* 作者:cutter_point
*/

#include<iostream>
#include<memory>
#include<string>
#include<vector>

using namespace std;

/**
C++语言定义了第二种new表达式语法，能够分配并初始化一个对象数组。

标准库中包括
一个名为allocator的类，同意我们将分配和初始化分离。
*/

/**
12.2.1 new和数组
*/
void fun1()
{
int *pia=new int[2]; //pia指向第一个int
//方括号里的大小必须是整型。但不必是常量
typedef int arrT[42];    //arrT表示42个int的数组类型
int *p=new arrT;         //分配一个42个int的数组。p指向第一个int
//实际上，编译的时候还是这种
int *p1=new int[42];
}

/**
分配一个数组会得到一个元素类型的指针
*/

/*
由于分配的内存并非一个数组类型，因此不能对动态数组调用begin或end
也不能使用范围for语句来处理动态数组中的元素
*/

/**
初始化动态分配对象的数组
*/
void fun2()
{
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
//新标准中。我们还能够这样写
//10个int分别用列表中相应的值进行初始化
int *pia3=new int[10]{0,1,2,3,4,5,6,7,8,9};
//10个string类型的前面4个用给的值进行初始化，后面的进行值初始化
string *psa3=new string[10]{"a","an","the",string(3,'x')};
}

/**
动态分配一个空数组是合法的
*/
void fun3()
{
size_t n=10,n2=0;
int *p=new int
;  //分配数组保存元素
for(int* q=p ; q != p ; ++q)
{
/* 处理数组 */
}

/*
若n为0。new会分配0个对象。

for循环中的条件会失败(p等于q+n,由于n为0)。

因此,循环体不会被运行
*/
}

/**
释放动态数组
*/
void fun4()
{
int *p=new int;
int *pa=new int[110];
//为了释放动态数组。我们使用一种特殊形式的delete——在指针前加上一方括号对
delete p;  //p必须指向一个动态分配的对象或为空
delete [] pa;  //pa必须指向一个动态分配的数组或为空

typedef int arrT[42];      //arrT是42个int的数组的类型别名
int *p1=new arrT;           //分配一个42个int的数组;p指向第一个元素
delete [] p1;               //方括号是必须的，由于我们当初分配的是一个动态数组

/*
无论外面怎样，p指向的是一个对象数组的首元素。而不是一个类型为arrT的单一对象。
因此释放的时候必须加上方括号
*/
}

/**
智能指针和动态数组
*/
void fun5()
{
//up指向一个包括10个未初始化的int的数组
unique_ptr<int[]> up(new int[10]);
up.release();       //自己主动用delete[]销毁其指针
//当一个unique_ptr指向一个动态数组的时候我们能够用下标訪问数组中的元素
for(size_t i=0 ; i != 10 ; ++i)
up[i]=i;        //为每一个元素赋予一个新值
/*
和unique_ptr不同，shared_ptr不直接支持管理动态数组。

假设希望shared_ptr管理一个动态
数组，那么就必须自己提供自定义的删除器
*/
//为了适应shared_ptr,必须提供自定义的删除器
shared_ptr<int> sp(new int[10], [](int *p){delete [] p;});
sp.reset(); //使用我们提供的lambda释放数组，它使用delete[]
//shared_ptr没有定义下标运算，也不支持下标运算
for(size_t i=0 ; i != 10 ; ++i)
*(sp.get()+i)=i;        //使用get获取一个内置指针
}

/**
12.23
编写一个程序，链接两个字符串字面常量，将结果保存在一个动态分配的char数组中
重写这个程序，连接两个标准库string对象
*/
void fun6()
{
string s1="cutter",s2="_point";
unique_ptr<char[]> upc(new char[20]);

for(size_t i=0 ; i != s1.size()+s2.size() ; ++i)
{
if(i < s1.size())
upc[i]=s1[i];
else
upc[i]=s2[i-s1.size()];
}

for(int j=0 ; j != 20 ; ++j)
cout<<upc[j];

upc.release();      //自己主动用delete[]销毁其指针

}

/**
allocator类
*/
/*
普通情况下，将内存分配和对象构造结合在一起可能会导致不必要的浪费
*/
void fun7()
{
int n;
string *const p=new string
;      //构造n个空string
string s;
string *q=p;        //q指向第一个string
while(cin>>s && q != p+n)
*q++=s;         //赋予*q一个新值
const size_t size=q-p;      //记住我们读取了多少个string
//使用数组
delete [] p;        //p指向一个数组;记得用delete[]来释放
/*
可是。我们可能不须要n个string。少量string可能就足够了。

*/
}

/*
allocator类
*/
void fun8()
{
int n;
allocator<string> alloc;        //可分配string的allocator对象
auto const p=alloc.allocate(n); //分配n各未初始化的string
/*
allocator分配微构造的内存
*/
auto q=p;     //这里q指向和p一样
alloc.construct(q++);   //*q为空字符串
alloc.construct(q++, 10, 'c');  //*q为cccccccccc
alloc.construct(q++, "hi");     //*q为hi!
//q指向最后构造的元素之后的位置
cout<<*p<<endl; //正确；使用string输出运算符
//    cout<<*q<<endl; //灾难：q指向微构造的内存

while(q != p)
alloc.destroy(--q);     //释放我们真正构造的string
}

int main()
{
fun6();
return 0;
}

PS：花了一早上，就搞了这么点东西，尽管中途歇息了一会。而且还玩了半个多小时的游戏

，可是哥还是把这玩意所有搞完了，哈哈搞完了就能够好好玩一玩啦！！