一个名为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];
}
分配一个数组会得到一个元素类型的指针
也不能使用范围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[n]; //分配数组保存元素
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]; //构造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[n]; //分配数组保存元素 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]; //构造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; }
，可是哥还是把这玩意所有搞完了，哈哈搞完了就能够好好玩一玩啦！！